JavaSE 一些技巧 04——IO流各种流常用代码整理

Posted 2022-09-28

1 引言

​ IO流这块知识点碎且杂，但仍然有迹可循，因此整理一份以供后续我和小伙伴们进行查阅！

2 分类

​

3 一般字节流

3.1 字节输入流读数据

1. 内容

• 创建一个字节输入流管道
• 定义一个字节数组
• 循环中将字节数组转成字符串打印出来

2. 代码

		//1.直接创建一个字节输入流管道和源文件对接接通
        InputStream is = new FileInputStream("Day09Demo/src/dilei02.txt");

        //2.必须使用循环，但是还是无法解决中文乱码的问题
        //a.定义一个字节数组代表桶
        byte[] buffer = new byte[3];
        int len;//存储每次读取的字节数

        //3.循环，括号以及等号右边有优先级，因此is.read(buffer)拿到桶后装三滴水，返回3然后判断不等于-1
        while ((len = is.read(buffer))!=-1)
            //读多少倒多少！
            String rs = new String(buffer,0,len);
            System.out.print(rs);//不用换行
        

3.2 字节输出流写数据

1. 内容

• 写一个字节
• 写一个字节数组
• 写部分字节数组
• 追加管道
• 关闭管道

2. 代码

		//1.创建一个字节输出流管道与目标文件接通，默认是数据覆盖管道

		//追加数据管道，可以追加数据，原来数据不清掉
		//OutputStream os = new FileOutputStream("Day09Demo/src/dilei04.txt",true);

        OutputStream os = new FileOutputStream("Day09Demo/src/dilei04.txt");//不用自己再建文件，因为源码中已经有创建文件

		//2.写一个字节出去(写一滴水出去)
        os.write(97);//字节a
        os.write(b);//字节b
        //os.write(芬);//只会写出中文的第一个字节，写出去就是乱码了！
        os.write("\\r\\n".getBytes());//加了\\r是在哪个系统都可以换行
		
		//3.写一个字节数组出去(写一个桶出去)
        byte[] bytes = new byte[]34,54,65,76,87,6,54;//写了一堆字节
        os.write(bytes);
        byte[] bytes1 = "Java是最优美的语言".getBytes();//直接拿字符串调getbytes得到字节，默认以当前编码UTF-8提取
		System.out.println(bytes1.length);//看看长度
        os.write(bytes1);
        os.write("\\r\\n".getBytes());//换行

        //4.写一个字节数组的一部分出去
        byte[] bytes2 = "Java是最优美的语言".getBytes();
        os.write(bytes2,0,19);
        os.write("\\r\\n".getBytes());//换行



	
		//6.刷新或者关闭下
		os.flush();//立即刷新数据到文件中去，刷新后管道可以继续使用
        os.close();//记得关闭资源管道，关闭包含了刷新，关闭后管道不能使用了

3.3 字节流作文件复制

1. 内容：一半字节流用来做文件复制的多，因为读写文件难避免中文字符出现乱码的情况

• 建两根输入流和输出流管道
• 循环先读后写
• 捕获下异常

2. 代码

    public static void main(String[] args) 
		
        //try后面小括号放置资源对象，用完会自动调用close关闭，省的finally里面写了
        try(//相当于常量，只能给一次初始值
                //1.创建一个字节输入流管道和源文件接通
                InputStream is = new FileInputStream("C:\\\\Users\\\\CZyue\\\\Desktop\\\\壁纸\\\\girl.jpg");
                //2.创建一个字节输出流与目标文件接通
                OutputStream os = new FileOutputStream("C:\\\\Users\\\\CZyue\\\\Desktop\\\\littlegirl.jpg");
                )
        
            //3.创建一个字节数组作为桶
            byte[] butter = new byte[1024];
            //4.从字节输入流读取数据，写到字节输出流管道即可
            //定义一个变量存储每次桶读取的字节数
            int len;
            while ((len = is.read(butter))!=-1)
                //读取多少就倒出多少
                os.write(butter,0,len);
            
            System.out.println("复制完成！！");
        catch (Exception e)
            e.printStackTrace();
        
    

4 一般字符流

4.1 字符输入流读数据

1. 内容

• 和字节输入流差不多，把字节byte换成字符char即可

2. 代码

        //1.创建一个字符输入流管道与源文件路径接通
        Reader fr = new FileReader("Day10Demo\\\\src\\\\dilei01.txt");

		//2.使用循环读取
        char[] chars = new char[1024];
        //定义一个整数记录每次桶读取的字符数据量
        int len = 0;
        while((len = fr.read(chars))!=-1)
            //读多少倒出多少
            System.out.print(new String(chars,0,len));
        

4.2 字符输出流写数据

1. 内容：

• 和字节输出流差不多，字符可以随意输出啦

2. 代码

		//1.创建字符输出流管道通向目标文件路径

        //追加数据管道，表示不会清空数据
        //Writer fw = new FileWriter("Day10Demo\\\\src\\\\dilei03.txt",true);
        Writer fw = new FileWriter("Day10Demo\\\\src\\\\dilei03.txt");

        //2.写一个字符出去： public void write(int a)/public void write(String c)
        fw.write(97);//字符a
        fw.write(98);//字符a
        fw.write(芬);//字符芬
        fw.write("\\r\\n");//换行

        //3.写一个字符串出去：
        fw.write("Java是最优美的语言");
        fw.write("\\r\\n");//换行

        //4.写一个字符数据数据出去：public void write(char[] butter)
        fw.write("我爱中国".toCharArray());//打印成字符数组
        fw.write("\\r\\n");//换行

        //5.写字符串一部分出去：public void write(String c,int pos,int len)
        fw.write("Java是最优美的语言",0,9);
        fw.write("\\r\\n");//换行
        //6.写字符数组的一部分出去
        fw.write("我爱中国".toCharArray(),0,2);
        fw.write("\\r\\n");//换行

        fw.close();

5 字节缓冲流

5.1 字节缓冲输入流读数据

1. 内容：

• new 一个字节缓冲输入流，然后将原来的字节输入流对象丢进去

2. 代码

	public static void main(String[] args) throws Exception 
        //1.定义一个低级的字节输入流与源文件接通
        InputStream is = new FileInputStream("Day10Demo\\\\src\\\\dilei03.txt");

        //2.把低级的字节输入流包装成一个高级的缓冲字节输入流，多了个缓冲池
        BufferedInputStream bis = new BufferedInputStream(is);

        //3.定义一个字节数组按照循环读取
        byte[] buffer = new byte[3];
        int len;
        while((len=bis.read(buffer))!=-1)
            String rs = new String(buffer,0,len);
            System.out.println(rs);
        
    

5.2 字节缓冲输出流写文件

1. 内容

• new 一个字节缓冲输出流，然后将原来的字节输出流对象丢进去

2. 代码

    public static void main(String[] args) throws Exception 
       //1.写一个原始的字节输出流
        OutputStream os = new FileOutputStream("Day10Demo\\\\src\\\\dilei05.txt");
        BufferedOutputStream bos = new BufferedOutputStream(os);

        //2.写数据出去
        bos.write(a);
        bos.write(100);
        bos.write("我爱中国".getBytes());
        bos.close();

    

5.3 利用字节流的复制统计各种写法形式的性能执行情况

1. 内容：分别比较四种字节流的复制性能

• 使用一般的字节流一个一个字节形式的复制文件

• 使用一般的字节流一个一个字节数组形式的复制文件

• 使用高级的缓冲字节流一个一个字节形式的复制文件

• 使用高级的缓冲字节流一个一个字节数组形式的复制文件

2. 代码

public class CopyDemo 
    public static final String SRC_FILE="C:\\\\Users\\\\CZyue\\\\Desktop\\\\04_问题答疑.vip";
    public static final String DEST_FILE="C:\\\\Users\\\\CZyue\\\\Desktop\\\\Hadoop\\\\";

    public static void main(String[] args) 
        //一般的字节流一个一个字节形式的复制文件耗时141.218s
        //一般流一个一个字节复制，速度跟蜗牛有的一拼，直接淘汰，静止使用！
        copy01();

        //一般的字节流一个一个字节数组的复制文件耗时0.312s,速度较慢
        copy02();

        //高级的字节缓冲流一个一个字节形式的复制文件耗时0.309s，速度较慢
        copy03();

        //高级的字节缓冲流一个一个字节数组的复制文件耗时0.186s，速度极快，这流可以处！
        copy04();

    

        //1.使用一般的字节流一个一个字节形式的复制文件
        public static void copy01()
            long startTimer = System.currentTimeMillis();
            try
                //1.创建一个一般字节输入流与源文件接通
                InputStream is = new FileInputStream(SRC_FILE);
                //2.创建一个一般的字节输出流和目标文件接通
                FileOutputStream os = new FileOutputStream(DEST_FILE+"缓冲字节流复制的test1.vip");
                //3.定义一个整形变量存储读取的字节
                int ch;
                while ((ch = is.read())!=-1)
                    os.write(ch);
                
                long endTimer = System.currentTimeMillis();
                System.out.println("一般的字节流一个一个字节形式的复制文件耗时"+(endTimer-startTimer)/1000.0);
            catch (Exception e)

                e.printStackTrace();
            
        

        //2.使用一般的字节流一个一个字节数组形式的复制文件
        public static void copy02()
            long startTimer = System.currentTimeMillis();
            try
                //1.创建一个一般字节输入流与源文件接通
                InputStream is = new FileInputStream(SRC_FILE);
                //2.创建一个一般的字节输出流和目标文件接通
                FileOutputStream os = new FileOutputStream(DEST_FILE+"缓冲字节流复制的test2.vip");
                //3.定义一个字节数组存储字节
                byte[] butter = new byte[1024];//1KB
                //定义一个变量存储每次读取的字节数量
                int len;
                while ((len=is.read(butter))!=-1)
                    os.write(butter,0,len);
                

                long endTimer = System.currentTimeMillis();
                System.out.println("一般的字节流一个一个字节数组的复制文件耗时"+(endTimer-startTimer)/1000.0);
            catch (Exception e)

                e.printStackTrace();
            
        

        //3.使用高级的缓冲字节流一个一个字节形式的复制文件
        public static void copy03()
            long startTimer = System.currentTimeMillis();
            try
                //1.创建一个高级字节输入流与源文件接通
                InputStream is = new FileInputStream(SRC_FILE);
                BufferedInputStream bis = new BufferedInputStream(is);
                //2.创建一个高级的字节输出流和目标文件接通
                FileOutputStream os = new FileOutputStream(DEST_FILE+"缓冲字节流复制的test3.vip");
                BufferedOutputStream bos = new BufferedOutputStream(os);
                //3.定义一个整形变量存储读取的字节
                int ch;
                while ((ch = bis.read())!=-1)
                    bos.write(ch);
                
                long endTimer = System.currentTimeMillis();
                System.out.println("高级的字节缓冲流一个一个字节形式的复制文件耗时"+(endTimer-startTimer)/1000.0);
            catch (Exception e)
                e.printStackTrace();
            
        

        //4.使用高级的缓冲字节流一个一个字节数组形式的复制文件
 

6 字符缓冲流

6.1 字符缓冲输入流读数据

1. 内容

• 使用readLine()的方法：public String readLine()读取一行数据返回，读取完毕返回null

2. 代码

 		public static void main(String[] args) throws Exception 
            
        //1.定义一个原始的一般的字符输入流
        Reader fr = new FileReader("Day10Demo\\\\src\\\\dilei06.txt");
            
        //2.把一般的字符输入流包装成高级的字符缓冲输入流管道
        BufferedReader br = new BufferedReader(fr);
            
        //3.定义一个字符串变量存储每一行数据
        String line;
        //使用一个循环读取数据(经典代码)
        while ((line = br.readLine())!=null)//有时候业务需要一行一行读
            System.out.print(line);
        
        br.close();//代码少直接close，规范的应该try的小括号关闭，这边简略些
        

6.2 字符缓冲输出流写数据

1. 内容:同字符缓冲流，new一个BufferedWriter，然后把字符输出流对象丢进去
2. 代码

    public static void main(String[] args) throws Exception 
        //1.定义一个一般的字符输出流写数据出去

        //如果要追加，还是只能在原来的一般的字符输出流中操作
        //Writer fw = new FileWriter("Day10Demo\\\\src\\\\dilei07.txt",true);
        Writer fw = new FileWriter("Day10Demo\\\\src\\\\dilei07.txt");

        //2.把一般的低级的字符输出流包装成高级的字符缓冲输出流管道
        BufferedWriter bw = new BufferedWriter(fw);

        //3.写字符输出,使用newLine()作为换行符
        bw.write("学习IO流中~~");
        bw.newLine();
        //bw.write("\\r\\n");newLine就替代了这个呢
        bw.write("今天Javase要全部结束啦，真棒！！！");
        bw.close();
    

7 转换流

7.1 字符转换输入流读取数据

1. 内容：可以把原始的字节流按照指定编码转换成字符输入流
2. 代码

    public static void main(String[] args) throws Exception 
        //代码：UTF-8  文件：GBK
        //1.提取GBK文件的原始字节流
        InputStream is = new FileInputStream("C:\\\\Users\\\\CZyue\\\\Desktop\\\\试试看.txt");
        
        //2.把原始字节输入流通过转换流，转换成字符输入转换流InputStreamReader
        //Reader isr = new InputStreamReader(is);//默认UTF-8
        Reader isr = new InputStreamReader(is,"GBK");//默认UTF-8
        
        //3.包装成缓冲流
        BufferedReader br = new BufferedReader(isr);
        //4.打印出来看看
        String line;
        while ((line=br.readLine())!=null)
            System.out.println(line);
        
    

7.2 字符转换输出流写数据

1. 内容：可以把原始的字节流按照指定编码转换成字符输出流

2. 代码

    public static void main(String[] args) throws Exception 
        //1.创建一个一般的字节输出流
        OutputStream os = new FileOutputStream("Day10Demo\\\\src\\\\dilei07.txt");
        
         //2.把字节输出流包装成字符输出流
        //Writer osw = new OutputStreamWriter(os);//默认编码字节输出流转换成字符输出流
        Writer osw = new OutputStreamWriter(os,"GBK");//按照GBK编码字节输出流转换成字符输出流
        
        //3.写看看
        osw.write("abc我是中国人");
        osw.close();
    

8 打印流

8.1 打印流

1. 内容：可以实现打印啥出去，就是啥出去
2. 代码

public static void main(String[] args) throws Exception 
    	//1.打印流PrintStream
//        OutputStream os = new FileOutputStream("Day10Demo\\\\src\\\\dilei08.txt");
//        PrintStream ps = new PrintStream(os);
        //2.可以直接打印流通向文件路径，以及两者PrintStream和PrintWriter可以混用
        PrintStream ps = new PrintStream("Day10Demo\\\\src\\\\dilei08.txt");
        PrintWriter pw = new PrintWriter("Day10Demo\\\\src\\\\dilei08.txt");//可以直接通向文件，但是默认覆盖了
        //3.注意：不能丢给缓冲流，因为打印流底层基于缓冲流了，这流很厉害！
		//4.打印看看
        ps.println(97);//可以打印各种数据，写啥打啥，这边97不是字母了，直接就是97
        ps.println(99.8);
        ps.println(false);
        ps.println(芬);
        ps.close();
    

8.2 利用打印流重定向输出的流向

1. 内容：数据会流向打印流，打印流会流向文件
2. 代码

  public static void main(String[] args) throws Exception 
      	/1./这个流向控制台
        System.out.println("=====java0========");
      
        //2.即下面的内容会流向打印流，打印流会流向文件
        PrintStream ps = new PrintStream("Day10Demo\\\\src\\\\log.txt");
        System.setOut(ps);//让系统的输出流向打印流，java提供的静态方法
        System.out.println("=====java1========");
        System.out.println("=====java2========");
        System.out.println("=====java3========");
        System.out.println("=====java4========");

9 对象序列化和属性文件内容

略，有机会再研究