java--对象的输入输出流、字节流、序列化与反序列化

SequenceInputStream(序列流)

合并

//把三个文件合并成一个文件
public static void merge3() throws IOException{
    //找到目标文件
    File file1 = new File("F:\\a.txt");
    File file2 = new File("F:\\b.txt");
    File file3 = new File("F:\\c.txt");
    File file4 = new File("F:\\d.txt");

    //建立对应 的输入输出流对象
    FileOutputStream fileOutputStream = new FileOutputStream(file4);
    FileInputStream fileInputStream1 = new FileInputStream(file1);
    FileInputStream fileInputStream2 = new FileInputStream(file2);
    FileInputStream fileInputStream3 = new FileInputStream(file3);

    //创建序列流对象
    Vector<FileInputStream> vector = new Vector<FileInputStream>();
    vector.add(fileInputStream1);
    vector.add(fileInputStream2);
    vector.add(fileInputStream3);
    Enumeration<FileInputStream> e = vector.elements();

    SequenceInputStream sequenceInputStream = new SequenceInputStream(e);
    //读取文件数据
    byte[] buf = new byte[1024];
    int length = 0; 

    while((length = sequenceInputStream.read(buf))!=-1){
        fileOutputStream.write(buf,0,length);
    }

    //关闭资源
    sequenceInputStream.close();
    fileOutputStream.close();

}

切割

File file = new File("F:\\美女\\1.mp3");
    //目标文件夹
    File dir = new File("F:\\music");
    //建立数据的输入通道
    FileInputStream fileInputStream = new FileInputStream(file);
    //建立缓冲数组读取
    byte[] buf = new byte[1024*1024];
    int length = 0;
    for(int i = 0 ;  (length = fileInputStream.read(buf))!=-1 ; i++){
        FileOutputStream fileOutputStream = new FileOutputStream(new File(dir,"part"+i+".mp3"));
        fileOutputStream.write(buf,0,length);
        fileOutputStream.close();
    }
    //关闭资源
    fileInputStream.close();

对象的输入输出流

对象的输入输出流 主要的作用

是用于写对象的信息与读取对象的信息。 对象信息一旦写到文件上那么对象的信息就可以做到持久化了

对象的输出流： ObjectOutputStream .

对象的输入流: ObjectInputStream

ObjectOutputStream的使用步骤：

1. 对象输入输出流要注意的细节：

1. 如果对象需要被写出到文件上，那么对象所属的类必须要实现Serializable接口。 Serializable接口没有任何的方法，是一个标识接口而已。
2. 对象的反序列化创建对象的时候并不会调用到构造方法的、
3. serialVersionUID 是用于记录class文件的版本信息的，serialVersionUID这个数字是通过一个类的类名、成员、包名、工程名算出的一个数字。
4. 使用ObjectInputStream反序列化的时候，ObjeectInputStream会先读取文件中的serialVersionUID，然后与本地的class文件的serialVersionUID
进行对比，如果这两个id不一致，那么反序列化就失败了。
5. 如果序列化与反序列化的时候可能会修改类的成员，那么最好一开始就给这个类指定一个serialVersionUID，如果一类已经指定的serialVersionUID，然后
在序列化与反序列化的时候，jvm都不会再自己算这个 class的serialVersionUID了。
6. 如果一个对象某个实例变量不想被序列化到硬盘上，可以使用关键字transient修饰。
7. 如果一个类维护了另外一个类的引用，那么另外一个类也需要实现Serializable接口。
8.当对象被序列化时，被该对象引用的实例变量也会被序列化。且所有被引用的对象也会被序列化，这些操作都是自动进行的。
9.静态变量不会被序列化，会维持类中原本的样子，因为所有对象共享同一份静态变量值。
10.父类实现序列化，子类自动实现，而不管是否有明确的声明。
11.读取对象的顺序必须与写入对象的顺序相同。

---

class Address implements Serializable{

String country; 

String city;

public Address(String country,String city){
    this.country = country;
    this.city = city;
}

}

class User implements Serializable{

private static final long serialVersionUID = 1l;

String userName ;

String password;

transient int age;  // transient 透明

Address address ;

public User(String userName , String passwrod) {
    this.userName = userName;
    this.password = passwrod;
}

public User(String userName , String passwrod,int age,Address address) {
    this.userName = userName;
    this.password = passwrod;
    this.age = age;
    this.address = address;
}

@Override
public String toString() {
    return "用户名："+this.userName+ " 密码："+ this.password+" 年龄："+this.age+" 地址："+this.address.city;
}
}

//把文件中的对象信息读取出来-------->对象的反序列化
public static void readObj() throws  IOException, ClassNotFoundException{
    //找到目标文件
    File file = new File("F:\\obj.txt");
    //建立数据的输入通道
    FileInputStream fileInputStream = new FileInputStream(file);
    //建立对象的输入流对象
    ObjectInputStream objectInputStream = new ObjectInputStream(fileInputStream);
    //读取对象信息
    User user = (User) objectInputStream.readObject(); //创建对象肯定要依赖对象所属 的class文件。
    System.out.println("对象的信息："+ user);
}

//定义方法把对象的信息写到硬盘上------>对象的序列化。
public static void writeObj() throws IOException{
    //把user对象的信息持久化存储。
    Address address = new Address("中国","广州");
    User user = new User("admin","123",15,address);
    //找到目标文件
    File file = new File("F:\\obj.txt");
    //建立数据输出流对象
    FileOutputStream fileOutputStream = new FileOutputStream(file);
    //建立对象的输出流对象
    ObjectOutputStream objectOutputStream = new ObjectOutputStream(fileOutputStream);
    //把对象写出
    objectOutputStream.writeObject(user);
    //关闭资源
    objectOutputStream.close();
}

Properties（配置文件类）

Properties（配置文件类）: 主要用于生产配置文件与读取配置文件的信息。

Properties要注意的细节：

1. 如果配置文件的信息一旦使用了中文，那么在使用store方法生成配置文件的时候只能使用字符流解决，如果使用字节流生成配置文件的话，
默认使用的是iso8859-1码表进行编码存储，这时候会出现乱码。
2. 如果Properties中的内容发生了变化，一定要重新使用Properties生成配置文件，否则配置文件信息不会发生变化。

读取配置文件

//读取配置文件的信息
public static void readProperties() throws IOException{
    //创建Properties对象
    Properties properties = new Properties();
    //加载配置文件信息到Properties中
    properties.load(new FileReader("F:\\persons.properties"));
    //遍历
    Set<Entry<Object, Object>> entrys = properties.entrySet();
    for(Entry<Object, Object> entry  :entrys){
        System.out.println("键："+ entry.getKey() +" 值："+ entry.getValue());
    }
    //修改狗娃的密码
    //把修改后的Properties再生成一个配置文件
    properties.setProperty("狗娃", "007");
    properties.store(new FileWriter("F:\\persons.properties"), "hehe");
}

保存（写入）配置文件信息

//保存配置文件文件的信息。
public static void creatProperties() throws IOException{
    //创建Properties
    Properties properties = new Properties();
    properties.setProperty("狗娃", "123");
    properties.setProperty("狗剩","234");
    properties.setProperty("铁蛋","345");
    // 遍历Properties
    /*Set<Entry<Object, Object>> entrys = properties.entrySet();
    for(Entry<Object, Object> entry  :entrys){
        System.out.println("键："+ entry.getKey() +" 值："+ entry.getValue());
    }*/

    //使用Properties生产配置文件。
    //properties.store(new FileOutputStream("F:\\persons.properties"), "haha"); //第一个参数是一个输出流对象，第二参数是使用一个字符串描述这个配置文件的信息。
    properties.store(new FileWriter("F:\\persons.properties"), "hehe");
}

需求： 使用properties实现本软件只能 运行三次，超过了三次之后就提示购买正版，退jvm.

File file = new File("F:\\count.properties");
    if(!file.exists()){
        //如果配置文件不存在，则创建该配置文件
        file.createNewFile();
    }

    //创建Properties对象。
    Properties properties = new Properties();
    //把配置文件的信息加载到properties中
    properties.load(new FileInputStream(file));
    FileOutputStream fileOutputStream = new FileOutputStream(file);

    int count = 0; //定义该变量是用于保存软件的运行次数的。
    //读取配置文件的运行次数
    String value = properties.getProperty("count");
    if(value!=null){
        count = Integer.parseInt(value);
    }

    //判断使用的次数是否已经达到了三次，
    if(count==3){
        System.out.println("你已经超出了试用次数，请购买正版软件！！");
        System.exit(0);
    }

    count++;
    System.out.println("你已经使用了本软件第"+count+"次");
    properties.setProperty("count",count+"");
    //使用Properties生成一个配置文件
    properties.store(fileOutputStream,"runtime");

}

打印流（printStream）

打印流可以打印任意类型的数据，而且打印数据之前都会先把数据转换成字符串再进行打印。

class Animal{

String name;

String color;

public Animal(String name,String color){
    this.name = name;
    this.color = color;
}

@Override
public String toString() {
    return "名字："+this.name+ " 颜色："+ this.color;
}

}

---

public static void main(String[] args) throws IOException {
    /*FileOutputStream fileOutputStream = new FileOutputStream("F:\\a.txt");
    fileOutputStream.write("97".getBytes());
    fileOutputStream.close();*/

    //打印流可以打印任何类型的数据，而且打印数据之前都会先把数据转换成字符串再进行打印。
    File file = new  File("F:\\a.txt");
    //创建一个打印流
    PrintStream printStream = new PrintStream(file);
    /*
    printStream.println(97);
    printStream.println(3.14);
    printStream.println('a');
    printStream.println(true);
    Animal a = new Animal("老鼠", "黑色");
    printStream.println(a);

    //默认标准的输出流就是向控制台输出的，
    System.setOut(printStream); //重新设置了标准的输出流对象
    System.out.println("哈哈，猜猜我在哪里！！");
    */

    //收集异常的日志信息。
    File logFile = new File("F:\\2015年1月8日.log");
    PrintStream logPrintStream = new PrintStream( new FileOutputStream(logFile,true) );
    try{
        int c = 4/0;
        System.out.println("c="+c);
        int[] arr = null;
        System.out.println(arr.length);

    }catch(Exception e){
        e.printStackTrace(logPrintStream);

    }
}

编码与解码

编码： 把看得懂的字符变成看不懂码值这个过程我们称作为编码。

解码： 把码值查找对应的字符，我们把这个过程称作为解码。

注意： 以后编码与解码一般我们都使用统一的码表。否则非常容易出乱码。

/*
    String str = "中国";
    byte[] buf = str.getBytes("utf-8");// 平台默认的编码表是gbk编码表。  编码
    System.out.println("数组的元素："+Arrays.toString(buf)); //

    str = new String(buf,"utf-8");  //默认使用了gbk码表去解码。
    System.out.println("解码后的字符串："+ str);
    */

    /*String str = "a中国"; // ,0, 97, 78, 45, 86, -3
    byte[] buf = str.getBytes("unicode");  //编码与解码的时候指定 的码表是unicode实际上就是用了utf-16.
    System.out.println("数组的内容："+ Arrays.toString(buf));
    */

    String str = "大家好";
    byte[] buf = str.getBytes(); //使用gbk进行编码
    System.out.println("字节数组："+ Arrays.toString(buf));  // -76, -13, -68, -46, -70, -61

    str = new String(buf,"iso8859-1");
    // 出现乱码之后都可以被还原吗？ 

    byte[] buf2 = str.getBytes("iso8859-1");
    str = new String(buf2,"gbk"); 

    System.out.println(str);

转换流

输入字节流的转换流：InputStreamReader 是字节流通向字符流的桥
InputStreamReader

输出字节流的转换流：
OutputStreamWriter 可以把输出字节流转换成输出字符流 。

转换流的作用：

1. 如果目前所 获取到的是一个字节流需要转换字符流使用，这时候就可以使用转换流。  字节流----> 字符流
2. 使用转换流可以指定编码表进行读写文件。

//使用输入字节流的转换流指定码表进行读取文件数据
public static void readTest2() throws IOException{
    File file = new File("F:\\a.txt");
    FileInputStream fileInputStream = new FileInputStream(file);
    //创建字节流的转换流并且指定码表进行读取
    InputStreamReader inputStreamReader = new InputStreamReader(fileInputStream,"utf-8");
    char[] buf = new char[1024];
    int length = 0;
    while((length = inputStreamReader.read(buf))!=-1){
        System.out.println(new String(buf,0,length));
    }

}

//使用输出字节流的转换流指定码表写出数据
public static void writeTest2() throws IOException{
    File file = new File("F:\\a.txt");
    //建立数据的输出通道
    FileOutputStream fileOutputStream = new FileOutputStream(file);
    //把输出字节流转换成字符流并且指定编码表。
    OutputStreamWriter outputStreamWriter = new OutputStreamWriter(fileOutputStream, "utf-8");
    outputStreamWriter.write("新中国好啊");
    //关闭资源
    outputStreamWriter.close();

}