JAVAOOP-17 字符流

一. 回顾

​

字节流和字符流的区别：

​ 字节流： 以字节为单位传输 不能处理中文问题 中文会出现乱码

​ 字符流： 以字符为单位传输 一个字符两个字节 可以处理中文问题

二. FileReader和FileWriter

Reader: 抽象类

​

Writer: 抽象类

FileReader:

​

​

​

FileWriter:

代码：

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


public class TestRAW {

	public static void main(String[] args) throws IOException {
		doWrite();
		doRead();

	}
	//写入字符到文件里面
	public static void doWrite() throws IOException{
		Writer w=new FileWriter("D:/bb.txt");
		w.write("a");
		w.write("中");
		w.write("b");
		w.write("国");
		w.close();
	}
	//从文件里面循环读取数据
	public static void doRead() throws IOException{
		Reader r=new FileReader("D:/bb.txt");
		int data=-1;
		while((data=r.read())!=-1){
			System.out.println((char)data);
		}
		r.close();
	}

}

二. ObjectOutputStream

ObjectOutputStream可以写入一个对象，对象在写入的过程中是以流的形式传输的，必须要序列化

序列化概念：

Java序列化就是指把Java对象转换为字节序列的过程

Java反序列化就是指把字节序列恢复为Java对象的过程。

作用：

​ 序列化最重要的作用：在传递和保存对象时.保证对象的完整性和可传递性。对象转换为有序字节流,以便在网络上传输或者保存在本地文件中。

​ 反序列化的最重要的作用：根据字节流中保存的对象状态及描述信息，通过反序列化重建对象

如何序列化： 实现一个序列化接口 implements Serializable

ObjectOutputStream类详解:

​

​

ObjectInputStream类详解：

实现将Student对象写到文件里面

import java.io.*;

public class TestObject {
    public static void main(String[] args) {
        try {
            //doWrite();
            doRead();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    //往文件里面写入Student对象
    public static void doWrite() throws IOException {
        ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("C:\\Users\\17909\\Desktop\\20201130班级\\1202\\3.txt"));
        Student s1=new Student("zhangsan",23);
        Student s2=new Student("lisi",28);

        oos.writeObject(s1);
        oos.writeObject(s2);

        oos.close();

    }

    //从文件中读取Student对象
    public static void doRead() throws IOException, ClassNotFoundException {
        ObjectInputStream ois=new ObjectInputStream(new FileInputStream("C:\\Users\\17909\\Desktop\\20201130班级\\1202\\3.txt"));

        Student s1=(Student) ois.readObject();
        Student s2=(Student) ois.readObject();
        System.out.println(s1);
        System.out.println(s2);

        ois.close();

    }
}

class Student implements Serializable{
    String name;
    int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

三. BufferedReader和 PrintWriter

文本数据太大，一个一个读写效率太低，BufferedReader可以实现逐行读取，PrintWriter可以实现逐行写入

注意： BufferedWriter里面没有逐行写入的方法

BufferedReader:

​

​

PrintWriter:

​

​ 实现逐行读取和逐行写入的操作：

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;


public class TestRWLine {

	public static void main(String[] args) throws IOException {
		testReadLine();
		testWriteLine();

	}
	public static void testReadLine() throws IOException{
		BufferedReader br=new BufferedReader(new FileReader("D:\\day17\\主要内容.txt"));
		
		String line=null;
		while((line=br.readLine())!=null){
			System.out.println(line);
		}
		br.close();
	}
	
	public static void testWriteLine() throws IOException{
		PrintWriter pw=new PrintWriter(new FileWriter("D:/ccc.txt"));
		//PrintWriter里面有逐行写的方法，他可以包装字节流和字符流
		pw.println("jkfwog");
		pw.println("加快流入共和国");
		pw.println("你好啊！！！！！！！");
		pw.println("很好！！！！！！！！！！！！！！！！！！");
		pw.close();
	}

}

四： Properties

Properties里面放的是键值对类型，extends HashTable，是可以将数据持久化到本地文件的流对象

类 Properties: 位于java.util包下

• Properties 类表示了一个持久的属性集。
• Properties 可保存在流中或从流中加载。
• 属性列表中每个键及其对应值都是一个字符串。

构造方法：

普通方法：

​

实现Properties集合的读取和写入（存储）

在src下面创建name.properties文件

import java.io.*;
import java.util.Properties;

public class TestProperties {
    public static void main(String[] args) {

        try {
            mystore1();
            myLoad();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    //写入数据到本地
    public static void mystore1() throws IOException {
        //创建Properties集合对象
        Properties prop=new Properties();
        prop.setProperty("张三","33");
        prop.setProperty("李四","29");

        //写入本地文件
        Writer w=new FileWriter("src\\name.properties");
        prop.store(w,"helloworld");

        //关闭流
        w.close();

    }
    //从本地文件加载数据
    public static void myLoad() throws IOException {
        //创建Properties集合对象
        Properties prop=new Properties();
        //创建流对象
        Reader reader=new FileReader("src\\name.properties");
        //加载数据
        prop.load(reader);
        System.out.println("properties: "+prop);
        //关闭流
        reader.close();
    }
}

练习demo

import java.io.*;
import java.util.Enumeration;
import java.util.Properties;

public class TestProperties2 {
    public static void main(String[] args) {

        try {
            //testWrite();
            testRead();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
    //从文件中读取
    public static void testRead() throws IOException {
        //创建Properties对象
        Properties prop=new Properties();
        //创建流对象
        BufferedReader br=new BufferedReader(new FileReader("src\\demo.properties"));
        // void load(Reader reader) 按简单的面向行的格式从输入字符流中读取属性列表（键和元素对）。
        prop.load(br);
        prop.list(System.out);//把prop对象中的名称值输出到控制台

        //显示数据 循环遍历Properties对象
        Enumeration keys = prop.keys();
        while(keys.hasMoreElements()){
            String key = (String) keys.nextElement();
            String value = prop.getProperty(key);
            //String value = (String) prop.get(key);
            System.out.println(key+" = "+value);
        }
        //关闭流
        br.close();



    }

    //写入到文件里面
    public static void testWrite() throws IOException {
        //创建Properties对象
        Properties prop=new Properties();
        //放入数据
        prop.put("111","aaa");
        prop.put("222","bbb");

        //创建流对象
        PrintWriter pw=new PrintWriter(new FileWriter("src\\demo.properties"));
        // void list(PrintWriter out) 将属性列表输出到指定的输出流。
        prop.list(pw);
        pw.close();
    }

}

.实现复制一个目录中的所有内容到另一个目录

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

// 2.复制一个目录中的所有内容到另一个目录
public class Zy3 {
	
	public void doCopy(File src,File tar) throws IOException{
		BufferedInputStream in=new BufferedInputStream(new FileInputStream(src));
		BufferedOutputStream out=new BufferedOutputStream(new FileOutputStream(tar));
		int data=-1;
		while((data=in.read())!=-1){
			out.write(data);
		}
		in.close();out.close();
	}
	public void doCopyDir(File src,File tar) throws IOException{
		if(src==null||tar==null){
			throw new RuntimeException("参数不能为null");
		}
		if(tar.isFile()){
			throw new RuntimeException("目标目录不能是文件");
		}
		if(src.isFile()){
			String fileName=src.getName();
			File newFile=new File(tar,fileName);
			doCopy(src, newFile);
		}else if(src.isDirectory()){
			String srcPath=src.getName();
			File newFile=new File(tar,srcPath);
			if(!newFile.exists()){newFile.mkdirs();}
			File[] children=src.listFiles();
			if(children!=null&&children.length>0){
				for (File child : children) {
					doCopyDir(child, newFile);
				}
			}
		}
	}

	public static void main(String[] args) throws IOException {
	
		Zy3 zy=new Zy3();
		File src=new File("D:\\day20");
		File tar=new File("D:");
		
		zy.doCopyDir(src, tar);
		

	}
	
}