Java 文件IO的操作示例

File file = new File("");
        try {
            //字节流
            InputStream inputStream = new FileInputStream(file);
            OutputStream outputStream = new FileOutputStream(file);

            //字符流
            Writer writer = new FileWriter(file);
            Reader reader = new FileReader(file);

            //字节流转字符流
            Reader reader1 = new InputStreamReader(inputStream, Charset.defaultCharset());
            Writer writer1 = new OutputStreamWriter(outputStream, Charset.defaultCharset());

            //字节缓冲流，默认的缓存是8kb，当缓存满时，会把数据写入文件，并且缓存下标置为0，重头开始覆盖数据。
            BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(outputStream);
            String info = "你好";
            //这个时候其实是写入缓存，并没有写到文件
            bufferedOutputStream.write(info.getBytes());
            //关闭的时候才写入文件
            bufferedOutputStream.close();

            BufferedInputStream bufferedInputStream = new BufferedInputStream(inputStream);
            byte[] bytes = new byte[1024];
            int length = -1;
            while ((length = bufferedInputStream.read(bytes)) != -1){
                System.out.println(new String(bytes,0,length));
            }
            bufferedInputStream.close();

            //字符缓冲流，默认的缓存是8kb
            BufferedReader bufferedReader = new BufferedReader(reader);
            char[] chars = new  char[1024];
            while ((length = bufferedReader.read(chars)) != -1){
                System.out.println(new String(chars,0,length));
            }
            bufferedReader.close();

            //字节数组流,基于内存操作，维护内部的数组
            String str = "1245878555fdsfhjsSDHNc";
            ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(str.getBytes());
            ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
            int curr = -1;
            while ((curr = byteArrayInputStream.read()) != -1){
                //只取字母
                if ((curr>=65 && curr<=90) || (curr>=97 && curr<=122)) {
                    byteArrayOutputStream.write(curr);
                }
            }
            System.out.println(byteArrayOutputStream.toString());

            //合并流处理，获取要合并的流文件
            InputStream in1 = new  FileInputStream(file);
            InputStream in2 = new  FileInputStream(file);
            InputStream in3 = new  FileInputStream(file);
            InputStream in4 = new  FileInputStream(file);
            Vector<InputStream> v = new Vector<InputStream>();
            v.add(in1);
            v.add(in2);
            v.add(in3);
            v.add(in4);
            Enumeration<InputStream> list = v.elements();
            //合并流处理
            SequenceInputStream sequenceInputStream = new SequenceInputStream(list);
            BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("ASD"));
            while ((length = sequenceInputStream.read(bytes)) != -1){
                bos.write(bytes, 0, length);
                bos.flush();
            }
            bos.close();
            sequenceInputStream.close();
            System.out.println("合并完成");

            //字符串流
            StringReader stringReader = new StringReader("hello word");
            StreamTokenizer streamTokenizer = new StreamTokenizer(stringReader);
            int totol = 0;
            while (streamTokenizer.ttype != StreamTokenizer.TT_EOF){
                if (streamTokenizer.nextToken() == StreamTokenizer.TT_WORD){
                    totol++;
                }
            }
            System.out.println("一个"+ totol + "个单词");

            //管道流
            //管道输入流应该接到管道输出流；管道输入流提供要写入管道输出流的所有数据字节。
            //通常由某个线程从PipedInputStream对此读取，并由其他线程将其写入到相应的PipedOutputStream。
            //不建议对这两个对象尝试使用单个线程，因为这样可能死锁线程。
            //管道输入流包含一个缓冲区，可在缓冲区限定的范围内将读操作和写操作分离开。
            //如果向链接管道输出流提供数据字节的线程不再存在，则认为该管道已损坏
            PipedInputStream pipedInputStream = new PipedInputStream();
            PipedOutputStream pipedOutputStream = new PipedOutputStream();

            pipedInputStream.connect(pipedOutputStream);
            ReadThread readThread = new ReadThread(pipedInputStream);
            WriteThread writeThread = new WriteThread(pipedOutputStream);
            new  Thread(readThread).start();
            new  Thread(writeThread).start();

            //Properties文件操作
            Properties properties = new Properties();
//            InputStream inputStream1 = new FileInputStream("conger.properties");
            InputStream inputStream1 = Thread.currentThread().getContextClassLoader().getResourceAsStream("conger.properties");
                    //加载配置文件
            properties.load(inputStream1);
            //读操作
            String value = properties.getProperty("key");
            System.out.println(value);
            //写操作
            properties.put("key","内容") ;
            OutputStream outputStream1 = new FileOutputStream("conger.properties");
            properties.store(outputStream1,"备注");
            outputStream1.close();

        } catch (IOException e) {
            e.printStackTrace();
        }
    

class ReadThread implements  Runnable{
    private final PipedInputStream pipedInputStream;

    public ReadThread(PipedInputStream pipedInputStream) {
        this.pipedInputStream = pipedInputStream;
    }

    @Override
    public void run() {
        try {
            byte[] buf = new byte[1024];
            int len = pipedInputStream.read(buf);
            String s = new String(buf,0,len);
            System.out.println("读到：" + s);
            pipedInputStream.close();
        }catch (IOException e){
            e.printStackTrace();
        }
    }
}

class WriteThread implements  Runnable{
    private final PipedOutputStream pipedOutputStream;

    public WriteThread(PipedOutputStream pipedOutputStream) {
        this.pipedOutputStream = pipedOutputStream;
    }

    @Override
    public void run() {
        try {
            pipedOutputStream.write("dffg".getBytes());
            pipedOutputStream.close();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
}