Java--IO流

最新推荐文章于 2024-07-18 16:29:57 发布

liu。。。。

最新推荐文章于 2024-07-18 16:29:57 发布

阅读量143

点赞数

分类专栏： java 文章标签： java

本文链接：https://blog.csdn.net/qq_48186679/article/details/119489161

版权

java 专栏收录该内容

17 篇文章 0 订阅

订阅专栏

一、IO的概述

1.什么是Io流？

IO Stream（input output Steam）：输入输出流
本质指的就是计算机中数据的流入和流出：
从磁盘上将数据读入内存
从内存中将数据写入到硬盘
也就是说，从狭义上来说，我们一般IO流指的就是磁盘和内存之间的数据流动

但是从广义来说，不同电脑之间的数据流动，也是一种IO流，网络通信也是IO流（socket）
在本地进程间的数据流动，就是狭义上的IO流
在远程进程间的数据流动，也就是一种IO流（Socket）

Java的I0流是实现输入/输出的基础，它可以方便地实现数据的输入/输出操作，在Java中把不同的输入输出源(键盘、文件、网络连接等)抽象表述为“流”(stream),通过流的方式允许Java 程序使用相同的方式来访问不同的输入/输出源。stream 是从起源(source) 到接收(sink) 的有序数据。Java把所有传统的流类型(类或抽象类)都放在java.io包中，用以实现输入输出功能。

2.IO流的分类

1.输入流和输出流

按照流的流向来分，可以分为输入流和输出流。
输入流: 只能从中读取数据，而不能向其写入数据。
输出流:只能向其写入数据，而不能从中读取数据。

2.字节流和字符流

字节流和字符流的用法几乎完全一样，区别在于字节流和字符流所操作的数据单元不同一字节流
操作的数据单元是8位的字节，而字符流操作的数据单元是16位的字符。
字节流主要由ipuStraem和OupuStram作为基类，而字符流则主要由Reader和Witer作为基类。

3.根据作用

节点流
装饰流（过滤流）

4.转换流

转换字节流和字符流

二、File类

1.File类的构造函数和分隔符

继续查阅File的构造函数，发现原来File类有多个构造函数，可以构造File对象。

public class FileDemo {
   public static void main(String[] args) { 
	//File构造函数演示 
	 String pathName = "e:\\java_code\\day22e\\hello.java"; 
	File f1 = new File(pathName);
	
	 //将Test22文件封装成File对象。注意；
	 //有可以封装不存在文件 或者文件夹，变成对 象。 
	System.out.println(f1); File f2 = new File
	("e:\\java_code\\day22e","hello.java"); 
	System.out.println(f2); 
	/将parent封装成file对象。 
	File dir = new File("e:\\java_code\\day22e");
	File f3 = new File(dir,"hello.java"); 
	System.out.println(f3); 
	//File类中几个静态的成员属性，其中separator描述的与操作系统相关的路径分隔符 
	File f5 = new File("e:"+File.separator+"java_code"+
 File.separator+"day22e"+File.separator+"hello.java"); 
		}
}

2.File类的获取

public class FileMethodDemo { 
     public static void main(String[] args) {
      //创建文件对象 
      File file = new File("Test22.java"); 
      //获取文件的绝对路径，即全路径
       String absPath = file.getAbsolutePath(); 
       //File中封装的路径是什么获取到的就是什么。 
       String path = file.getPath(); 
       //获取文件名称 String filename = file.getName(); 
       //获取文件大小 long size = file.length(); 
       //获取文件修改时间，获取到的是毫秒值，
       //可以使用日期格式化把毫秒值转成字符串文本格式 
       long time = file.lastModified(); 
       System.out.println("absPath="+absPath);   
       System.out.println("path="+path); 
       System.out.println("filename="+filename); 
       System.out.println("size="+size); 
       System.out.println("time="+time); 
       // 毫秒值--Date--格式化--字符串文本 
       String str_date = DateFormat.getDateTimeInstance
       (DateFormat.LONG,DateFormat.LONG).format(new Date(time)); 
       System.out.println(str_date); 
       }
 }

3.文件和文件夹的创建删除

public class FileMethodDemo2 { 
 public static void main(String[] args) throws IOException { 
     // 对文件或者文件加进行操作。 
     File file = new File("e:\\file.txt");
      // 创建文件，如果文件不存在，创建 true 如果文件存在，
      //则不创建 false。 如果路径错误， IOException。 
      boolean b1 = file.createNewFile(); 
      System.out.println("b1=" + b1);
       //-----------删除文件操作-------注意：不去回收站。慎用------
       boolean b2 = file.delete(); 
       System.out.println("b2="+b2);
          //-----------需要判断文件是否存在------------
                 boolean b3 = file.exists(); 
             System.out.println("b3="+b3); 
                         //-----------对目录操作 创建，删除，判断------------
              File dir = new File("e:\\abc");
                             //mkdir()创建单个目录。
           //dir.mkdirs();创建多级目录 
           boolean b4 = dir.mkdir(); 
           System.out.println("b4="+b4); 
           //删除目录时，如果目录中有内容，无法直接删除。
            boolean b5 = dir.delete(); 
            //只有将目录中的内容都删除后，保证该目录为空。
            //这时这个目录才可以删除。
             System.out.println("b5=" + b5); 
             //-----------判断文件，目录------------
            File f = new File("e:\\javahaha");
           // 要判断是否是文件还是目录，必须先判断存在。
               // f.mkdir();//f.createNewFile(); 
               System.out.println(f.isFile()); 
               System.out.println(f.isDirectory()); 
         } 
 }

4.文件过滤器

在File类的 list()方法中可以接收一个 FilenameFilter 参数(Filter译:过滤),通过该参数可以只列出符合条件的文件。这里的FilenameFilter 接口和 javax.swing.filechooser 包下的 FileFilter 抽象类的功能非常相似，可以把 FileFilter 当成 FilenameFilter 的实现类，（实际并不是它实现类）

FilenameFilter 接口里包含了一个 accept(File dir, String name)方法该方法将依次对指定 File 的所有子目录或者文件进行迭代；如果该方法返回true，则 list() 方法会列出该子目录或者文件。
boolean accept(File dir, String name)
该方法测试指定文件是否包含在文件列表中。
dir - 找到该文件的目录。
name - 文件的名称。 (包括目录)
true 当该名称包含在文件列表中时; false否则。 (名称包含目录，和文件)
. 点代表当前根目录

public static void main(String[] args) {

		File file = new File(".");

		// 使用 Lambda 表达式(目标类型为 FilenameFilter)
		// 如果文件名以.java 结尾，或该文件是一个目录(文件夹)
		String d;
		String[] nameList = file.list((dir, name) -> name.endsWith(".java") 
		|| new File(name).isDirectory());
		for (String name : nameList) {
			System.out.println(name);
		}
	}

三、字节流

1.数据写入文件中

通过api查找output。找到很多，其中java.io.OutputStream， OutputStream: 输出字节流的超类。

基本特点：

操作的数据都是字节。
定义了输出字节流的基本共性功能。
输出流中定义都是写write方法。
操作字节数组write(byte[])，操作单个字节write(byte)。
5.子类有规律：所有的子类名称后缀是父类名，前缀名是这个流对象功能。

public class FileOutputStreamDemo {
   public static void main(String[] args) throws IOException { 
        //需求：将数据写入到文件中。 //创建临时目录， 
          File dir = new File("tempfile"); 
          if(!dir.exists()){
            dir.mkdir();
           }
           //创建存储数据的文件。 
           File file = new File(dir,"file.txt");
            //创建一个用于操作文件的字节输出流对象。
           // 一创建就必须明确数据存储目的地。 
            //输出流目的是文件，会自动创建。如果文件存在，则覆盖。           FileOutputStream fos = new FileOutputStream(file); 
            //调用父类中的write方法。
             byte[] data = "abcde".getBytes();
                  fos.write(data); //关闭流资源。
               fos.close(); 
               }
     }

2.IO异常的处理

public class FileOutputStreamDemo3 {
    public static void main(String[] args) { 
          File file = new File("k:\\file.txt"); 
          //定义FileOutputStream的引用 
          FileOutputStream fos = null; 
          try {//创建FileOutputStream对象
                  fos = new FileOutputStream(file); 
                  //写出数据
                   fos.write("abcde".getBytes()); 
            } catch (IOException e) { 
                  System.out.println(e.toString() + "----"); 
             } finally {
              //一定要判断fos是否为null，
              //只有不为null时，才可以关闭资源
               if (fos != null) { 
               try {
                    fos.close();
               } catch (IOException e) { 
               throw new RuntimeException(""); }
              }
          }
     }
 }

3. 读取数据read方法

通过api查找input。java.io.InputStream InputStream：字节输入流的超类。
常见功能：

int read():读取一个字节并返回，没有字节返回-1.
int read(byte[]): 读取一定量的字节数，并存储到字节数组中，返回读取到的字节数。

用于读取文件的字节输入流对象：FileInputStream。

public class FileInputStreamDemo { 
   public static void main(String[] args) throws IOException { 
        File file = new File("tempfile\\file.txt"); 
        //创建一个字节输入流对象,必须明确数据源，
        //其实就是创建字节读取流和数据源相关联。
         FileInputStream fis = new FileInputStream(file); 
         //读取数据。使用 read();一次读一个字节。
          int ch = 0; 
          while((ch=fis.read())!=-1){
           System.out.println("ch="+(char)ch);
            }// 关闭资源。
           fis.close(); 
    } 
}

4.读取数据read(byte[])方法

在读取文件中的数据时，调用read方法，每次只能读取一个，太麻烦了，于是我们可以定义数组作
为临时的存储容器，这时可以调用重载的read方法，一次可以读取多个字符。

public class FileInputStreamDemo2 { 
      public static void main(String[] args) throws IOException {
            /** 演示第二个读取方法， 
            read(byte[]); 
            */
          File file = new File("tempfile\\file.txt"); 
          // 创建一个字节输入流对象,必须明确数据源，
          //其实就是创建字节读取流和数据源相关联。
           FileInputStream fis = new FileInputStream(file); 
           //创建一个字节数组。
            byte[] buf = new byte[1024];
            //长度可以定义成1024的整数倍。 
            int len = 0; 
            while((len=fis.read(buf))!=-1){ 
               System.out.println(new String(buf,0,len));
               }
            fis.close(); 
      } 
}

5.复制文件

原理；读取一个已有的数据，并将这些读到的数据写入到另一个文件中

public class CopyFileTest { 
    public static void main(String[] args) throws IOException { 
        //1,明确源和目的。 
        File srcFile = new File("E:\\1.mp3");
          File destFile = new File("E:\\copy_2.mp3"); 
          //2,明确字节流 输入流和源相关联，输出流和目的关联。           
          FileInputStream fis = new FileInputStream(srcFile); 
          FileOutputStream fos = new FileOutputStream(destFile);
           //3, 使用输入流的读取方法读取字节，并将字节写入到目的中。 
           int ch = 0; 
           while((ch=fis.read())!=-1){
                  fos.write(ch); 
              }
              //4,关闭资源。
           fos.close();
      }
  }

6.自定义缓冲数组复制

述代码复制文件效率太低了，并且频繁的从文件读数据，和写数据，能不能一次多把文件中多个数据都读进内容中，然后在一次写出去，这样的速度一定会比前面代码速度快。
public class CopyFileByBufferTest {
     public static void main(String[] args) throws IOException { 
           File srcFile = new File("E:\\1.mp3"); 
           File destFile = new File("E:\\copy_1.mp3");
           // 明确字节流 输入流和源相关联，输出流和目的关联。
            FileInputStream fis = new FileInputStream(srcFile); 
            FileOutputStream fos = new FileOutputStream(destFile); 
            //定义一个缓冲区。
             byte[] buf = new byte[1024];
              int len = 0;
               while ((len = fis.read(buf)) != -1) {
                     fos.write(buf, 0, len);
               // 将数组中的指定长度的数据写入到输出流中。 
               }
               // 4,关闭资源。
               fos.close();
                fis.close();
     } 
 }

7.缓冲区

在前面文件读写的时候，我们一直都是在使用自己的定义的数组作为缓冲区，其实在IO流体系中有相应的缓冲区对象。

public class BufferedDemo {
    public static void main(String[ ] args) throws IOException {
           long start = System. currentTimeMillis() ;
         BufferedInputStream bufIn = new BufferedInputStream(
           new FileInputStream("E:\\1.mp3")) ;
         Buffered0utputStream bufOut = new Buffered0utputStream
           ( new File0utputStream("e:\\2.mp3")) ;

         FileInputStream fis= new FileInputStream("E:\\1.mp3") ;

       FileOutputStream fos = new File0utputStream( "e:\\2.mp3") ;
               byte[] buf = new byte[1024];
                 int len = 0;
               while((len = bufIn.read())!=-1){
                  bufOut . write(len) ;
                  buf0ut . flush() ;
                  bufIn. close() ;
                  buf0ut. close() ;
                 long end = System . cur rentTimeMillis();
                       System . out . println(end-start) ;
      } 
 }

三、字符流

1.字节流读取字符的问题

通过以下程序读取带有中文件的文件。

public static void main(String[] args) throws IOException { 
  //给文件中写中文 
     writeCNText(); 
      //读取文件中的中文 
     readCNText(); }
     //读取中文 
     public static void readCNText() throws IOException { 
     FileInputStream fis = new FileInputStream("D:\\test\\cn.txt"); 
     int ch = 0; 
     while((ch = fis.read())!=-1){ 
         System.out.println(ch);
       } 
    }
    //写中文 
    public static void writeCNText() throws IOException {
      FileOutputStream fos = new FileOutputStream("D:\\test\\cn.txt");
       fos.write("欢迎你".getBytes());
       fos.close(); 
    }

2.FileReader类介绍

打开FileReader的API介绍。用来读取字符文件的便捷类。此类的构造方法假定默认字符编码和默认字节缓冲区大小都是适当的
FileReader 用于读取字符流。使用FileReader时，了解它的功能，看它所属的体系顶层。
Reader：读取字符流的抽象超类。read():读取单个字符并返回， read(char[]):将数据读取到数组中，并返回读取的个数。

public class CharStreamDemo { 
    public static void main(String[] args) throws IOException { 
       //给文件中写中文 
        writeCNText(); 
        //读取文件中的中文
         readCNText(); 
     }
     //读取中文
    public static void readCNText() throws IOException { 
       FileReader fr = new FileReader("D:\\test\\cn.txt"); 
       int ch = 0;
       while((ch = fr.read())!=-1){ 
            //输出的字符对应的编码值 
         System.out.println(ch); //输出字符本身 
         System.out.println((char)ch); 
        } 
   }
   //写中文 
   public static void writeCNText() throws IOException { 
      FileOutputStream fos = new FileOutputStream("D:\\test\\cn.txt");
         fos.write("欢迎你".getBytes());
       f.colse();
   }
}

3.FileWriter类介绍

既然有专门用于读取字符的流对象，那么肯定也有写的字符流对象，查阅API，发现有一个Writer类，Writer是写入字符流的抽象类。其中描述了相应的写的动作。

public class FileWriterDemo { 
    public static void main(String[] args) throws IOException { 
    //演示FileWriter 用于操作文件的便捷类。
     FileWriter fw = new FileWriter("d：\\text\\fw.txt");
         fw.write("你好谢谢再见");
         //这些文字都要先编码。都写入到了流的缓冲区中。
         fw.flush();
          fw.close(); 
   }
 }

四、转换流

1. OutputStreamWriter类

OutputStreamWriter 是字符流通向字节流的桥梁：可使用指定的 charset 将要写入流中的字符编码成字节。它的作用的就是，将字符串按照指定的编码表转成字节，在使用字节流将这些字节写出去。

public static void writeCN() throws Exception { 
  //创建与文件关联的字节输出流对象
   FileOutputStream fos = new FileOutputStream("D:\\test\\cn8.txt"); 
   //创建可以把字符转成字节的转换流对象，并指定编码 
   OutputStreamWriter osw = new OutputStreamWriter(fos,"utf-8"); 
   //调用转换流，把文字写出去，其实是写到转换流的缓冲区中 
   osw.write("你好");
   //写入缓冲区。 
   osw.close(); 
 }

OutputStreamWriter流对象，它到底如何把字符转成字节输出的呢？

其实在OutputStreamWriter流中维护自己的缓冲区，当我们调用OutputStreamWriter对象的write方法时，会拿着字符到指定的码表中进行查询，把查到的字符编码值转成字节数存放到OutputStreamWriter缓冲区中。然后再调用刷新功能，或者关闭流，或者缓冲区存满后会把缓冲区中的字节数据使用字节流写到指定的文件中。

2. InputStreamReader类

查阅InputStreamReader的API介绍，InputStreamReader 是字节流通向字符流的桥梁：它使用指定的charset 读取字节并将其解码为字符。它使用的字符集可以由名称指定或显式给定，或者可以接受平台默认的字符集。

public class InputStreamReaderDemo { 
     public static void main(String[] args) throws IOException { 
       //演示字节转字符流的转换流 
        readCN(); 
      }
      public static void readCN() throws IOException{ 
          //创建读取文件的字节流对象
           InputStream in = new FileInputStream("D:\\test\\cn8.txt");
            //创建转换流对象 
            //InputStreamReader isr = new InputStreamReader(in);
            //这样创建对象，会用本地默认码表 读取，将会发生错误解码的错误      
            InputStreamReader isr = new InputStreamReader(in,"utf-8");
             //使用转换流去读字节流中的字节
              int ch = 0;
              while((ch = isr.read())!=-1){ 
                  System.out.println((char)ch); 
                }
                //关闭流 
               isr.close(); 
    } 
 }

五、基本类型数据流

操作基本数据值的对象。
DataInputStream DataOutputStream
用于操作基本数据类型值。write基本类型 read基本类型。

public class DataStreamDemo {
   public static void main(String[] args) throws IOException {    
       writeData();
       readData(); 
    }
    public static void readData() throws IOException {
       FileInputStream fis = new FileInputStream("tempfile\\data.txt");     
       DataInputStream dis = new DataInputStream(fis);
       boolean b = dis.readBoolean(); 
       System.out.println(b); 
       dis.close(); 
    }
    public static void writeData() throws IOException {
     //写入一些基本数据值。存储到文件。 
     FileOutputStream fos = new FileOutputStream("tempfile\\data.txt");  
     DataOutputStream dos = new DataOutputStream(fos);  
     dos.writeBoolean(true); 
     dos.close(); 
  } 
}

六、对象流

1.java对象流介绍
对象流主要是将java中具体的对象转换为字节序列（配合文件流可以将对象保存在文件中）
也可以将序列化的对象反序列化转换为对象（配合文件流可以将文件中保存的对象读出来）

2.流操作对象的限制
public class Student implements Serializable{
对象必须实现Serializable这个空接口

3.ObjectInput与ObjectOutput对文件操作实例

public class ObjectTest {
 
	public static void main(String[] args) throws IOException, ClassNotFoundException {
		FileOutputStream fos=new FileOutputStream("c:\\jiangwei.data");
		ObjectOutputStream os=new ObjectOutputStream(fos);
		os.writeObject(new Student(1,"xiaojiang",19));
		os.writeObject(new Student(2,"xiaoming",18));
		os.close();
		fos.close();
        FileInputStream fis=new FileInputStream("c:\\jiangwei.data");
        ObjectInputStream ois=new ObjectInputStream(fis);
        Student st1=(Student)ois.readObject();
        Student st2=(Student)ois.readObject();
        fis.close();
        ois.close();
        System.out.println(st1.toString());
        System.out.println(st2.toString());
	}
 
}

1.对象序列化流

用于操作对象的流对象。对象的序列化。ObjectOutputStream
特点：用于操作对象。
解决问题：可以将对象进行序列化和反序列化。
注意：对象序列化一定要实现Serializable接口。为了给类定义一个serialVersionUID。
功能：ObjectInputStream readObject() ObjectOutputStream writeObject()
关键字：瞬态：transient

public class ObjectStreamDemo { 
      public static void main(String[] args) throws IOException,   
           ClassNotFoundException { 
           /** 将一个对象存储到持久化(硬盘)的设备上。 
           */ 
           writeObj()
           //对象的序列化。 
      }
      public static void writeObj() throws IOException { 
          //1,明确存储对象的文件。
          FileOutputStream fos = new FileOutputStream("tempfile\\obj.object");  
          //2，给操作文件对象加入写入对象功能。 
          ObjectOutputStream oos = new ObjectOutputStream(fos); 
          //3，调用了写入对象的方法。
           oos.writeObject(new Person("wangcai",20)); 
           //关闭资源。
            oos.close();
      } 
}

2.对象反序列化流

当把一个对象持久化存储起来之后，需要使用反序列化技术获取存储起来的对象使用此ObjectInputStream对象就可以完成反序列化动作

```javascript
public class ObjectStreamDemo { 
    public static void main(String[] args) throws IOException, 
    ClassNotFoundException { 
          readObj();
          //对象的反序列化。 
    }
    public static void readObj() throws IOException, 
    ClassNotFoundException {
        //1,定义流对象关联存储了对象文件。 
        FileInputStream fis = new FileInputStream("tempfile\\obj.object"); 
        //2,建立用于读取对象的功能对象。 
        ObjectInputStream ois = new ObjectInputStream(fis); 
        Person obj = (Person)ois.readObject(); 
        System.out.println(obj.toString()); 
     } 
}

3.序列化接口

当一个对象要能被序列化，这个对象所属的类必须实现Serializable接口。否则会发生异常NotSerializableException异常。同时当反序列化对象时，如果对象所属的class文件在序列化之后进行的修改，那么进行反序列化也会发生异常InvalidClassException。

发生这个异常的原因如下：
1.该类的序列版本号与从流中读取的类描述符的版本号不匹配
2.该类包含未知数据类型
3.该类没有可访问的无参数构造方法
4.Serializable标记接口。该接口给需要序列化的类，提供了一个序列版本号。serialVersionUID. 该版本号的目的在于验证序列化的对象和对应类是否版本匹配。
5.瞬态关键字
6.当一个类的对象需要被序列化时，某些属性不需要被序列化，这时不需要序列化的属性可以使用关键字transient修饰。只要被transient修饰了，序列化时这个属性就不会琲序列化了。
7.同时静态修饰也不会被序列化，因为序列化是把对象数据进行持久化存储，而静态的属于类加载时的数据，不会被序列化。

public class Person implements Serializable { 
    /*
    * 给类显示声明一个序列版本号。 
    */ 
    private static final long serialVersionUID = 1L;
    private static String name;
    private transient/*瞬态*/ int age; 
     public Person() { 
         super(); 
      }
      public Person(String name, int age) { 
             super(); 
             this.name = name; 
             this.age = age; 
       }
       public String getName() { 
              return name;
      }
      public void setName(String name) { 
              this.name = name; 
       }
       public int getAge() {
             return age;
       }
       public void setAge(int age) { 
              this.age = age;
        }
        @Override 
        public String toString() { 
             return "Person [name=" + name + ", age=" + age + "]"; 
       } 
}

七、Properties类介绍

特点：

Hashtable的子类，map集合中的方法都可以用。
该集合没有泛型。键值都是字符串。
它是一个可以持久化的属性集。键值可以存储到集合中，也可以存储到持久化的设备上。键值的来源也可以是持久化的设备。
有和流技术相结合的方法。load(InputStream) load(Reader) store(OutputStream,commonts); stroe(Writer,comments)

Properties（Java.util.Properties），主要用于读取Java的配置文件，各种语言都有自己所支持的配置文件，配置文件中很多变量是经常改变的，这样做也是为了方便用户，让用户能够脱离程序本身去修改相关的变量设置。像Python支持的配置文件是.ini文件，同样，它也有自己读取配置文件的类ConfigParse，方便程序员或用户通过该类的方法来修改.ini配置文件。在Java中，其配置文件常为.properties文件，格式为文本文件，文件的内容的格式是“键=值”的格式，文本注释信息可以用"#"来注释。

Properties类的方法
在这里插入图片描述

import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;
    import com.qianfeng.login.LoginServlet;
    public class ProUtils {
    	private static Properties pro = null;
    	static {
    		// 创建Properties 对象
    		pro = new Properties();
    
    		// 针对普通java程序和web程序都可以获取文件路径
    		// web程序， / 相对于classes目录，不写/ ,相对于调用方的类所在的包
    	
		// 将读到的文件直接转换为输入流
		InputStream inputStream = ProUtils.class.getResourceAsStream("/info.properties");

		// 加载properties文件
		try {
			pro.load(inputStream);
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	
	public static String getName(){
		return pro.getProperty("name");
	}
	
	public static String getPassword(){
		return pro.getProperty("password");
	}
	
}

liu。。。。

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java--IO流

一、IO的概述1.什么是Io流？IO Stream（input output Steam）：输入输出流本质指的就是计算机中数据的流入和流出：从磁盘上将数据读入内存从内存中将数据写入到硬盘也就是说，从狭义上来说，我们一般IO流指的就是磁盘和内存之间的数据流动但是从广义来说，不同电脑之间的数据流动，也是一种IO流，网络通信也是IO流（socket）在本地进程间的数据流动，就是狭义上的IO流在远程进程间的数据流动，也就是一种IO流（Socket）Java的I0流是实现输入/输出的基础
复制链接

扫一扫