第三章输入和输出处理

文章目录

[第三章输入和输出处理](#第三章输入和输出处理)

第三章输入和输出处理

1.文件

相关记录或放在一起的数据的集合

访问文件属性：

JAVA API ：java.io.File 类File file = new File( String pathname );

File类 --> 创建文件对象（物理文件或目录）-->通过文件对象的方法，操作文件或目录的属性（路径、权限、日期和时间等）

File类的常用方法

方法名称	说明
boolean exists( )	判断文件或目录是否存在
boolean isFile( )	判断是否是文件
boolean isDirectory( )	判断是否是目录
String getPath( )	返回此对象表示的文件的相对路径名
String getAbsolutePath( )	返回此对象表示的文件的绝对路径名
String getName( )	返回此对象表示的文件或目录的名称
boolean delete( )	删除此对象指定的文件或目录
boolean createNewFile( )	创建名称的空文件，不创建文件夹
long length()	返回文件的长度，单位为字节 , 如果文件不存在，则返回 0L

java 复制代码

 public static void main(String[] args) throws IOException {
        File file = new File("C:\\Users\\Administrator\\Desktop\\html开场.txt");
        boolean bool = file.exists();
        System.out.println("文件或目录是否存在:"+bool);
        System.out.println("是否是文件:"+file.isFile());
        System.out.println("是否是目录:"+file.isDirectory());
        String rPath = file.getPath();
        System.out.println("文件的相对路径："+rPath);
        String aPath = file.getAbsolutePath();
        System.out.println("文件的绝对路径："+aPath);
        String fName = file.getName();
        System.out.println("文件或目录的名称:"+fName);
        System.out.println("文件的长度:"+file.length());

        File file1 = new File("C:\\Users\\Administrator\\Desktop\\html.txt");
        bool = file1.createNewFile();
        System.out.println("创建名称的空文件:"+bool);
        bool = file1.delete();
        System.out.println("删除此对象指定的文件或目录:"+bool);
        System.out.println("文件或目录是否存在:"+file1.exists());
        System.out.println("文件的长度:"+file1.length());
    }

运行结果：

java 复制代码

文件或目录是否存在:true
是否是文件:true
是否是目录:false
文件的相对路径：C:\Users\Administrator\Desktop\html开场.txt
文件的绝对路径：C:\Users\Administrator\Desktop\html开场.txt
文件或目录的名称:html开场.txt
文件的长度:1529
创建名称的空文件:true
删除此对象指定的文件或目录:true
文件或目录是否存在:false
文件的长度:0

2.流

流是一组有序的 数据序列，以先进先出方式发送信息的通道，通过流来读写文件

Java流的分类

输入输出流是相对于计算机内存来说的

字节流是 8 位通用字节流，字符流是 16 位 Unicode 字符流

1.FileInputStream

InputStream类常用方法
- int read( )：从当前数据流中读取一个字节。若已达到流结尾，则返回-1
- int read(byte[] b)：从当前输入流读取一定的byte数据，并存取在数组中，然后返回读取的byte数据的数量，若已到达流结尾，则返回-1
- int read(byte[] b,int off,int len)：从输人流中的当前位置连续读人len个字节，从数组b的第off+1个元素位置处开始存放,同时返回所读到的字节数
- void close( )：关闭输入流与外设的连接并释放所占用的系统资源
- int available()：可以从输入流中读取的字节数目
子类FileInputStream常用的构造方法
- FileInputStream(File file)
- FileInputStream(String name)

使用FileInputStream 读文本文件

java 复制代码

import java.io.FileInputStream;
import java.io.IOException;

public class FileIS {
    public static void main(String[] args) throws IOException {
        //构造文件输入流FileInputStream对象
        FileInputStream fis = new FileInputStream("C:\\Users\\Administrator\\Desktop\\html开场.txt");
        //读取文本文件的数据
        System.out.println( fis.available());  //可以从输入流中读取的字节数目：1529
        System.out.println(fis.read());        //229
        //关闭文件流对象
        fis.close();
    }
}

在实例化字节数组时，一次性实例化足够大的数组

fis.available() 避免乱码

2.FileOutputStream

OutputStream类常用方法
- void write(int c)：将参数c的低位字节写入到输出流
- void write(byte[] buf)：将字节数组buf中的全部字节按顺序写入到输出流
- void write(byte[] b,int off,int len)：将字节数组b中第off+1个元素开始的len个数据，顺序地写人到输出流
- void flush()：强制写入所有缓冲的字节数据，强制清空缓冲区并执行向外设写操作
- void close()：关闭输出流与外设的连接并释放所占用的系统资源
子类FileOutputStream常用的构造方法
- FileOutputStream (File file)
- FileOutputStream(String name)
- FileOutputStream(String name,boolean append)
注意：

1.前两种构造方法在向文件写数据时将覆盖文件中原有的内容

2.创建FileOutputStream实例时，如果相应的文件并不存在，则会自动创建一个空的文件

使用FileOutputStream 写文本文件

java 复制代码

import java.io.FileOutputStream;
import java.io.IOException;

public class FileOS {
    public static void main(String[] args) throws IOException {
        //构造文件输出流FileOutputStream对象
        FileOutputStream fos = new FileOutputStream("html开场.txt");
        //把数据写入文本文件
        String str = "好好学习Java";
        byte[] words = str.getBytes();
        fos.write(words,0,words.length);
        //关闭文件流对象
        fos.close();
    }
}

复制文本文件

java 复制代码

/*文件"我的青春谁做主.txt"位于D盘根目录下，
 *要求将此文件的内容复制到 C:\myFile\my Prime.txt中
 */
public static void main(String[] args) throws IOException {
    //创建输入输出流
    FileInputStream fis = new FileInputStream("D:\\我的青春谁做主.txt");
    FileOutputStream fos = new FileOutputStream("C:\\myFile\\my Prime.txt");
    //创建字节
    byte[] word = new byte[1024];
    while (fis.read(word)>0){
        fos.write(word,0, word.length);
    }
    fis.close();
    fos.close();
}

3.Reader类

Reader类常用方法
- int read( )：从输入流中读一个字符
- int read(char[] c)：从输入流中读最多c.length个字符，存入字符数组c中
- read(char[] c,int off,int len):从输入流中读最多len个字符，存入字符数组c中从off开始的位置
- void close( ):关闭输入流
子类InputStreamReader常用的构造方法
- InputStreamReader(InputStream in)
- InputStreamReader(InputStream in,String charsetName)

1.FileReader类

FileReader类是InputStreamReader的子类
- FileReader(File file)
- FileReader(String name)
该类只能按照本地平台的字符编码来读取数据，用户不能指定其他的字符编码类型
- System.out.println(System.getProperty("file.encoding"));

使用FileReader读取文件

java 复制代码

import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;

public class FileRead {
    public static void main(String[] args) throws IOException {
        //创建FileReader对象
        Reader fr = new FileReader("D:\\Cly\\javagj\\html开场.txt");
        //读取文本文件的数据
        fr.read();
        //关闭相关的流对象
        fr.close();
    }
}

2.BufferedReader类

使用FileReader类与BufferedReader类提高字符流读取文本文件的效率

BufferedReader类是Reader类的子类

BufferedReader类带有缓冲区

按行读取内容的readLine()方法

BufferedReader常用的构造方法
- BufferedReader(Reader in)：创建缓冲区字符输入流
子类BufferedReader特有的方法
- readLine()

使用 BufferedReader读文本文件

java 复制代码

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;

public class BufferedRead {
    public static void main(String[] args) throws IOException {
        //构造BufferedRead对象和FileReader对象
        Reader fr = new FileReader("D:\\Cly\\javagj\\html开场.txt");
        BufferedReader br = new BufferedReader(fr);
        //调用方法获取数据
        System.out.println(br.readLine());
        //关闭文件流
        br.close();
        fr.close();
    }
}

读取时中文乱码

java 复制代码

FileInputStream fis=new FileInputStream("c:\\myDoc\\hello.txt");
//使用InputStreamReader并设置编码格式
InputStreamReader fr=new InputStreamReader(fis,"UTF-8");

4.Writer类

Writer类常用方法
- write(String str):将字符串str输出到流中
- write(String str,int off,int len)：将字符串按指定格式输出
- void close()
- void flush()
子类OutputStreamWriter常用的构造方法
- OutputStreamWriter(OutputStream out)
- OutputStreamWriter(OutputStream out,String charsetName)

1.FileWriter类

该类只能按照本地平台的字符编码来写数据，用户不能指定其他的字符编码类型

FileWriter类是OutputStreamWriter的子类
- FileWriter (File file)
- FileWriter (String name)：根据所给文件名创建一个可供写人字符数据的输出流对象，原先的文件会被覆盖

使用FileWriter写文件

java 复制代码

import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;

public class FileWri {
    public static void main(String[] args) throws IOException {
        //创建FileReader对象
        Writer fw = new FileWriter("D:\\Cly\\javagj\\html开场.txt");
        //写文本文件
        fw.write("好好学习，天天向上");
        //关闭相关的流对象
        fw.close();
    }
}

2.BufferedWriter类

使用FileWriter类与BufferedWriter类，提高字符流写文本文件的效率

BufferedWriter类是Writer类的子类

BufferedWriter类带有缓冲区

BufferedWriter常用的构造方法
- BufferedWriter(Writer out)

使用 BufferedWriter写文件

java 复制代码

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;

public class BufferedWri {
    public static void main(String[] args) throws IOException {
        //构造FileWriter对象和BufferedWriter对象
        FileWriter fw = new FileWriter("D:\\Cly\\javagj\\html开场.txt");
        BufferedWriter bw = new BufferedWriter(fw);
        //调用方法写数据
        bw.write("hello");
        //清空和关闭
        bw.flush();
        bw.close();
    }
}

5.读写二进制文件

DataInputStream类
- FileInputStream的子类
- 与FileInputStream类结合使用读取二进制文件
DataOutputStream类
- FileOutputStream的子类
- 与FileOutputStream类结合使用写二进制文件

使用 DataInputStream 读二进制文件

java 复制代码

import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.IOException;

public class DataIS {
    public static void main(String[] args) throws IOException {
        //构造数据输入流对象
        FileInputStream fis = new FileInputStream("D:\\Cly\\javagj\\pet.txt");
        DataInputStream dis = new DataInputStream(fis);
        //调用read()方法
        dis.read();
        //关闭数据输入流
        dis.close();
    }
}

使用 DataOutputStream写二进制文件

java 复制代码

import java.io.DataOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class DataOS {
    public static void main(String[] args) throws IOException {
        //构造数据输出流对象
        FileOutputStream fos = new FileOutputStream("D:\\Cly\\javagj\\pet.txt");
        DataOutputStream dos = new DataOutputStream(fos);
        //调用write()方法写二进制文件数据
        dos.write(1);
        //关闭数据输出流
        dos.close();
    }
}

6.序列化和反序列化

序列化和反序列化的过程：

内存：序列化->流

二进制的字节序列：反序列化->java对象

序列化是将对象的状态写入到特定的流中的过程

反序列化则是从特定的流中获取数据重新构建对象的过程

实现序列化：

1.实现Serializable接口

2.创建对象输出流

3.调用writeObject()方法将对象写入文件

4.关闭对象输出流

注意：使用集合保存对象，可以将集合中的所有对象序列化

java 复制代码

//序列化
List<Student> list = new ArrayList<>();
list.add(new Student("张三",18));
list.add(new Student("李四",20));
try {
    创建对象输出流
    ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("student"));
    //调用writeObject()方法将对象写入文件
    oos.writeObject(list);
    oos.flush();

    //关闭对象输出流
    oos.close();
} catch (IOException e) {
    e.printStackTrace();
}

实现反序列化：

1.实现Serializable接口

2.创建对象输入流

3.调用readObject()方法将对象写入文件

4.关闭对象输入流

注意：如果向文件中使用序列化机制写入多个对象，那么反序列化恢复对象时，必须按照写入的顺序读取

java 复制代码

//反序列化
try {
    //创建对象输入流
    ObjectInputStream ois = new ObjectInputStream(new FileInputStream("student"));
    //调用readObject()方法将对象写入文件
    list = (List<Student>) ois.readObject();
    for (Student stu : list) {
        System.out.println(stu);
    }
    //关闭对象输入流
    ois.close();
} catch (IOException e) {
    e.printStackTrace();
} catch (ClassNotFoundException e) {
    e.printStackTrace();
}

结果：

Student{name='张三', age=18}

Student{name='李四', age=20}

第三章 输入和输出处理

文章目录