Java中流-----个人总结心得

时间：2021-12-28 03:57:54

流

  1. 字符流
  2. 字节流
  3. 缓冲区

数据流---用于传输数据。IO流---Input/Output流。数据从外部流向程序---输入流；数据从程序流向外部的时候--输出流。读取一个文件---数据从文件流向程序---输入流；向一个文件中写入数据---数据从程序流向文件---输出流

根据数据流动的方向：输入流/输出流

根据数据传输的形式：字节流/字符流

 

输入流

输出流

字节流

InputStream

OutputSteam

字符流

Reader

Writer

Java中流-----个人总结心得Java中流-----个人总结心得

 

这四个类是Java中四个流的基本类，但是这四个类都是抽象类，都不能用于直接创建对象

数据的来源：硬盘、网络、内存、输入设备

向一个文件中去写入数据---txt文件---字符流、输出流、文件流---

最简单的一个输入流，写入缓冲区中，再从缓冲区中读取出来

 1 public static void main(String[] args) throws IOException {
 2         // TODO Auto-generated method stub
 3         String c;                    //设置一个字符串去接收缓冲区
 4         InputStreamReader IsReader=new InputStreamReader(System.in);//输入流：键盘输入
 5         BufferedReader bReader=new BufferedReader(IsReader);//将输入的存入缓冲区中
 6         System.out.println("输入字符按q退出");
 7         do {
 8             c= bReader.readLine();//从缓冲区中读取
 9             System.out.println(c);
10         } while (!c.equals("q"));
11     }

 字符流

FileWriter

构造函数

FileWriter(String name)--传入文件路径，操作对应的文件---当文件不存在的时候，会创建这个文件；如果文件存在，则创建一个新文件覆盖源文件。

重要方法

write(String s)---写出字符串。数据不是直接写到目的地而是写到缓冲区中，等到缓冲区满了之后才会写到目的地中

flush()---冲刷缓冲区

close()---关闭流。流在关闭之前会自动的冲刷缓冲区。

代码实现：

 1  public static void main(String[] args) throws IOException {   
 2           //创建一个FileWriter对象，并指定文件路径，该文件会被创建到指定目录下。如果该目录有同名文件，那么该文件将被覆盖。 
 3             FileWriter fw = new FileWriter("1.txt");
 4             //调用write的方法将字符串写到流中  
 5             fw.write("hello world!");  
 6             //刷新流对象缓冲中的数据，将数据刷到目的地中  
 7             fw.flush();  
 8             //关闭流资源，但是关闭之前会刷新一次内部缓冲中的数据。当我们结束输入时候，必须close();  
 9             fw.write("刷新");  
10             fw.close();  
11             //flush和close的区别：flush刷新后可以继续输入，close刷新后不能继续输入。  
12         }

 

流的异常处理

1. 流对象要外置定义内置初始化

2. 判断流对象是否初始化成功---判断流对象是否为空

3. 关流操作无论成功与否，都需要将流对象值为null

FileReader

 

1 public int read() throws IOException
读取单个字符，返回一个int型变量代表读取到的字符
2 public int read(char [] c, int offset, int len)
读取字符到c数组，返回读取到字符的个数

 

代码实现：

 1      public static void main(String[] args) throws IOException {   
 2          //创建FileReader对象，并读取1.txt文件
 3          FileReader fr = new FileReader("1.txt"); 
 4          //单字符读取  。。。。。。多字符的读取，创建数组将1.txt文件存入数组中，在读取出来char []  buf = new char[6];   
 5          int ch = 0;     
 6        //一直读取文件中的内容直到文件的尾部
 7          while((ch = fr.read())!=-1) {  
 8             /* 输出字符串   
 9              * 
10              * String(char[] value , int offest,int count) 分配一个新的String,包含从offest开始的count个字符 new String(buf,0,ch}
11              * */ 
12             System.out.print((char)ch);  
13          }  
14          fr.close();  //关闭流
15         }

 两个结合可以实现一个文件的拷贝

将1.txt文件内容拷贝到2.txt中

代码实现：

 1      public static void main(String[] args) throws IOException {   
 2          FileReader fr=new FileReader("1.txt");//先读取需要拷贝的文件
 3          FileWriter fw=new FileWriter("2.txt");//拷贝文件内容复制到的另个文件路径
 4          int ch=0;   
 5          while ((ch=fr.read())!=-1) {   //读个读取内容
 6             fw.write((char)ch);   //将读取的内容写入文件中
 7         }
 8          fr.close();  //关闭读取流
 9          fw.close();//关闭写入流
10      }

 

字节流

其实字节流和字符流是差不多的形式，看懂了上面，下面就不用多说了

文件输入流： FileInputStream类

 简要的说是打开文件，将文件数据读取到内存中

代码实现：
1 public static void main(String[] args) throws IOException {   
2              FileInputStream fStream=new FileInputStream("1.txt");//创建文件输入流对象
3              int ch=0;
4              while ((ch=fStream.read())!=-1) {   //依次读取文件内容赋值给ch
5                 System.out.print((char)ch);     //输出内容-----(char)ch转换成字符输出
6             }
7              }

文件输出流: FileOutputStream类

目的是将内存中的数据读取到文件中

代码实现：
 1      public static void main(String[] args) throws IOException {   
 2          int count, n = 20;  
 3          //创建字节数组
 4          byte buffer[] = new byte[n]; 
 5          //将输入的字节存入字节数组中
 6          count = System.in.read(buffer);//System.in.read()返回的是输入数值的 ASKII 码（一个 int 整数）
 7          FileOutputStream fO=new FileOutputStream("1.txt"); //创建文件输出流对象，指定文件路径
 8          fO.write(buffer, 0, count); //将字节写入文件，显示字符
 9          fO.close();//关闭流
10      }

 FileInputStream流和FileOutputStream的应用

将1.txt文件拷贝到2.txt 文件中

代码实现：
 1  public static void main(String[] args) throws IOException {   
 2          FileInputStream fIn=new FileInputStream("1.txt");//创建文件输入流对象  拷贝对象文件，指定文件路径
 3          FileOutputStream fOut=new FileOutputStream("2.txt");//创建文件输出流对象，，指定写入内容的文件路径
 4          int ch=0;
 5          while ((ch=fIn.read())!=-1) {//循环读取
 6             fOut.write(ch);//将内容写入
 7         }
 8          fIn.close();//关闭流
 9          fOut.close();//关闭流
10      }

 

OutputStreamWriter---将一个字节输出流转化为字符输出流

 代码演示：
1      public static void main(String[] args) throws IOException {   
2          String string="sadkjsdfadsfdaasd";        //需要写入的字符串
3          FileOutputStream fStream=new FileOutputStream("1.txt");//创建输出流对象，指定写入文件的路径
4          OutputStreamWriter oWriter=new OutputStreamWriter(fStream, "utf-8");//-将一个字节输出流转化为字符输出流 ---可以指定编码格式utf-8
5          oWriter.write(string);//写入文件内容
6          fStream.close();//关闭字节输出流
7         oWriter.close();//关闭字符输出流
8 }

 

InputStreamReader---将一个字节输入流转化为字符输入流

代码演示：
1      public static void main(String[] args) throws IOException {   
2          FileInputStream  fStream=new FileInputStream("1.txt");//创建输入流对象，并指定读取文件路径
3          InputStreamReader iReader=new InputStreamReader(fStream);//将一个字节输入流转化为字符输入流
4         StringBuffer sBuffer=new StringBuffer(); //创建一个字符串接收
5          while (iReader.ready()) { //读取字符输入流内容
6             sBuffer.append((char)iReader.read());//添加到字符中
7         }
8          System.out.println(sBuffer.toString());//输出显示
　　　　　　fStream.close();//关闭字节输入流
　　　　　　iReader.close(); //关闭字符输入流
9      }

 

 

OutputStreamWriter和InputStreamReader结合应用

将1.txt中的数据读取到内存，在从内存中数据读取到2.txt

代码演示：
 public static void main(String[] args) throws IOException {   
         FileInputStream fStream=new FileInputStream("1.txt"); 
         InputStreamReader iReader=new InputStreamReader(fStream);
         FileOutputStream fStream2=new FileOutputStream("2.txt");
         OutputStreamWriter oWriter=new OutputStreamWriter(fStream2, "utf-8");
while (iReader.ready()) {
            oWriter.write((char)iReader.read()); //将输入字符流给输出字符流，写入文件中
            oWriter.flush(); //这是个循环需要刷新缓存
        }
         iReader.close();//关闭流
         oWriter.close();
         fStream.close();
         fStream2.close();
}

将内存数据写入文件1.txt，在从文件1.txt中的数据读取出来到内存中

代码演示：
 1 public static void main(String[] args) throws IOException {   
 2          String string="style周";
 3          FileOutputStream fOutputStream=new FileOutputStream("1.txt");
 4          OutputStreamWriter oWriter=new OutputStreamWriter(fOutputStream,"utf-8");//创建字符输出流，设置字符编码
 5          oWriter.write(string);          //将字符串写入字符输出流中，写入文件
 6          oWriter.close();        //关闭流
 7          fOutputStream.close();
 8          FileInputStream fInputStream=new FileInputStream("1.txt");
 9          InputStreamReader iReader=new InputStreamReader(fInputStream,"utf-8");//创建字符输入流，字符编码设置
10          StringBuffer sBuffer=new StringBuffer();    //设置一个字符变量接收
11          while (iReader.ready()) {
12             sBuffer.append((char)iReader.read());   //添加到字符串中
13         }
14          iReader.close();//关闭流
15          fInputStream.close();
16          System.out.println(sBuffer);
17 }

这里我需要讲解一下flush用法

 flush的作用是用于在数据缓存中数据满了之后刷新该缓存，然后对剩下的数据继续进行缓存。如果要写入的数据量很小，或者你自己定义的缓存足够大到可以保存所有数据的话，不用flush也不会丢失数据，但是如果要写入的数据大小操作缓存大小，则需要循环多步才能处理完，这时不用flush就会导致只有最前面的一些数据能够写入，而剩下的数据会丢失。只有字符流才有刷新

缓冲区

        计算机访问外部设备非常耗时。访问外存的频率越高，造成CPU闲置的概率就越大。为了减少访问外存的次数，应该在一次对外设的访问中，读写更多的数据。为此，除了程序和流节点间交换数据必需的读写机制外，还应该增加缓冲机制。缓冲流就是每一个数据流分配一个缓冲区，一个缓冲区就是一个临时存储数据的内存。这样可以减少访问硬盘的次数,提高传输效率。  

1. 字符流的缓冲区：BufferedReader和BufferedWreiter

* 缓冲区的出现时为了提高流的操作效率而出现的.

* 需要被提高效率的流作为参数传递给缓冲区的构造函数

* 在缓冲区中封装了一个数组，存入数据后一次取出

BufferedReader

自带了缓冲区，需要一个Reader对象来构建这个BufferedReader对象---BufferedReader最主要的作用提供缓冲区，从字符输入流中来获取数据；Reader对象来指名数据的具体来源

简单代码实现：
 1  public static void main(String[] args) throws IOException {   
 2          FileReader fReader=new FileReader("1.txt");//创建一个文件读取对象，并读取文件
 3          BufferedReader bReader=new BufferedReader(fReader);//将文件内容放入缓冲区中------  需要被提高效率的流作为参数传递给缓冲区的构造函数
 4          StringBuffer sBuffer=new StringBuffer();   //创建一个StringBuffer类的字符串后面接收读出的数据
 5          while (bReader.ready()) {  //循环读取知道文件尾部
 6             sBuffer.append((char)bReader.read());//将文件内容逐一添加到sBuffer中
 7  }
 8 System.out.println(sBuffer.toString());//输出
 9 fReader.close();//关闭读取流
10 bReader.close();//关闭缓冲区读取流
11 }

 

BufferedWriter

代码实现：
 1  public static void main(String[] args) throws IOException {   
 2              FileWriter  fWriter=new FileWriter("1.txt");//创建写入流对象，并指定创建的文件路径；
 3              BufferedWriter bWriter=new BufferedWriter(fWriter);//创建写入流的缓冲区
 4              bWriter.write("abcdf");//向缓冲区写入字符
 5              bWriter.flush(); //刷新缓冲区
 6              bWriter.newLine();//newLine()在不同的操作系统下自动转义为当前系统认识对的回车换行
 7              bWriter.write("qwer");
 8 bWriter.flush(); //刷新缓冲区
 9 bWriter.close();//关闭缓冲区
10 fWriter.close();//关闭写入流
11 }

字节流缓冲区

BufferedInputStream:当向缓冲流写入数据时候，数据先写到缓冲区，待缓冲区写满后，系统一次性将数据发送给输出设备。

 1      public static void main(String[] args) throws IOException {   
 2          FileInputStream fStream=new FileInputStream("1.txt");
 3          BufferedInputStream bStream=new BufferedInputStream(fStream); //字节输入流缓冲区，，
 4          int ch=0;
 5          while ((ch=bStream.read())!=-1) {
 6             System.out.print((char)ch);
 7         }
 8          fStream.close();//关闭流
 9          bStream.close();
10      }

BufferedOutputStream :当从向缓冲流读取数据时候，系统先从缓冲区读出数据，待缓冲区为空时，系统再从输入设备读取数据到缓冲区。

1  public static void main(String[] args) throws IOException {   
2         int ch=1561;//因为写入的是int类型的，所以用用int，也可以用    System.in.read()键盘输入字符，转换成ASKII 码（一个 int 整数）
3         FileOutputStream fOutputStream=new FileOutputStream("1.txt");
4         BufferedOutputStream bStream=new BufferedOutputStream(fOutputStream);//创建字节输出流缓冲区对象
5         bStream.write(ch); //将字节写入文件中
6         bStream.close();//关闭流
7         fOutputStream.close();
8         }

 

系统流/标准流---字节流

底层使用字节流来实现的

System.out   标准输出流

System.in    标准输入流

System.err   标准错误流

标签：

相关文章