5-01 Java IO编程

怼烎@ 2022-02-27 06:54 228阅读 0赞

**目录**

一.文件对象

二.IO 简介

三.流分类

四.IO 字节流

五.IO 对象流

六.IO 数据流

七.IO 字符流

八.IO 缓存流

九.常用操作

十.读取Classpath下的文件

--------------------

#  一.文件对象 #

文件和文件夹都是用File代表

> 1.文件创建
> 
> 2.文件常用方法

1.文件创建

try {
       //参数前面作为目录,最后/后面的作为文件名
       File file=new File("/Users/zhouzhenlin/Public/space/workbench/test.rtf");
       file.createNewFile();
       System.out.println(file.getAbsolutePath());
    }catch (Exception e){
       e.printStackTrace();
    }

2.文件常用方法

createNewFile()：创建一个新文件
    mkdir()  创建目录
    mkdirs() 创建目录,如果父目录不存在同时创建
    isFile()：是否是文件
    isDirectory()：是否是目录
    获取路径／绝对路径／规范路径：getPath() / getAbsolutePath() / getCanonicalPath()
    文件操作：
    canRead()：是否允许读取该文件
    canWrite()：是否允许写入该文件
    canExecute()：是否允许运行该文件
    length()：获取文件大小
    f.exists() 文件是否存在
    f.lastModified() 文件最后修改时间
    delete()：删除该文件
    renameTo(f2) 文件重命名
                                                   
    //文件最后修改时间
    long time = f.lastModified();
    Date d = new Date(time);
    System.out.println("获取文件的最后修改时间："+d);
    //设置文件修改时间为1970.1.1 08:00:00
    f.setLastModified(0);
              
    //文件重命名
    File f2 =new File("d:/LOLFolder/DOTA.exe");
    f.renameTo(f2);
    System.out.println("把LOL.exe改名成了DOTA.exe");

# 二.IO 简介 #

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xkdXpoZW5saW4_size_16_color_FFFFFF_t_70][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xkdXpoZW5saW4_size_16_color_FFFFFF_t_70 1][]

1.流

什么是流(Stream)，流就是一系列的数据

IO: Input / Output

# 三.流分类 #

字节流：
       InputStream outputStream
    
       FileInputStream  FileOutputStream
    
    字符流：
       FileReader  FileWrite
    
    将字节流转换成字符流：
       InputStreamReader  InputStreamWriter
    
    字符包装流：
       BufferedReader  BufferedWriter

# 四.IO 字节流 #

用于以字节的形式读取和写入数据

字节输入流:InputStream   FileInputStream

字节输出流:OutputStream  FileOutputStream

//以字节流的形式 从文件读取数据
    
    //read() 从该输入流读取一个字节的数据
    //read(byte[] b) 从该输入流读取最多 b.length个字节的数据为字节数组
    //read(byte[] b, int off, int len) 从该输入流读取最多 len字节的数据为字节数组。
    InputStream fis=null;
    try {
       File file=new File("/Users/zhouzhenlin/Public/space/workbench/test.txt");
       fis=new FileInputStream(file);
    
       byte[] temp=new byte[1024];
       int length=0;
       while ((length=fis.read(temp))!=-1) {
          System.out.write(temp,0,temp.length);
       }
    }catch (IOException e){
       e.printStackTrace();
    }finally {
       if(fis!=null){
        try {
            fis.close();
         }catch (IOException e){
             e.printStackTrace();
         }
    
       }
    }

//以字节流的形式 向文件写入数据
    try {
        File file1=new  File("/Users/zhouzhenlin/Public/space/workbench/test.txt");
        try(FileOutputStream fos=new FileOutputStream(file1)){
        // 准备长度是2的字节数组，用88,89初始化，其对应的字符分别是X,Y
        byte[] data = {88, 89};
        fos.write(data);
        fos.flush();
        }
    }catch (IOException e){
        e.printStackTrace();
    }

# 五.IO 对象流 #

对象输入流 ObjectInputStream

对象输出流 ObjectOutStream

对象流指的是可以直接把一个对象以流的形式传输给其他的介质，比如硬盘   
一个对象以流的形式进行传输，叫做序列化。 该对象所对应的类，必须是实现Serializable接口

try
    {
      Student student=new Student("Joe",22);
      File file=new File("/Users/zhouzhenlin/Public/space/workbench/test.txt");
      ObjectOutputStream objectOutputStream=new ObjectOutputStream(new FileOutputStream(file));
      objectOutputStream.writeObject(student);
      objectOutputStream.close();
    
      //反序列化
      ObjectInputStream objectInputStream=new ObjectInputStream(new FileInputStream(file));
      Student stu=(Student) objectInputStream.readObject();
      System.out.println(stu.getName()+" "+stu.getAge());
      objectInputStream.close();//应该在 finally 里面关闭的 偷懒
    } catch(Exception e)
    {
        e.printStackTrace();
    }

# 六.IO 数据流 #

数据输入流 DataInputStream    
数据输出流 DataOutputStream

*  DataOutputStream：数据输出流允许应用程序以适当方式将基本 Java 数据类型写入输出流中。然后应用程序可以使用数据输入流将数据读入。 
 *  DataInputStream：数据输入流允许应用程序以与机器无关方式从底层输入流中读取基本 Java 数据类型。应用程序可以使用数据输出流写入稍后由数据输入流读取的数据。对于多线程访问不一定是安全的。 线程安全是可选的，它由此类方法的使用者负责。

有时没有必要存储整个对象的信息，而只是要存储一个对象的成员数据，成员数据的类型假设都是Java的基本数据类型，这样的需求不必使用到与Object输入、输出相关的流对象，可以使用DataInputStream、DataOutputStream来写入或读出数据.

Student[] students = {new Student("Justin",90),
                    new Student("momor",95),
                    new Student("Bush",88)};
    try
    {
      File file=new File("/Users/zhouzhenlin/Public/space/workbench/test.txt");
      DataOutputStream dataOutputStream = new DataOutputStream(new FileOutputStream(file));
      for(Student student:students)
      {
        //写入UTF字符串
        dataOutputStream.writeUTF(student.getName());
        //写入int数据
        dataOutputStream.writeInt(student.getAge());
      }
      //所有数据至目的地
      dataOutputStream.flush();
      //关闭流
      dataOutputStream.close();
    
      DataInputStream dataInputStream = new DataInputStream(new FileInputStream(file));
      //读出数据并还原为对象
      for(int i=0;i<students.length;i++)
      {
         //读出UTF字符串
         String name = dataInputStream.readUTF();
         //读出int数据
         int age = dataInputStream.readInt();
         students[i] = new Student(name,age);
       }
       //关闭流
       dataInputStream.close();
       //显示还原后的数据
       for(Student student : students)
       {
           System.out.printf("%s\t%d%n",student.getName(),student.getAge());
       }
    } catch(IOException e)
    {
         e.printStackTrace();
    }

# 七.IO 字符流 #

专门用于字符的形式读取和写入数据

字符输入流  Reader  FileReader  
字符输出流  Writer     FileWriter

try
    {
        //用字符流从文件写入数据
        File file=new File("/Users/zhouzhenlin/Public/space/workbench/test.txt");
        FileWriter fw=new FileWriter(file);
        fw.write("Hello World!");
        fw.close();//应该在 finally 里面关闭 偷懒
    
        //用字符流从文件读取数据
        FileReader fr=new FileReader(file);
        char[] temp=new char[32];
        int length=0;
        while ((length=fr.read(temp))!=-1){
            System.out.println(temp);
        }
            fr.close();
    
    } catch(Exception e)
    {
        e.printStackTrace();
    }

# 八.IO 缓存流 #

以介质是硬盘为例，字节流和字符流的弊端：   
在每一次读写的时候，都会访问硬盘。 如果读写的频率比较高的时候，其性能表现不佳。   
  
为了解决以上弊端，采用缓存流。   
缓存流在读取的时候，会一次性读较多的数据到缓存中，以后每一次的读取，都是在缓存中访问，直到缓存中的数据读取完毕，再到硬盘中读取。   
  
就好比吃饭，不用缓存就是每吃一口都到锅里去铲。用缓存就是先把饭盛到碗里，碗里的吃完了，再到锅里去铲   
  
缓存流在写入数据的时候，会先把数据写入到缓存区，直到缓存区达到一定的量，才把这些数据，一起写入到硬盘中去。按照这种操作模式，就不会像字节流，字符流那样每写一个字节都访问硬盘，从而减少了IO操作

try
    {
        //用字符流从文件写入数据
        File file=new File("/Users/zhouzhenlin/Public/space/workbench/test.txt");
        FileWriter fw=new FileWriter(file);
        BufferedWriter bw=new BufferedWriter(fw);
        bw.write("Hello World!");
        bw.close();
    
        FileReader fr=new FileReader(file);
        BufferedReader br=new BufferedReader(fr);
        while(true){
           String line=br.readLine();
           if(line==null) break;
           System.out.println(line);
        }
        br.close();
    } catch(Exception e)
    {
        e.printStackTrace();
    }

# 九.常用操作 #

只需要掌握下面三种流即可：
    
    字节流：
    
    inputStream outputStream
    
    FileInputStream  FileOutputStream
    
    字符流：
    
    	FileReader FileWrite
    
    将字节流转换成字符流：
    
    	InputStreamReader  InputStreamWriter
    
    字符包装流：
    
    	BufferedReader  BufferedWriter
    
    一般读文件用的方法：
    
    第一种：
    	
        BufferedReader buff = new BufferedReader(new FileReader("test.txt"));
    
    	String s = "";	
    	while((s = buff.readLine()) !=null)
    	{			
    		System.out.println(s);		
    	}
    
    
    第二种：
    
    	try{
            BufferedReader buff = new BufferedReader(new InputStreamReader(
            new FileInputStream("test.txt")));
            String s = "";
            while((s = buff.readLine()) !=null){
               System.out.println(s);
            }
        }catch(Exception e){
           e.printStackTrace();
        }

# 十.读取Classpath下的文件 #

classpath中可以包含任意类型的文件。  
从classpath读取文件可以避免不同环境下文件路径不一致的问题。  
读取classpath资源：

try(InputStream input = getClass().getResourceAsStream("/default.properties")) {
        if (input != null) {
            // Read from classpath
        }
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xkdXpoZW5saW4_size_16_color_FFFFFF_t_70]: /images/20220227/71a23689afd44065b8547a9d40d2ffd2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xkdXpoZW5saW4_size_16_color_FFFFFF_t_70 1]: /images/20220227/c085f64d6c8a4e3a8a3bf97bc1c8b85b.png