Java基础编程(01)--I/O系统

File(String path)
File(File parent, String child)
File(String parent, String child)

public class CreateFileTest {
    public static void main(String[] args) throws IOException {
        File file = new File("/home/smartkeyerror/JavaProjects/LearningJava/hello.txt");
        boolean isCreated = file.createNewFile();
        System.out.println(isCreated);

        File file1 = new File("/home/smartkeyerror/JavaProjects/LearningJava", "hello1.txt");
        boolean isCreated1 = file1.createNewFile();
        System.out.println(isCreated1);

        File file2 = new File(new File("."), "hello2.txt");
        boolean isCreated2 = file2.createNewFile();
        System.out.println(isCreated2);
    }
}

File fileNew = new File(".");
File[] files = fileNew.listFiles();
for (File file3 : files) {
    System.out.println(file3.getName());  // 获取文件或目录名称
    System.out.println(file3.isDirectory());  // 判断是否为目录
    System.out.println(file3.isFile());  // 判断是否为文件
}

File file = new File(".");
String[] files = file.list(new FilenameFilter() {
    public boolean accept(File dir, String name) {
        return name.endsWith(".txt");
    }
});

public String[] list(FilenameFilter filter) {
    String names[] = list();
    /** 当filter为null时直接返回names数组 */
    List<String> v = new ArrayList<>();
    for (int i = 0 ; i < names.length ; i++) {
        if (filter.accept(this, names[i])) {
            v.add(names[i]);
        }
    }
    return v.toArray(new String[v.size()]);
}

public int read(byte b[], int off, int len) throws IOException

public class FileReadTest {
    public static void main(String[] args) throws IOException {
        /* 创建文件对象 */
        File file = new File(".", "hello.txt");
        /* 创建buffer数组， 大小为4096 */
        byte[] buffer = new byte[4096];
        /* 传入文件文对象， 打开一个流 */
        FileInputStream fileInputStream = new FileInputStream(file);

        int length = 0;
        /* 当文件没有读完时， 将所读取到的数据转换成为字符并向控制台输出 */
        while ((length = fileInputStream.read(buffer, 0, 4096)) != -1) {
            String string = new String(buffer, 0, length);
            System.out.println(string);
        }
        /* 最后需要关闭这个流 */
        fileInputStream.close();
    }
}

public class FileOutputTest {
    public static void main(String[] args) throws IOException {

        FileOutputStream fileOutputStream = new FileOutputStream("hello.txt");

        StringBuilder buffer = new StringBuilder();
        for (int i = 0; i < 100; i++) {
            buffer.append("hello World~ \n");
        }

        fileOutputStream.write(buffer.toString().getBytes());

        fileOutputStream.close();
    }
}

public class RandomAccessFileDemo {
    public static void main(String[] args) throws IOException {
        RandomAccessFile file = new RandomAccessFile("hello.txt", "rw");

        byte[] buffer = new byte[4096];

        int length = 0;
        int count = 0;

        while ((length = file.read(buffer, 0, buffer.length)) != -1) {
            System.out.println(new String(buffer, 0, length));
            /* 记录已经读取的字节数 */
            count += length;
        }
        /* 跳过已读取字节数个字节 */
        file.skipBytes(count);
        /* 相当于文件末尾追加数据 */
        file.write("append".getBytes());

        file.close();
    }
}

file.seek(file.length());
file.write("\nappend".getBytes());

public class SimpleDemo {
    public static void main(String[] args) throws IOException {
        FileInputStream in = new FileInputStream("hello.txt");
        BufferedInputStream bufferedInputStream = new BufferedInputStream(in);
        InputStreamReader inputStreamReader = new InputStreamReader(bufferedInputStream);

        /* 首先我们先将其读出来, 此时已经是字符流 */
        char[] chunk = new char[4096];
        int data = inputStreamReader.read(chunk);

        /* 新建输出流 */
        FileWriter fileWriter = new FileWriter("hello1.txt");
        BufferedWriter bufferedWriter = new BufferedWriter(fileWriter);

        while (data != -1) {
            System.out.println(new String(chunk, 0, data));
            bufferedWriter.write(chunk, 0, data);
            /* 写入数据 */
            data = inputStreamReader.read(chunk);

        }

        /* 关闭资源 */
        inputStreamReader.close();
        bufferedWriter.close();
    }
}

interface Work {
    void work();
}

class HomeWork implements Work {
    @Override
    public void work() { System.out.println("做家庭作业"); }
}


class Decorator implements Work {
    private final Work work;

    Decorator(Work work) { this.work = work; }

    @Override
    public void work() {
        work.work();
        System.out.println("做其它的作业");
    }
}

public class SimpleDecorator {
    public static void main(String[] args) {
        HomeWork homeWork = new HomeWork();
        Decorator decorator = new Decorator(homeWork);
        decorator.work();
    }
}

FileInputStream inputStream = new FileInputStream("hello.txt");
/* 获取Channel对象 */
FileChannel channel = inputStream.getChannel();
/* 声明Buffer对象 */
ByteBuffer buffer = ByteBuffer.allocate(4096);
/* 将数据从channel写入至buffer中 */
channel.read(buffer);
/* 将buffer相关变量还原 */
buffer.flip();

while (buffer.hasRemaining()) {
    byte b = buffer.get();
    System.out.println("character: " + (char)b);
}
channel.close();

public class NIOCopyFile {
    public static void main(String[] args) throws IOException {

        FileChannel inChannel = new FileInputStream("hello.txt").getChannel();

        FileChannel outChannel = new FileOutputStream("hello1.txt").getChannel();

        ByteBuffer buffer = ByteBuffer.allocate(4096);

        while (inChannel.read(buffer) != -1) {
            buffer.flip();  // 翻转buffer, 准备进行buffer的读操作
            outChannel.write(buffer);
            buffer.clear();  // 将buffer的position, limit置为最初状态, 以便接收后续数据
        }

        inChannel.close();
        outChannel.close();
    }
}