Java核心类库篇6——IO

骑猪看日落 2023-10-03 15:59 14阅读 0赞

## Java核心类库篇6——IO ##

### 1、File ###

#### 1.1、构造方法 ####

<table> 
 <thead> 
  <tr> 
   <th>方法声明</th> 
   <th>功能介绍</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>public File(File parent, String child)</td> 
   <td>从父抽象路径名和子路径名字符串创建新的 <code>File</code>实例</td> 
  </tr> 
  <tr> 
   <td>public File(String pathname)</td> 
   <td>通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例</td> 
  </tr> 
  <tr> 
   <td>public File(String parent, String child)</td> 
   <td>从父路径名字符串和子路径名字符串创建新的File实例</td> 
  </tr> 
  <tr> 
   <td>public File(URI uri)</td> 
   <td>通过将给定的file:URI转换为抽象路径名来创建新的File实例</td> 
  </tr> 
 </tbody> 
</table>

#### 1.2、方法 ####

<table> 
 <thead> 
  <tr> 
   <th>方法声明</th> 
   <th>功能介绍</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>public boolean exists()</td> 
   <td>测试此抽象路径名表示的文件或目录是否存在</td> 
  </tr> 
  <tr> 
   <td>public boolean exists()</td> 
   <td>测试此抽象路径名表示的文件或目录是否存在</td> 
  </tr> 
  <tr> 
   <td>public long length()</td> 
   <td>返回由此抽象路径名表示的文件的长度</td> 
  </tr> 
  <tr> 
   <td>public long lastModified()</td> 
   <td>用于获取文件的最后一次修改时间</td> 
  </tr> 
  <tr> 
   <td>public String getAbsolutePath()</td> 
   <td>用于获取绝对路径信息</td> 
  </tr> 
  <tr> 
   <td>public boolean delete()</td> 
   <td>用于删除文件，当删除目录时要求是空目录</td> 
  </tr> 
  <tr> 
   <td>public boolean createNewFile()</td> 
   <td>用于创建新的空文件</td> 
  </tr> 
  <tr> 
   <td>public boolean mkdir()</td> 
   <td>用于创建目录</td> 
  </tr> 
  <tr> 
   <td>public boolean mkdirs()</td> 
   <td>用于创建多级目录</td> 
  </tr> 
  <tr> 
   <td>public File[] listFiles()</td> 
   <td>获取该目录下的所有内容</td> 
  </tr> 
  <tr> 
   <td>public boolean isFile()</td> 
   <td>判断是否为文件</td> 
  </tr> 
  <tr> 
   <td>public boolean isDirectory()</td> 
   <td>判断是否为目录</td> 
  </tr> 
  <tr> 
   <td>public File[] listFiles(FileFilter filter)</td> 
   <td>获取目录下满足筛选器的所有内容</td> 
  </tr> 
 </tbody> 
</table>

### 2、IO ###

IO就是Input和Output的简写，也就是输入和输出的含义

#### 2.1、IO分类 ####

*  按读写数据的基本单位
    
     *  字节流：以字节为单位进行数据读写的流，可以读写任意类型的文件
     *  字符流：以字符(2个字节)为单位进行数据读写的流，只能读写文本文件
 *  按读写数据的方向不同
    
     *  输入流：从文件中读取数据内容输入到程序中，也就是读文件
     *  输出流：将程序中的数据内容输出到文件中，也就是写文件
 *  按流的角色
    
     *  节点流：直接和输入输出源对接的流
     *  处理流：需要建立在节点流的基础之上的流

#### 2.2、IO流的体系结构 ####

红色为抽象类

蓝色为节点流，必须直接与指定的物理节点关联

<table> 
 <thead> 
  <tr> 
   <th>分类</th> 
   <th>字节输入流</th> 
   <th>字节输出流</th> 
   <th>字符输入流</th> 
   <th>字符输出流</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>抽象基类</td> 
   <td><font>InputStream</font></td> 
   <td><font>OutputStream</font></td> 
   <td><font>Reader</font></td> 
   <td><font>Writer</font></td> 
  </tr> 
  <tr> 
   <td>访问文件</td> 
   <td><font>FileInputStream</font></td> 
   <td><font>FileOutputStream</font></td> 
   <td><font>FileReader</font></td> 
   <td><font>FileWriter</font></td> 
  </tr> 
  <tr> 
   <td>访问数组</td> 
   <td><font>ByteArrayInputStream</font></td> 
   <td><font>ByteArrayOutputStream</font></td> 
   <td><font>CharArrayReader</font></td> 
   <td><font>CharArrayWriter</font></td> 
  </tr> 
  <tr> 
   <td>访问管道</td> 
   <td><font>PipedInputStream</font></td> 
   <td><font>PipedOutputStream</font></td> 
   <td><font>PipedReader</font></td> 
   <td><font>PipedWriter</font></td> 
  </tr> 
  <tr> 
   <td>访问字符串</td> 
   <td>——</td> 
   <td>——</td> 
   <td>StringReader</td> 
   <td>StringWriter</td> 
  </tr> 
  <tr> 
   <td>缓冲流</td> 
   <td>BufferedInputStream</td> 
   <td>BufferedOutputStream</td> 
   <td>BufferedReader</td> 
   <td>BufferedWriter</td> 
  </tr> 
  <tr> 
   <td>转换流</td> 
   <td>——</td> 
   <td>——</td> 
   <td>InputStreamReader</td> 
   <td>OutputStreamWriter</td> 
  </tr> 
  <tr> 
   <td>对象流</td> 
   <td>ObjectInputStream</td> 
   <td>ObjectOutputStream</td> 
   <td>——</td> 
   <td>——</td> 
  </tr> 
  <tr> 
   <td>打印流</td> 
   <td>——</td> 
   <td>PrintStream</td> 
   <td>——</td> 
   <td>PrintWriter</td> 
  </tr> 
  <tr> 
   <td></td> 
   <td><font>FilterInputStream</font></td> 
   <td><font>FilterOutputStream</font></td> 
   <td><font>FilterReader</font></td> 
   <td><font>FilterWriter</font></td> 
  </tr> 
  <tr> 
   <td>推回输入流</td> 
   <td>PushbackInputStream</td> 
   <td>——</td> 
   <td>PushbackReader</td> 
   <td>——</td> 
  </tr> 
  <tr> 
   <td>特殊流</td> 
   <td>DataInputStream</td> 
   <td>DataOutputStream</td> 
   <td>——</td> 
   <td>——</td> 
  </tr> 
 </tbody> 
</table>

#### 2.3、FileInputStream ####

**逐个字节读**

public class Test {
        
        public static void main(String[] args) throws IOException {
        
            String path="D:\\a.txt";
            File file = new File(path);
            FileInputStream fileInputStream = new FileInputStream(file);
            int l = 0;
            while ((l=fileInputStream.read())!=-1){
        
                System.out.println((char)l);
            }
            fileInputStream.close();
        }
    }

**建立缓冲区读**

public class Test {
        
        public static void main(String[] args) throws IOException {
        
            String path="D:\\a.txt";
            File file = new File(path);
            FileInputStream fileInputStream = new FileInputStream(file);
            byte[] b=new byte[1024];
            int l = 0;
            while ((l=fileInputStream.read(b))!=-1){
        
                System.out.println(new String(b,0,l));
            }
            fileInputStream.close();
        }
    }

#### 2.4、FileOutputStream ####

**写入文件**

public class Test {
        
        public static void main(String[] args) throws IOException {
        
            String path="D:\\a.txt";
            File file = new File(path);
            FileOutputStream fileOutputStream = new FileOutputStream(file);
            String str="hello world, i am ruoye!";
            byte[] bytes = str.getBytes();
            fileOutputStream.write(bytes);
            fileOutputStream.close();
        }
    }

**追加内容**

public class Test {
        
        public static void main(String[] args) throws IOException {
        
            String path="D:\\a.txt";
            File file = new File(path);
            FileOutputStream fileOutputStream = new FileOutputStream(file,true);
            String str="hello world, i am ruoye!";
            byte[] bytes = str.getBytes();
            fileOutputStream.write(bytes);
            fileOutputStream.close();
        }
    }

#### 2.5、FileReader ####

**逐个字符读**

public class Test {
        
        public static void main(String[] args) throws IOException {
        
            String path="D:\\a.txt";
            File file = new File(path);
            FileReader fileReader = new FileReader(file);
            int l = 0;
            while ((l=fileReader.read())!=-1){
        
                System.out.println((char)l);
            }
            fileReader.close();
        }
    }

**建立缓冲区读**

public class Test {
        
        public static void main(String[] args) throws IOException {
        
            String path="D:\\a.txt";
            File file = new File(path);
            FileReader fileReader = new FileReader(file);
            char[] b=new char[1024];
            int l = 0;
            while ((l=fileReader.read(b))!=-1){
        
                System.out.println(new String(b,0,l));
            }
            fileReader.close();
        }
    }

#### 2.6、FileWriter ####

**写入文件**

public class Test {
        
        public static void main(String[] args) throws IOException {
        
            String path="D:\\a.txt";
            File file = new File(path);
            FileWriter fileWriter = new FileWriter(file);
            String str="你好，世界！";
            fileWriter.write(str);
            fileWriter.close();
        }
    }

**追加内容**

public class Test {
        
        public static void main(String[] args) throws IOException {
        
            String path="D:\\a.txt";
            File file = new File(path);
            FileWriter fileWriter = new FileWriter(file,true);
            String str="你好，世界！";
            fileWriter.append(str);
            fileWriter.close();
        }
    }

#### 2.7、转换流 ####

public class Test {
        
        public static void main(String[] args) throws IOException {
        
            InputStreamReader inputStreamReader = new InputStreamReader(new FileInputStream(new File("D:\\a.txt")));
            int l = 0;
            while ((l=inputStreamReader.read())!=-1){
        
                System.out.println((char)l);
            }
            inputStreamReader.close();
        }
    }

public class Test {
        
        public static void main(String[] args) throws IOException {
        
            OutputStreamWriter outputStreamWriter = new OutputStreamWriter(new FileOutputStream(new File("D:\\a.txt")));
            String str="hello wordld";
            outputStreamWriter.write(str);
            outputStreamWriter.close();
        }
    }

#### 2.8、缓冲流 ####

public class Test {
        
        public static void main(String[] args) throws IOException {
        
            String path="D:\\a.txt";
            File file = new File(path);
            FileInputStream fileInputStream = new FileInputStream(file);
            BufferedInputStream bufferedInputStream = new BufferedInputStream(fileInputStream);
            byte[] bytes=new byte[1024];
            int l = 0;
            while ((l=fileInputStream.read(bytes))!=-1){
        
                System.out.println(new String(bytes,0,l));
            }
            fileInputStream.close();
        }
    }

public class Test {
        
        public static void main(String[] args) throws IOException {
        
            String path="D:\\a.txt";
            File file = new File(path);
            FileOutputStream fileOutputStream = new FileOutputStream(file);
            BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(fileOutputStream);
            String str="hello world, i am ruoye!";
            byte[] bytes = str.getBytes();
            bufferedOutputStream.write(bytes);
            bufferedOutputStream.close();
            fileOutputStream.close();
        }
    }

**writer和reader同上**

#### 2.9、Data流 ####

##### 2.9.1、DataInputStream #####

*  read(byte b\[\])—从数据输入流读取数据存储到字节数组b中
 *  read(byte b\[\],int off,in len)—从数据输入流中读取数据存储到数组b里面,位置从off开始,长度为len个字节
 *  readFully(byte b\[\])—从数据输入流中循环读取b.length个字节到数组b中
 *  readFully(byte b\[\],int off,in len )—从数据输入流中循环读取len个字节到字节数组b中.从b的off位置开始
 *  skipBytes(int b)—跳过n个字节
 *  readBoolean()—从数据输入流读取布尔类型的值
 *  readByte()—从数据输入流中读取一个字节
 *  readUnsignedByte()—从数据输入流中读取一个无符号的字节,返回值转换成int类型
 *  readShort()—从数据输入流读取一个short类型数据
 *  readUnsignedShort()—从数据输入流读取一个无符号的short类型数据
 *  readChar()—从数据输入流中读取一个字符数据
 *  readInt()—从数据输入流中读取一个int类型数据
 *  readLong()—从数据输入流中读取一个long类型的数据
 *  readFloat()—从数据输入流中读取一个float类型的数据
 *  readDouble()—从数据输入流中读取一个double类型的数据
 *  readUTF()—从数据输入流中读取用UTF-8格式编码的UniCode字符格式的字符串

public class Test {
        
        public static void main(String[] args) throws IOException {
        
            DataInputStream dataInputStream = new DataInputStream(new FileInputStream("D:\\a.txt"));
            System.out.println(dataInputStream.readUTF());
            System.out.println(dataInputStream.readInt());
            System.out.println(dataInputStream.readBoolean());
            System.out.println(dataInputStream.readShort());
            System.out.println(dataInputStream.readLong());
            System.out.println(dataInputStream.readDouble());
            dataInputStream.close();
        }
    }

##### 2.9.2、DataOutputStream #####

*  intCount(int value)—数据输出流增加的字节数
 *  write(int b)—将int类型的b写到数据输出流中
 *  write(byte b\[\],int off, int len)—将字节数组b中off位置开始,len个长度写到数据输出流中
 *  flush()—刷新数据输出流
 *  writeBoolean()—将布尔类型的数据写到数据输出流中,底层是转化成一个字节写到基础输出流中
 *  writeByte(int v)—将一个字节写到数据输出流中(实际是基础输出流)
 *  writeShort(int v)—将一个short类型的数据写到数据输出流中,底层将v转换2个字节写到基础输出流中
 *  writeChar(int v)—将一个charl类型的数据写到数据输出流中,底层是将v转换成2个字节写到基础输出流中
 *  writeInt(int v)—将一个int类型的数据写到数据输出流中,底层将4个字节写到基础输出流中
 *  writeLong(long v)—将一个long类型的数据写到数据输出流中,底层将8个字节写到基础输出流中
 *  writeFloat(flloat v)—将一个float类型的数据写到数据输出流中,底层会将float转换成int类型,写到基础输出流中
 *  writeDouble(double v)—将一个double类型的数据写到数据输出流中,底层会将double转换成long类型,写到基础输出流中
 *  writeBytes(String s)—将字符串按照字节顺序写到基础输出流中
 *  writeChars(String s)—将字符串按照字符顺序写到基础输出流中
 *  writeUTF(String str)—以机器无关的方式使用utf-8编码方式将字符串写到基础输出流中
 *  size()—写到数据输出流中的字节数

public class Test {
        
        public static void main(String[] args) throws IOException {
        
            DataOutputStream dataOutputStream = new DataOutputStream(new FileOutputStream("D:\\a.txt"));
            dataOutputStream.writeUTF("α");
            dataOutputStream.writeInt(1234567);
            dataOutputStream.writeBoolean(true);
            dataOutputStream.writeShort((short)123);
            dataOutputStream.writeLong((long)456);
            dataOutputStream.writeDouble(99.98);
            dataOutputStream.close();
        }
    }

#### 2.10、Zip流 ####

**压缩文件**

public class Test {
        
        public static void main(String[] args) throws IOException {
        
            File file = new File("D:\\a.txt");
            FileInputStream fileInputStream = new FileInputStream(file);
            File zip = new File("D:\\a.zip");
            FileOutputStream fileOutputStream = new FileOutputStream(zip);
            ZipOutputStream zipOutputStream = new ZipOutputStream(fileOutputStream);
            int l = 0;
            zipOutputStream.putNextEntry(new ZipEntry(file.getName()));
    
            while ((l=fileInputStream.read())!=-1){
        
                //压缩算法
                zipOutputStream.write(l);
            }
            fileInputStream.close();
            zipOutputStream.close();
            fileOutputStream.close();
        }
    }

**解压文件**

public class Test {
        
        public static void main(String[] args) throws IOException {
        
            File file = new File("D:\\a.txt");
            File zip = new File("D:\\a.zip");
            ZipFile zipFile= new ZipFile(zip);
            ZipEntry entry = zipFile.getEntry("a.txt");
            InputStream input = zipFile.getInputStream(entry);
            FileOutputStream fileOutputStream = new FileOutputStream(file);
            int l;
            while ((l=input.read())!=-1){
        
            	//解压算法
                fileOutputStream.write(l);
            }
            fileOutputStream.close();
            input.close();
        }
    }

**压缩多个文件**

待补

**解压多个文件**

待补

#### 2.11、Object流 ####

想要使用ObjectOutputStream和ObjectInputStream，对象一定要序列化

import java.io.Serializable;
    
    public class Person implements Serializable {
        
        private String name;
        private int age;
    
        public Person() {
        
        }
    
        public Person(String name, int age) {
        
            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 +
                    '}';
        }
    }

当我们使用Serializable接口实现序列化操作的时候，如果一个对象的某一个属性不想被序列化保存下来，那么我们可以使用transient关键字进行说明

private transient String name;

##### 2.11.1、ObjectOutputStream #####

public class Test {
        
        public static void main(String[] args) throws IOException {
        
            File file = new File("D:\\a.txt");
            ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream(file));
            objectOutputStream.writeObject(new Person("zhangsan",20));
            objectOutputStream.close();
        }
    }

##### 2.11.2、ObjectInputStream #####

public class Test {
        
        public static void main(String[] args) throws IOException, ClassNotFoundException {
        
            File file = new File("D:\\a.txt");
            ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream(file));
            Person person = (Person) objectInputStream.readObject();
            System.out.println(person);
        }
    }

#### 2.12、RandomAccessFile ####

<table> 
 <thead> 
  <tr> 
   <th>方法声明</th> 
   <th>功能介绍</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>public RandomAccessFile(String name, String mode)</td> 
   <td>根据参数指定的名称和模式构造对象 r: 以只读方式打开 rw：打开以便读取和写入 rwd:打开以便读取和写入，同步文件内容的更新 rws:打开以便读取和写入，同步文件内容和元数据 的更新</td> 
  </tr> 
  <tr> 
   <td>int read()</td> 
   <td>读取单个字节的数据</td> 
  </tr> 
  <tr> 
   <td>void seek(long pos)</td> 
   <td>用于设置从此文件的开头开始测量的文件指针偏移量</td> 
  </tr> 
  <tr> 
   <td>void write(int b)</td> 
   <td>将参数指定的单个字节写入</td> 
  </tr> 
  <tr> 
   <td>void close()</td> 
   <td>用于关闭流并释放有关的资源</td> 
  </tr> 
 </tbody> 
</table>

public class Test {
        
        public static void main(String[] args) throws IOException {
        
            RandomAccessFile r = new RandomAccessFile("D:\\a.txt", "rw");
            r.seek(1);
            System.out.println((char) r.read());
            r.write('b');
            r.close();
        }
    }