Java学习第四十九天＜处理流＞＜对象处理流＞＜标准输入输出流＞＜转换流＞＜打印流＞＜配置文件Properties＞＜IO流章节作业＞

处理流

package chapter21.BufferedStream;
​
import java.io.BufferedReader;
import java.io.FileReader;
​
public class BufferedReader_ {
    public static void main(String[] args) throws Exception {
        String filePath="d:\\java\\code\\Hello.java";
        //创建BufferedReader
        BufferedReader bufferedReader = new BufferedReader(new FileReader(filePath));
        //读取
        String line;//按行读取，效率高 读取完返回null
       while ((line = bufferedReader.readLine())!=null){
           System.out.println(line);
        }
       bufferedReader.close();//只需关闭bufferedReader，底层FileReader会自动关闭
    }
}

package chapter21.BufferedStream;
​
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
​
public class BufferedWriter_ {
    public static void main(String[] args) throws IOException {
        String filePath="f:\\ok.txt";
        //创建BufferedWriter
        BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(filePath));//filePath,true节点流上可追加
        bufferedWriter.write("hello,666");
        bufferedWriter.newLine(); //插入一个和系统相关的换行
        bufferedWriter.write("hello,666");
​
        bufferedWriter.close();//关闭外层即可。底层会自行关闭
    }
}

Buffered拷贝

package chapter21.BufferedStream;
​
import java.io.*;
//按字符读取，不能操作二进制文件（声音、视频、doc、pdf），否则会造成文件损坏
public class BufferedCopy_ {
    public static void main(String[] args) throws IOException {
        String srcFilePath="d:\\java\\code\\Hello.java";
        String destFilePath="d:\\java\\code\\Hello-.java";
        BufferedReader bufferedReader = new BufferedReader(new FileReader(srcFilePath));
        BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(destFilePath));
        //先读取
        String line;
        while ((line=bufferedReader.readLine())!=null){
            //每读取一行遍写入
            bufferedWriter.write(line);
            bufferedWriter.newLine();//插入换行
        }
        System.out.println("已完成");
        if (bufferedReader!=null){
            bufferedReader.close();
        }
        if (bufferedWriter!=null){
            bufferedWriter.close();
        }
    }
}

package chapter21.BufferedStream;
​
import java.io.*;
//按字节拷贝
public class BufferedCopy02 {
    public static void main(String[] args) throws IOException {
        String srcFilePath="d:\\java\\picture\\注释.png";
        String desFilePath="d:\\java\\picture\\注释2.png";
        BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream(srcFilePath));
        BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(new FileOutputStream(desFilePath));
        //循环读取文件，写入desFilePath
        byte[] buff=new byte[1024];
        int readLen=0;
        while ((readLen=bufferedInputStream.read(buff))!=-1){
            bufferedOutputStream.write(buff,0,readLen);
        }
        System.out.println("拷贝成功");
        //关闭流
        if (bufferedInputStream!=null){
            bufferedInputStream.close();
        }
        if (bufferedOutputStream!=null){
            bufferedOutputStream.close();
        }
    }
}

对象处理流

package chapter21.ObjectStream;
​
import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
​
public class ObjectInputStream_ {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        String filePath="f:\\data.dat";//制定文件
        ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream(filePath));
        //读取（反序列化）的顺序要和保存数据（序列化）的顺心一致，否则会异常
        System.out.println(objectInputStream.readInt());
        System.out.println(objectInputStream.readBoolean());
        System.out.println(objectInputStream.readChar());
        System.out.println(objectInputStream.readDouble());
        System.out.println(objectInputStream.readUTF());//要按顺序，缺一不可（报错）
        Object dog = objectInputStream.readObject();//对象里每个属性，成员对象都要实现接口序列化
        System.out.println("运行类型"+dog.getClass());
        System.out.println("dog信息"+dog);//object>dog
        //关闭外层流，底层自动关闭
        objectInputStream.close();
        //如要调用dog类的成员
        Dog dog2=(Dog) dog;//向下转型，不同包要引入
        System.out.println(dog2.getName());
    }
}

package chapter21.ObjectStream;
​
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.io.Serializable;
​
public class ObjectOutStream_ {
    public static void main(String[] args) throws IOException {
        String filePath="f:\\data.dat";//序列化后，格式为dat
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(filePath));
        //序列化数据到
        oos.writeInt(100);//int>Integer(实现了Serializable)
        oos.writeBoolean(true);//boolean>Boolean(实现了Serializable)
        oos.writeChar('a');//char>Character(实现了Serializable)
        oos.writeDouble(9.5);//double>Double(实现了Serializable)
        oos.writeUTF("哈哈");//String (实现了Serializable)
        oos.writeObject(new Dog("哈哈",10));//注意要实现Serializable接口
        oos.close();
        System.out.println("数据已保存（序列化形式）");
​
    }
}
class Dog implements Serializable {
    private String name;
    private int age;
    private static final long serialVersionUID=1L;//序列化版本号提高兼容性
​
    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }
​
    public String getName() {
        return name;
    }
​
    public int getAge() {
        return age;
    }
​
    @Override
    public String toString() {
        return "Dog{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

标准输入输出流

package chapter21.Standard;
​
import java.util.Scanner;
​
public class InputAndOutput_ {
    public static void main(String[] args) {
        //标准输入 键盘
        System.out.println(System.in.getClass());//System.in 编译类型Inputstream 运行类型BufferedInputStream
        //标准输出 显示器
        System.out.println(System.out.getClass());//System.out 编译类型Printstream 运行类型PrintStream
​
        Scanner scanner = new Scanner(System.in);
        String next= scanner.next();
        System.out.println(next);
    }
}

转换流

乱码引出转换流

package chapter21.Transformation;
​
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
//默认情况下读取按照UTF-8读取
public class CodeQuestion {
    public static void main(String[] args) throws IOException {
        String filePath="f:\\a.txt";
        BufferedReader br = new BufferedReader(new FileReader(filePath));
        String s = br.readLine();
        System.out.println("读取到的内容"+s);
        br.close();
    }
}

package chapter21.Transformation;
​
import java.io.*;
//解决编码问题引起的乱码
//字节流FileInputStream>>字符流InputStreamReader，指定编码
public class InputStreamReader_ {
    public static void main(String[] args) throws IOException {
        String filePath="f:\\a.txt";
        //字节流FileInputStream>>字符流InputStreamReader 指定gbk编码
        InputStreamReader isr = new InputStreamReader(new FileInputStream(filePath),"gbk");
        //把InputStreamReader放入包装流BufferedReader
        BufferedReader br = new BufferedReader(isr);
        //读取
        String s = br.readLine();
        System.out.println("读取内容"+s);
        //关闭流
        br.close();
    }
}

package chapter21.Transformation;
​
import java.io.*;
​
public class OutputStreamWriter_ {
    public static void main(String[] args) throws IOException {
        String filePath="f:\\a.txt";
        String charSet="gbk";
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(filePath),charSet );
        osw.write("hi,666");
        osw.close();
        System.out.println("按照"+charSet+"保存文件成功");
    }
}

打印流

package chapter21.Print;
import java.io.IOException;
import java.io.PrintStream;
//PrintStream 字节打印流/输出流
public class PrintStream_ {
    public static void main(String[] args) throws IOException {
        PrintStream out=System.out;//System.out本身就是输出流，赋给PrintStream
        out.print("666");
        out.write("hhh".getBytes());//print底层用的write，所以可直接调用write打印
​
        //修改打印输出的位置/设备
        System.setOut(new PrintStream("f:\\f1.txt"));
        System.out.println("666");//输出到f:\f1.txt
        out.close();
    }
}

package chapter21.Print;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
​
public class PrintWriter_ {
    public static void main(String[] args) throws IOException {
        PrintWriter printWriter=new PrintWriter(System.out);
        printWriter.print("hi,北京");
        PrintWriter printWriter1 = new PrintWriter(new FileWriter("f:\\f2.txt"));
        printWriter1.print("666");
        printWriter.close();
        printWriter1.close();//关闭流才能把数据写入文件
    }
}

配置文件Properties

ip=192.168.100.100
user=root
pwd=123456

package chapter21.Properties;
​
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
​
public class Properties01 {
    public static void main(String[] args) throws IOException {
        //读取文件，并获得相应ip
        BufferedReader bufferedReader = new BufferedReader(new FileReader("d:\\java\\project\\JavaSE\\base\\src\\chapter21\\Properties\\mysql.properties"));
        String line;
        while ((line=bufferedReader.readLine())!=null){//按行读取
            String[] split = line.split("=");//以"=”号拆分，拆成数组
            if ("ip".equals(split[0])){
                System.out.println(split[0]+"值是："+split[1]);//只打印ip
            }
            System.out.println(split[0]+"值是："+split[1]);
        }
        bufferedReader.close();
    }
}

package chapter21.Properties;
​
import java.io.FileReader;
import java.io.IOException;
import java.util.Properties;
​
public class Properties02 {
    public static void main(String[] args) throws IOException {
        //使用Properties类读取mysql.properties文件
        Properties properties = new Properties();//创建Properties对象
        properties.load(new FileReader("d:\\java\\project\\JavaSE\\base\\src\\chapter21\\Properties\\mysql.properties"));//加载指定配置文件
        properties.list(System.out);//K-V显示控制台
        String user = properties.getProperty("user");//指定user输出
        String pwd = properties.getProperty("pwd");
        System.out.println("用户名"+user);
        System.out.println("密码"+pwd);
​
​
    }
}

#666
#Tue Jun 07 11:34:41 CST 2022
user=汤姆
pwd=888
charset=utf8

package chapter21.Properties;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Properties;
​
public class Properties03 {
    public static void main(String[] args) throws IOException {
        //Properties创建修改配置文件
        Properties properties = new Properties();//创建
        properties.setProperty("charset","utf8");
        properties.setProperty("user","汤姆");//中文unicode
        properties.setProperty("pwd","abc111");
        properties.setProperty("pwd","888");//已经有K则是修改 properties父类是Hashtable,底层就是Hashtable 核心方法
        properties.store(new FileOutputStream("d:\\java\\project\\JavaSE\\base\\src\\chapter21\\Properties\\mysql2.properties"),"666");//K-V存到文件中 “666”注释
​
        System.out.println("保存配置文件成功");
​
​
    }
}

IO流章节作业

package chapter21.Homework;
​
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
​
public class Homework01 {
    public static void main(String[] args) throws IOException {
        String Path="f:\\homework01";
        File file = new File(Path);
        if (!file.exists()){
            if (file.mkdirs()){
                System.out.println("创建"+Path+"创建成功");
            }else {
                System.out.println("创建失败");
            }
        }
        String filePath=Path+"\\hello.txt";
        file=new File(filePath);
        if (!file.exists()){
            if (file.createNewFile()){
                System.out.println(filePath+"创建成功");
                BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(file));
                bufferedWriter.write("666");
                bufferedWriter.close();
            }else {
                System.out.println(filePath+"创建失败");
            }
        }else {
            System.out.println(filePath+"已经存在，不再创建。");
        }
    }
}

package chapter21.Homework;
​
import java.io.*;
​
public class Homework02 {
    public static void main(String[] args) throws IOException {
        String filePath="f:\\a.txt";
        BufferedReader bufferedReader = new BufferedReader(new FileReader(filePath));//转换流的对象扔给bufferReader可以读取不同编码，解决乱码
        BufferedReader bufferedReader1 = new BufferedReader(new InputStreamReader(new FileInputStream(filePath),"gbk"));
        String line;
        int lineNum=0;
        while ((line=bufferedReader1.readLine())!=null){//按行读取
            System.out.println(++lineNum+line);
        }
        if (bufferedReader1!=null){
            bufferedReader1.close();
        }
    }
}

name=k
age=5
color=red

package chapter21.Homework;
​
import java.io.*;
import java.util.Properties;
​
public class Homework03 {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        String Path="d:\\java\\project\\JavaSE\\base\\src\\chapter21\\Homework\\dog.properties";
        Properties properties = new Properties();
        properties.load(new FileReader(Path));
        String name = properties.get("name")+"";//object>string
        int age = Integer.parseInt(properties.get("age")+"");//object>int
        String color = properties.get("color") + "";//object>string
        Dog dog = new Dog(name, age,color);
        System.out.println(dog);
        //序列化
        String serPath="f:\\dog.dat";
        ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream(serPath));
        objectOutputStream.writeObject(dog);
        objectOutputStream.close();
        System.out.println("dog对象序列化完成");
       m1();
    }
    //反序列化
    public static void m1() throws IOException, ClassNotFoundException {
        String serPath="f:\\dog.dat";
        ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream(serPath));
        Dog dog = (Dog) objectInputStream.readObject();
        System.out.println(dog);
        System.out.println("反序列完成");
        objectInputStream.close();
    }
}
class Dog implements Serializable {//序列化必须实现接口
    private String name;
    private int age;
    private String color;
​
    public Dog(String name, int age, String color) {
        this.name = name;
        this.age = age;
        this.color = color;
    }
​
    @Override
    public String toString() {
        return "Dog{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", color='" + color + '\'' +
                '}';
    }
}