java高级之Io流

1.1，什么是io流？

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

1.2，流按类型分为两种:

　* 字节流 : 字节流可以操作任何数据,因为在计算机中任何数据都是以字节的形式存储的
　* 字符流 : 字符流只能操作纯字符数据，比较方便。

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()一次读取一个字节

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类型

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     }

第二种读写方法:

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);

转载于:https://www.cnblogs.com/joeyJss/p/9490262.html