package Demo46;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
/**
* java.io.ObjectInputStream extends InputStream
* ObjectInputStream:对象的反系列化流
* 作用：把文件中保存的对象，以流的方式读取出来使用
* 构造方法：
* ObjectInputStream(InputStream in)创建写入指定InputStream的ObjectInputStream
* 参数：
* InputStream in:字节输入流
* 特有的成员方法：
* void ReadObject(Object obj)从ObjectInputStream读取对象
* 使用步骤：
* 1、创建ObjectInputStream对象，构造方法中传递字节输入流
* 2、使用ObjectInputStream对象中的方法ReadObject,读取保存对象的文件
* 3、释放资源
* 4、使用读取出来的对象
*readObject方法声明抛出ClassNotFoundException(文件找不到异常)
* 当不存在对象的class文件是抛出异常
* 反序列化的前提：
* 1、类必须实现serializable
* 2、必须存在类对应的class文件
*/
public class DemoObjectInputStream {
public static void main(String[] args) throws IOException, ClassNotFoundException {
//1、创建ObjectInputStream对象，构造方法中传递字节输入流
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("E:\\daima\\java_day01\\src\\Demo44\\abc"));
// 2、使用ObjectInputStream对象中的方法ReadObject,读取保存对象的文件
Object o = ois.readObject();
//3、释放资源
ois.close();
//4、使用读取出来的对象
System.out.println(o);
}
}
package Demo46;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
/**
* java.io.ObjectOutputStream extends OutputStream
* ObjectOutputStream:对象的系列化流
* 作用：把对象以流的方式写入到文件中保存
*
* 构造方法：
* ObjectOutputStream(OutputStream out)创建写入指定OutputStream的ObjectOutputStream
* 参数：
* OutputStream out:字节输出流
*特有的成员方法：
* void writeObject(Object obj)将指定的对象写入ObjectOutputStream
*
* 使用步骤：
* 1、创建ObjectOutputStream对象，构造方法中传递字节输出流
* 2、使用ObjectOutputStream对象中的方法writeObject,把对象写入到文件中
* 3、释放资源
*/
public class DemoObjectOutputStream {
public static void main(String[] args) throws IOException {
// 1、创建ObjectOutputStream对象，构造方法中传递字节输出流
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("E:\\daima\\java_day01\\src\\Demo44\\abc"));
//2、使用ObjectOutputStream对象中的方法writeObject,把对象写入到文件中
oos.writeObject(new Person("美女",18));
//3、释放资源
oos.close();
}
}
package Demo46;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
/**
* java.io.InputStreamReader extends Reader
* InputStreamReader是字节流通向字符流的桥梁，可以使用指定的charset将要写入流中的字符编码成字节
*
* 继承自父类的共性的成员方法：
* int read()读取单个字符并返回
* int read(char[] cbuf)一次读取多个字符，将字符读入数组
* void close()关闭流并释放资源
*构造方法：
* InputStreamReader(InputStream in)创建一个使用默认字符集的InputStreamReader
* InputStreamReader(InputStream in, String charsetName)创建一个使用指定字符集的InputStreamReader
* 参数：
* InputStreamReader in：字节输入流，用来读取文件中保存的字节
* String charsetName：指定编码表的名称，不区分大小写
*使用步骤：
* 1、创建InputStreamReader对象，构造方法中传递字节输入流和指定的编码表名称
* 2、使用InputStreamReader对象中的方法read读取文件
* 3、释放资源
*注意事项：
* 构造方法中指定的编码表名称要和文件的编码相同，否则会发生乱码
*/
public class DemoOutputStreamReader {
public static void main(String[] args) throws IOException {
//reader_utf_8();
reader_gbk();
}
private static void reader_gbk() throws IOException {
// 1、创建InputStreamReader对象，构造方法中传递字节输入流和指定的编码表名称
InputStreamReader ipRead = new InputStreamReader(new FileInputStream("E:\\hadoop\\testfile\\abc.txt"),"gbk");
// 2、使用InputStreamReader对象中的方法read读取文件
int len = 0;
while ((len = ipRead.read())!=-1){
System.out.println((char)len);
}
//3、释放资源
ipRead.close();
}
private static void reader_utf_8() throws IOException {
// 1、创建InputStreamReader对象，构造方法中传递字节输入流和指定的编码表名称
InputStreamReader ipRead = new InputStreamReader(new FileInputStream("E:\\daima\\java_day01\\src\\Demo44\\abc"),"utf-8");
// 2、使用InputStreamReader对象中的方法read读取文件
int len = 0;
while ((len = ipRead.read())!=-1){
System.out.println((char)len);
}
//3、释放资源
ipRead.close();
}
}
package Demo46;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
/**
* java.io.OutputStreamWriter extends writer
* OutputStreamWriter:是字符流通向字节流的桥梁，可以使用指定的charset将要写入流中的字符编码成字节
*
* 继承自父类的共性的方法：
* void write(int c)写入单个字符
* void write(char[] cbuf)写入字符数组
* abstract void write(char[] cbuf, int off, int len)写入字符数组的某一部分，off数组的开始索引，len写的字符个数
* void write(String str)写入字符串
* void write(String str, int off, int len)写入字符串的某一部分，off字符串的开始索引，len写的字符串的个数
* void flush()刷新该流的缓冲
* void close()关闭此流，但要先刷新它
*
* 构造方法：
* OutputStreamWriter(OutputStream out)创建使用默认字符编码的OutputStreamWriter
* OutputStreamWriter(OutputStream out, String charsetName)创建字符集的指定的OutputStreamWriter
* 参数：
* OutputStream out:字节输出流，可以用来写转换之后的字节到文件中
* String charsetName:指定的编码表名称，不区分大小写，可以是utf-8/UTF-8/GBK,不指定默认使用UTF-8
*使用步骤：
* 1、创建一个OutputStreamWriter对象构造方法中传递字节输出流和指定的编码表名称
* 2、使用OutputStreamWriter对象中的方法write，把字符转换为字节存储缓冲区中
* 3、使用OutputStreamWriter对象中的方法flush，把内存缓冲区的字节刷新到文件中
* 4、释放资源
*
*/
public class DemoOutputStreamWriter {
public static void main(String[] args) throws IOException {
//write_utf_8();
write_gbk();
}
private static void write_gbk() throws IOException {
//1、创建一个OutputStreamWriter对象构造方法中传递字节输出流和指定的编码表名称
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("E:\\daima\\java_day01\\src\\Demo44\\abc"),"gbk");
//2、使用OutputStreamWriter对象中的方法write，把字符转换为字节存储缓冲区中
osw.write("你好");
//3、使用OutputStreamWriter对象中的方法flush，把内存缓冲区的字节刷新到文件中
osw.flush();
//4、释放资源
osw.close();
}
//使用转换rea流OutputStmWriter写UTF-8格式的文件
private static void write_utf_8() throws IOException {
//1、创建一个OutputStreamWriter对象构造方法中传递字节输出流和指定的编码表名称
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("E:\\daima\\java_day01\\src\\Demo44\\abc"),"utf-8");
//2、使用OutputStreamWriter对象中的方法write，把字符转换为字节存储缓冲区中
osw.write("你好");
//3、使用OutputStreamWriter对象中的方法flush，把内存缓冲区的字节刷新到文件中
osw.flush();
//4、释放资源
osw.close();
}
}
package Demo46;
import java.io.*;
/**
* 练习：转换文件编码：
* 将GBK编码的文本文件，转换为UTF-8编码的文本文件
*分析：
* 1、创建InputStreamReader对象，构造方法中传递字节输入流和指定的编码表名称GBK
* 2、创建OutputStreamReader对象，构造方法中传递字节输出流和指定的编码表名称utf-8
* 3、使用InputStreamReader对象中的方法read读取文件
* 4、使用OutputStreamWriter对象中的方法write，把读取的数据写入文件中
* 5、释放资源
*
*/
public class Test {
public static void main(String[] args) throws IOException {
//1、创建InputStreamReader对象，构造方法中传递字节输入流和指定的编码表名称GBK
InputStreamReader input = new InputStreamReader(new FileInputStream("E:\\hadoop\\testfile\\abc.txt"),"gbk");
//2、创建OutputStreamReader对象，构造方法中传递字节输出流和指定的编码表名称utf-8
OutputStreamWriter ouput = new OutputStreamWriter(new FileOutputStream("E:\\daima\\java_day01\\src\\Demo44\\abc"),"utf-8");
// 3、使用InputStreamReader对象中的方法read读取文件
int len = 0;
while ((len = input.read())!=-1){
//4、使用OutputStreamWriter对象中的方法write，把读取的数据写入文件中
ouput.write(len);
}
//5、释放资源
ouput.close();
input.close();
}
}
package Demo46;
import java.io.Serializable;
/**
* 序列化和反序列化的时候，会抛出NotSerializableException没有序列化异常
* 类通过实现java.io.serializable 接口以启用其序列化功能，未实现此接口的类将无法使用其任何状态序列化或反序列化
* serializable接口也叫标记型接口
* 要进行序列化和反序列化的类必须实现serializable接口，就会给类添加一个标记
* 当我们进行序列化和反序列化的时候，就会检测类上是否有这个标记
* 有：可以实现序列化和反序列化
* 没有：则会抛出异常NotSerializableException
*
*static关键字：静态关键字
* 静态优于非静态加载到内存中,所以被static修饰的成员变量不能被序列化的，序列化的都是对象
*transient关键字：瞬态关键字
* 被 transient修饰的成员变量，不能被序列化
* 不想被序列化就用transient修饰
*/
public class Person implements Serializable {
private static final long serialVersionUID = 1L;
private String name;
private int age;
// private transient int age;
public Person() {
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
package Demo46;
import java.io.*;
import java.util.ArrayList;
/**
* 练习：序列化集合
* 对集合进行序列化和反序列化
* 分析：
* 1、定义一个存储Person对象的ArrayList集合
* 2、在ArrayList集合对象存储Person对象
* 3、创建一个序列化流ObjectOutputStream对象
* 4、使用ObjectOutputStream对象中的方法writeObject，对集合进行序列化
* 5、创建一个反序列化ObjectOutputStream对象
* 6、使用ObjectOutputStream对象中的方法readObject读取文件中保存的集合
* 7、把Object类型的集合转换为ArrayList类型
* 8、遍历ArrayList集合
* 9、释放资源
*/
public class Test1 {
public static void main(String[] args) throws IOException, ClassNotFoundException {
//1、定义一个存储Person对象的ArrayList集合
ArrayList<Person> list = new ArrayList<>();
//2、在ArrayList集合对象存储Person对象
list.add(new Person("迪丽热巴",18));
list.add(new Person("马尔扎哈",19));
list.add(new Person("景甜",15));
//3、创建一个序列化流ObjectOutputStream对象
ObjectOutputStream ows = new ObjectOutputStream(new FileOutputStream("E:\\daima\\java_day01\\src\\Demo44\\abc"));
//4、使用ObjectOutputStream对象中的方法writeObject，对集合进行序列化
ows.writeObject(list);
//5、创建一个反序列化ObjectOutputStream对象
ObjectInputStream ofs = new ObjectInputStream(new FileInputStream("E:\\daima\\java_day01\\src\\Demo44\\abc"));
//6、使用ObjectOutputStream对象中的方法readObject读取文件中保存的集合
Object o = ofs.readObject();
//7、把Object类型的集合转换为ArrayList类型
ArrayList<Person> list2 = (ArrayList<Person>)o;
//8、遍历ArrayList集合
for (Person person : list2) {
System.out.println(person);
}
//9、释放资源
ofs.close();
ows.close();
}
}
package Demo46;
import java.io.FileNotFoundException;
import java.io.PrintStream;
/**
* java.io.PrintStream:打印流
* PrintStream ：为其它输出流添加了功能，是它们能够方便的打印各种数据值表示形式
* PrintStream特点：
* 1、只负责数据的输出，不负责数据的读取
* 2、与其它输出流不同，PrintStream永远不会抛出IOException
* 3、特有的方法print,println
* void print(任意类型的值)
* void println(任意类型的值并换行)
*构造方法：
* PrintStream(File file):输出的目的地是一个文件
* PrintStream(OutputStream out):输出的目的地是一个字节输出流
* PrintStream(String fileName):输出的目的地是一个文件路径
* PrintStream extends OutputStream
* 继承自父类的成员方法：
* public void close():关闭此流释放资源
* public void flush():刷新此输出流并强制任何缓冲的输出字节被写出
* public void write(byte[] b):将b.length字节数组写入此输出流中
* public void write(byte[] b, int off, int len):将指定的字节数组写入len字节,从偏移量off开始输出到此输出流
* public abstract void write(int b)：将指定的字节输出流
*
* 注意：
* 如果使用继承自父类的write方法写数据，那么查看数据的时候回查询编码表97 ->a
* 如果使用自己特有的方法print/println方法写数据，写的数据原样输出97 -> 97
*
* 可以改变输出语句的目的地
* static void setOut(printStream out)
*/
public class DemoPrintStream {
public static void main(String[] args) throws FileNotFoundException {
System.out.println("我在控制台输出");
//创建打印流printStream对象，构造方法中绑定要输出的目的地
PrintStream ps = new PrintStream("E:\\daima\\java_day01\\src\\Demo44\\abc");
System.setOut(ps);
System.out.println("我在打印流输出");
// 如果使用继承自父类的write方法写数据，那么查看数据的时候回查询编码表97 ->a
ps.write(97);
//如果要使用自己特有的方法print/println方法写数据，写数据原样输出97->97
ps.println(97);
ps.println(8.8);
ps.println("hello");
ps.close();
}
}
