java高级之Io流

时间 2019-12-20

标签 java 高级栏目 Java 繁體版

原文原文链接

1.1，什么是io流？

　　流是一组有顺序的，有起点和终点的字节集合，是对数据传输的总称或抽象。即数据在两设备间的传输称为流，流的本质是数据传输，根据数据传输特性将流抽象为各类类，方便更直观的进行数据操做。java

1.2，流按类型分为两种:

　* 字节流 : 字节流能够操做任何数据,由于在计算机中任何数据都是以字节的形式存储的
　* 字符流 : 字符流只能操做纯字符数据，比较方便。windows

1.2.1，io流的结构图:

1.3，IO流经常使用父类:

　　* 字节流的抽象父类：　　　　　　　　　　　　* 字符流的抽象父类：
　　　　* InputStream 　　　　　　　　　　　　　　* Reader
　　　　* OutputStream　　　　　　　　　　　　　 * Writer　　设计模式

1.4，IO程序书写：

* 使用前，导入IO包中的类
* 使用时，进行IO异常处理
* 使用后，释放资源数组

1.5，IO流(FileInputStream)~（1.5~2.0讲的是字节流):

* read()一次读取一个字节优化

* read()一次读取一个字节编码

1         FileInputStream fis = new FileInputStream("aaa.txt");    //建立一个文件输入流对象,并关联aaa.txt
2         int b;                                                    //定义变量,记录每次读到的字节
3         while((b = fis.read()) != -1) {                            //将每次读到的字节赋值给b并判断是不是-1
4             System.out.println(b);                                //打印每个字节
5         }
6         
7         fis.close();                                            //关闭流释放资源

read()方法读取的是一个字节,为何返回是int,而不是byte？
　　由于字节输入流能够操做任意类型的文件,好比图片音频等,这些文件底层都是以二进制形式的存储的,若是每次读取都返回byte,有可能在读到中间的时候遇到111111111
　　那么这11111111是byte类型的-1,咱们的程序是遇到-1就会中止不读了,后面的数据就读不到了,因此在读取的时候用int类型接收,若是11111111会在其前面补上
　　24个0凑足4个字节,那么byte类型的-1就变成int类型的255了这样能够保证整个数据读完,而结束标记的-1就是int类型spa

1.6，IO流(FileOutputStream):

　　* write()一次写出一个字节设计

1         FileOutputStream fos = new FileOutputStream("bbb.txt");    //若是没有bbb.txt,会建立出一个
2         //fos.write(97);                        //虽然写出的是一个int数,可是在写出的时候会将前面的24个0去掉,因此写出的一个byte
3         fos.write(98);
4         fos.write(99);
5         fos.close();

1.7，第一种方法:IO之字节流流的基本读写(FileInputStream读取，FileOutputStream写出)：

 1         //建立输入流对象,C:\\Users\\十年饮冰，难凉热血\\Desktop\\平常一趣\\1970年的来历.rtf
 2         FileInputStream fis  = new FileInputStream("C:\\Users\\十年饮冰，难凉热血\\Desktop\\平常一趣\\1970年的来历.rtf");
 3         //建立输出流对象,关联copt.txt
 4         FileOutputStream fos = new FileOutputStream("C:\\Users\\十年饮冰，难凉热血\\Desktop\\平常一趣\\copt.rtf");
 5         int b;
 6         while((b = fis.read())!=-1){    //在不断的读取每个字节
 7                 fos.write(b);                //将每个字节写出
 8         }    
 9         fis.close();            //关闭释放
10         fos.close();
11     }

第二种读写方法:code

1         //建立输入流对象
2         FileInputStream fis = new FileInputStream("C:\\Users\\十年饮冰，难凉热血\\Desktop\\平常一趣\\由浅入深学Java—基础、进阶与必作260题.pdf");
3         //建立输出流对象
4         FileOutputStream fos = new FileOutputStream("C:\\Users\\十年饮冰，难凉热血\\Desktop\\平常一趣\\Jy.pdf");
5         byte[] arr = new byte[1024*8];
6         int len;  
7         while((len =fis.read(arr))!=-1){
8             fos.write(arr,0,len);　　
9         }

1.8，缓冲流思想:

　　缓冲思想：对象

　　　　* 字节流一次读写一个数组的速度明显比一次读写一个字节的速度快不少，这是加入了数组这样的缓冲区效果，java自己在设计的时候，也考虑到了这样的设计思想(装饰设计模式后面讲解)，因此提供了字节缓冲区流。
　　　　* BufferedInputStream
　　　　 BufferedInputStream内置了一个缓冲区(数组)，从BufferedInputStream中读取一个字节时，* BufferedInputStream会一次性从文件中读取8192个, 存在缓冲区中, 返回给程序一个，程序再次读取时, 就不用找文件了, 直接从缓冲区中获取，直到缓冲区中全部的都被使用过, 才从新从文件中读取8192个。
　　　　* BufferedOutputStream
　　　　 BufferedOutputStream也内置了一个缓冲区(数组)，程序向流中写出字节时, 不会直接写到文件, 先写到缓冲区中，直到缓冲区写满, BufferedOutputStream才会把缓冲区中的数据一次性写到文件里。

 1    　　  FileInputStream fis = new FileInputStream("致青春.mp3");            //建立文件输入流对象,关联致青春.mp3
 2         BufferedInputStream bis = new BufferedInputStream(fis);            //建立缓冲区对fis装饰
 3         FileOutputStream fos = new FileOutputStream("copy.mp3");        //建立输出流对象,关联copy.mp3
 4         BufferedOutputStream bos = new BufferedOutputStream(fos);        //建立缓冲区对fos装饰
 5         
 6         int b;
 7         while((b = bis.read()) != -1) {        
 8             bos.write(b);
 9         }
10         
11         bis.close();                        //只关装饰后的对象便可
12         bos.close();

1.9，IO流(flush和close方法的区别):

　　* flush()方法　　　　　　　　　　　　　　　 * close()方法
　　　* 用来刷新缓冲区的,刷新后能够再次写出　　　* 用来关闭流释放资源的的,若是是带缓冲区的流对象的close()方法,不但会关闭流,还会再关闭流以前刷新缓冲区,关闭后不能再写出

2.0，IO流(字节流读写中文)：

　　* 字节流读取中文的问题
　　　　* 字节流在读中文的时候有可能会读到半个中文,形成乱码
　　* 字节流写出中文的问题
　　　　* 字节流直接操做的字节,因此写出中文必须将字符串转换成字节数组,写出回车换行 write("\r\n".getBytes());

1     　　//字节流读取中文会形成乱码的解决方法
2         FileInputStream fis = new FileInputStream("xxx.txt");
3         byte[] arr = new byte[5];
4         int len;
5         while((len=fis.read(arr))!=-1){
6             System.out.println(new String(arr,0,len));
7         }
8         fis.close();
9     }

1         //字节流写出中文的问题
2         FileOutputStream fos = new FileOutputStream("zzz.txt");
3         fos.write("我读书少你,不要骗我".getBytes());
4         fos.write("\r\n".getBytes());
5         fos.close();

2.1，字符流是什么(2.1~3.1讲的是字符流知识):

　　* 字符流是能够直接读写字符的IO流
　　* 字符流读取字符, 就要先读取到字节数据, 而后转为字符. 若是要写出字符, 须要把字符转为字节再写出。

2.2，FileReader类的read()方法能够按照字符大小读取

1         FileReader fr = new FileReader("aaa.txt");                //建立输入流对象,关联aaa.txt
2         int ch;
3         while((ch = fr.read()) != -1) {                            //将读到的字符赋值给ch
4             System.out.println((char)ch);                        //将读到的字符强转后打印
5         }
6         fr.close();                                                //关流

2.3，FileWriter类的write()方法能够自动把字符转为字节写出：

1     　public static void main(String[] args){
2         FileWriter fw = new FileWriter("ccc.txt",true);　　//true是对数据进行追加的 3         fw.write(97);
4         fw.close();    
5        }

2.4，字符流的拷贝:

 1         //建立字符输入流
 2         FileReader fr = new FileReader("ccc.txt");
 3         //建立字符输出流
 4         FileWriter fw = new FileWriter("xxx.txt");
 5         int len;
 6         //while中的条件是fr.read()的字符长度等于len假如fr.read的值等于-1的时候就中止跳转
 7         while((len=fr.read())!=-1){
 8             fw.write(len);
 9         }
10         fr.close();
11         fw.close();//writer类中有一个2k的小缓冲区,若是不关流,就会将内容写到缓冲区里,关流回将缓冲区内容刷新,再关闭
12     }

2.5，(什么状况下使用字符流):

　　* 字符流也能够拷贝文本文件, 但不推荐使用. 由于读取时会把字节转为字符, 写出时还要把字符转回字节.
　　* 程序须要读取一段文本, 或者须要写出一段文本的时候可使用字符流
　　* 读取的时候是按照字符的大小读取的,不会出现半个中文
　　* 写出的时候能够直接将字符串写出,不用转换为字节数组

2.6，IO流(字符流是否能够拷贝非纯文本的文件)：

　　* 不能够拷贝非纯文本的文件
　　* 由于在读的时候会将字节转换为字符,在转换过程当中,可能找不到对应的字符,就会用?代替,写出的时候会将字符转换成字节写出去
　　* 若是是?,直接写出,这样写出以后的文件就乱了,看不了

2.7，IO流(自定义字符数组的拷贝):

 1        
 2          FileReader fr = new FileReader("aaa.txt");            //建立字符输入流,关联aaa.txt
 3          FileWriter fw = new FileWriter("bbb.txt");            //建立字符输出流,关联bbb.txt
 4          int len;
 5          char[] arr = new char[1024*8];                        //建立字符数组
 6          while((len = fr.read(arr)) != -1) {                    //将数据读到字符数组中
 7              fw.write(arr, 0, len);                            //从字符数组将数据写到文件上
 8          }
 9  
10          fr.close();                                            //关流释放资源
11          fw.close();

2.8，IO流(带缓冲的字符流) ：

* BufferedReader的read()方法读取字符时会一次读取若干字符到缓冲区, 而后逐个返回给程序, 下降读取文件的次数, 提升效率
* BufferedWriter的write()方法写出字符时会先写到缓冲区, 缓冲区写满时才会写到文件, 下降写文件的次数, 提升效率

 1         BufferedReader br = new BufferedReader(new FileReader("aaa.txt"));    //建立字符输入流对象,关联aaa.txt
 2         BufferedWriter bw = new BufferedWriter(new FileWriter("bbb.txt"));    //建立字符输出流对象,关联bbb.txt
 3         
 4         int ch;                
 5         while((ch = br.read()) != -1) {        //read一次,会先将缓冲区读满,从缓冲去中一个一个的返给临时变量ch
 6             bw.write(ch);                    //write一次,是将数据装到字符数组,装满后再一块儿写出去
 7         }
 8         
 9         br.close();                            //关流
10         bw.close();

2.9，IO流(readLine()和newLine()方法):

　　* BufferedReader的readLine()方法能够读取一行字符(不包含换行符号)
　　* BufferedWriter的newLine()能够输出一个跨平台的换行符号"\r\n"

 1         BufferedReader br = new BufferedReader(new FileReader("aaa.txt"));
 2         BufferedWriter bw = new BufferedWriter(new FileWriter("bbb.txt"));
 3         String line;
 4         while((line = br.readLine()) != null) {
 5             bw.write(line);
 6             //bw.write("\r\n");                    //只支持windows系统
 7             bw.newLine();                        //跨平台的
 8         }
 9         
10         br.close();
11         bw.close();

3.0，IO流(LineNumberReader):

　　* LineNumberReader是BufferedReader的子类, 具备相同的功能, 而且能够统计行号
　　* 调用getLineNumber()方法能够获取当前行号
　　* 调用setLineNumber()方法能够设置当前行号

1         LineNumberReader lnr = new LineNumberReader(new FileReader("aaa.txt"));
2         String line;
3         lnr.setLineNumber(100);                                    //设置行号
4         while((line = lnr.readLine()) != null) {
5             System.out.println(lnr.getLineNumber() + ":" + line);//获取行号
6         }
7         
8         lnr.close();

3.1，IO流(使用指定的码表读写字符)(掌握):

　　* FileReader是使用默认码表读取文件, 若是须要使用指定码表读取, 那么可使用InputStreamReader(字节流,编码表)
　　* FileWriter是使用默认码表写出文件, 若是须要使用指定码表写出, 那么可使用OutputStreamWriter(字节流,编码表)

 1         BufferedReader br =                                     //高效的用指定的编码表读
 2                 new BufferedReader(new InputStreamReader(new FileInputStream("UTF-8.txt"), "UTF-8"));
 3         BufferedWriter bw =                                     //高效的用指定的编码表写
 4                 new BufferedWriter(new OutputStreamWriter(new FileOutputStream("GBK.txt"), "GBK"));
 5         int ch;
 6         while((ch = br.read()) != -1) {
 7             bw.write(ch);
 8         }
 9         
10         br.close();
11         bw.close();

除却字节流与字符流本博客还将总结一些课外的流，开发中也会碰见，为了丰富知识的同窗们能够看看。

3.2，什么是序列流(了解):

　　* 序列流能够把多个字节输入流整合成一个, 从序列流中读取数据时, 将从被整合的第一个流开始读, 读完一个以后继续读第二个, 以此类推。

 1         //整合多个字节输入流: SequenceInputStream(Enumeration)
 2         FileInputStream fis1 = new FileInputStream("a.txt");    //建立输入流对象,关联a.txt
 3         FileInputStream fis2 = new FileInputStream("b.txt");    //建立输入流对象,关联b.txt
 4         FileInputStream fis3 = new FileInputStream("c.txt");    //建立输入流对象,关联c.txt
 5         Vector<InputStream> v = new Vector<>();                    //建立vector集合对象
 6         v.add(fis1);                                            //将流对象添加
 7         v.add(fis2);
 8         v.add(fis3);
 9         Enumeration<InputStream> en = v.elements();                //获取枚举引用
10         SequenceInputStream sis = new SequenceInputStream(en);    //传递给SequenceInputStream构造
11         FileOutputStream fos = new FileOutputStream("d.txt");
12         int b;
13         while((b = sis.read()) != -1) {
14             fos.write(b);
15         }
16     
17         sis.close();
18         fos.close();

3.3，什么是内存输出流(了解):

　　* 该输出流能够向内存中写数据, 把内存看成一个缓冲区, 写出以后能够一次性获取出全部数据

 1         　　 FileInputStream fis = new FileInputStream("a.txt");
 2             ByteArrayOutputStream baos = new ByteArrayOutputStream();
 3             int b;
 4             while((b = fis.read()) != -1) {
 5                 baos.write(b);
 6             }
 7             
 8             //byte[] newArr = baos.toByteArray();                //将内存缓冲区中全部的字节存储在newArr中
 9             //System.out.println(new String(newArr));
10             System.out.println(baos);
11             fis.close();

3.4，什么是对象操做流(了解):

　　* 该流能够将一个对象写出, 或者读取一个对象到程序中. 也就是执行了序列化和反序列化的操做.

3.4.1，使用方式:

　　* 写出: new ObjectOutputStream(OutputStream), writeObject()

 1                 public static void main(String[] args) throws IOException {
 2                     Person p1 = new Person("张三", 23);
 3                     Person p2 = new Person("李四", 24);
 4             //        FileOutputStream fos = new FileOutputStream("e.txt");
 5             //        fos.write(p1);
 6             //        FileWriter fw = new FileWriter("e.txt");
 7             //        fw.write(p1);
 8                     //不管是字节输出流,仍是字符输出流都不能直接写出对象
 9                     ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("e.txt"));//建立对象输出流
10                     oos.writeObject(p1);
11                     oos.writeObject(p2);
12                     oos.close();
13                 }

3.4.2，使用方式:

　　　　* 读取: new ObjectInputStream(InputStream), readObject()

1              　　//读取对象,反序列化
2                 public static void main(String[] args) throws IOException, ClassNotFoundException {
3                     ObjectInputStream ois = new ObjectInputStream(new FileInputStream("e.txt"));
4                     Person p1 = (Person) ois.readObject();
5                     Person p2 = (Person) ois.readObject();
6                     System.out.println(p1);
7                     System.out.println(p2);
8                     ois.close();
9                 }

3.4.3，IO流(对象操做流优化)(写入与读取写一块儿了)(了解):

　　*　将对象存储在集合中写出

 1     Person p1 = new Person("张三", 23);
 2     Person p2 = new Person("李四", 24);
 3     Person p3 = new Person("马哥", 18);
 4     Person p4 = new Person("辉哥", 20);
 5     
 6     ArrayList<Person> list = new ArrayList<>();
 7     list.add(p1);
 8     list.add(p2);
 9     list.add(p3);
10     list.add(p4);
11     
12     ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("f.txt"));
13     oos.writeObject(list);                                    //写出集合对象
14     oos.close();
15  　　　　//读取到的是一个集合对象 16      ObjectInputStream ois = new ObjectInputStream(new FileInputStream("f.txt"));
17           ArrayList<Person> list = (ArrayList<Person>)ois.readObject();    //泛型在运行期会被擦除,索引运行期至关于没有泛型
18                                                                     //想去掉黄色能够加注解                    @SuppressWarnings("unchecked")
19           for (Person person : list) {
20               System.out.println(person);
21           }
22      ois.close();

3.5，什么是打印流(了解):

　　* 该流能够很方便的将对象的toString()结果输出, 而且自动加上换行, 并且可使用自动刷出的模式
　　* System.out就是一个PrintStream, 其默认向控制台输出信息

1         　　PrintStream ps = System.out;
2             ps.println(97);                    //其实底层用的是Integer.toString(x),将x转换为数字字符串打印
3             ps.println("xxx");
4             ps.println(new Person("张三", 23));
5             Person p = null;
6             ps.println(p);                    //若是是null,就返回null,若是不是null,就调用对象的toString()

3.6，什么是标准输入输出流(掌握):

　　* System.in是InputStream, 标准输入流, 默承认以从键盘输入读取字节数据
　　* System.out是PrintStream, 标准输出流, 默承认以向Console中输出字符和字节数据

3.6.1，修改标准输入输出流(了解):

　修改输入流: System.setIn(InputStream)　　　　* 修改输出流: System.setOut(PrintStream)

 1             System.setIn(new FileInputStream("a.txt"));                //修改标准输入流
 2             System.setOut(new PrintStream("b.txt"));                //修改标准输出流
 3             
 4             InputStream in = System.in;                                //获取标准输入流
 5             PrintStream ps = System.out;                            //获取标准输出流
 6             int b;
 7             while((b = in.read()) != -1) {                            //从a.txt上读取数据
 8                 ps.write(b);                                        //将数据写到b.txt上
 9             }
10             
11             in.close();
12             ps.close();

3.6.2，(修改标准输入输出流拷贝图片)(了解):

 1         System.setIn(new FileInputStream("IO图片.png"));        //改变标准输入流
 2         System.setOut(new PrintStream("copy.png"));         //改变标准输出流
 3         
 4         InputStream is = System.in;                            //获取标准输入流
 5         PrintStream ps = System.out;                        //获取标准输出流
 6         
 7         int len;
 8         byte[] arr = new byte[1024 * 8];
 9         
10         while((len = is.read(arr)) != -1) {
11             ps.write(arr, 0, len);
12         }
13         
14         is.close();
15         ps.close();

3.7，(数据输入输出流)(读写一块儿写了)(了解):

　　* 1.什么是数据输入输出流
　　　　* DataInputStream, DataOutputStream能够按照基本数据类型大小读写数据
　　　　* 例如按Long大小写出一个数字, 写出时该数据占8字节. 读取的时候也能够按照Long类型读取, 一次读取8个字节.

 1     * DataOutputStream(OutputStream), writeInt(), writeLong() 
 2 
 3             DataOutputStream dos = new DataOutputStream(new FileOutputStream("b.txt"));
 4             dos.writeInt(997);
 5             dos.writeInt(998);
 6             dos.writeInt(999);
 7             
 8             dos.close();
 9     * DataInputStream(InputStream), readInt(), readLong()
10 
11             DataInputStream dis = new DataInputStream(new FileInputStream("b.txt"));
12             int x = dis.readInt();
13             int y = dis.readInt();
14             int z = dis.readInt();
15             System.out.println(x);
16             System.out.println(y);
17             System.out.println(z);
18             dis.close();

3.8，(Properties的概述和做为Map集合的使用)(了解)

　　* A:Properties的概述　　　　　　　　　　　　　　　　　　* A:Properties的特殊功能
　　* Properties 类表示了一个持久的属性集。　　　　　　　　　　* public Object setProperty(String key,String value)
　　* Properties 可保存在流中或从流中加载。　　　　　　　　　　* public String getProperty(String key)
　　* 属性列表中每一个键及其对应值都是一个字符串。　　　　　　　* public Enumeration<String> stringPropertyNames()　

1         Properties prop = new Properties();
2         prop.load(new FileInputStream("config.properties"));    //将文件读取到集合中
3         prop.setProperty("tel", "18972345678");
4         prop.store(new FileOutputStream("config.properties"), null); //第二个参数是对列表参数的描述,能够给值,也能够给null
5         System.out.println(prop);