第三章 输入和输出处理

第三章 输入和输出处理

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

  public static void main(String[] args)   {
        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");
        try {
            bool = file1.createNewFile();
        } catch (IOException e) {
            e.printStackTrace();
        }
        System.out.println("创建名称的空文件:"+bool);
        bool = file1.delete();
        System.out.println("删除此对象指定的文件或目录:"+bool);
        System.out.println("文件或目录是否存在:"+file1.exists());
        System.out.println("文件的长度:"+file1.length());
    	//file1.mkdirs();创建多级
    }

运行结果：

文件或目录是否存在: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 字符流
GBK：两个字节；UTF-8：三个字节

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 读文本文件

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

public class FileIS {
   public static void main(String[] args)   {
        FileInputStream fis = null;
        try {
            fis = new FileInputStream("C:\\Users\\Administrator\\Desktop\\html开场.txt");
            //定义字节数组，用于接收数据
            byte b[] = new byte[fis.available()];
            //available():获取文件字节数
            System.out.println(fis.available());
            //读取内容放入数组
            System.out.println(fis.read(b));
            //将字节数组转换为字符串
            String str = new String(b,"放入编码格式");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                //关闭流，释放资源
                fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

在实例化字节数组时，一次性实例化足够大的数组 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 写文本文件

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

public class FileOS {
     public static void main(String[] args)   {
        //构造文件输出流FileOutputStream对象
        FileOutputStream fos = null;
        try {
            fos = new FileOutputStream("html开场.txt");
            //把数据写入文本文件
            String str = "好好学习Java";
            //getBytes():转换为字节数组
            byte[] words = str.getBytes();
            fos.write(words,0,words.length);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //关闭文件流对象
            try {
                fos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

复制文本文件

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

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读取文件

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

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

2.BufferedReader类

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

BufferedReader类是Reader类的子类

BufferedReader类带有缓冲区

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

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

使用 BufferedReader读文本文件

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

读取时中文乱码

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写文件

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

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

2.BufferedWriter类

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

BufferedWriter类是Writer类的子类

BufferedWriter类带有缓冲区

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

使用 BufferedWriter写文件

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

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

5.读写二进制文件

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

使用 DataInputStream 读二进制文件

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

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

使用 DataOutputStream写二进制文件

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

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

6.序列化和反序列化

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

内存：序列化->流

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

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

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

实现序列化：

1.实现Serializable接口

2.创建对象输出流

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

4.关闭对象输出流

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

//序列化
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.关闭对象输入流

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

//反序列化
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}