IO流

最新推荐文章于 2023-06-11 20:05:01 发布

Will1997

最新推荐文章于 2023-06-11 20:05:01 发布

阅读量92

点赞数

分类专栏： javaSE学习

本文链接：https://blog.csdn.net/qq_42371269/article/details/81570417

版权

javaSE学习专栏收录该内容

16 篇文章 1 订阅

订阅专栏

IO流

字节流：

1）InputStream

FileInputStream: 文件输入流

BufferedInputStream: 字节缓冲流，提高文件读取效率

ByteArrayInputStream: 字节数组输入流，将字节数组转化为输入流

ObjectInputStream: 对象输入流，将字节内容读取出来转化为对象，用于反序列化

2）OutputStream

FileOutputStream: 文件输出流

BufferedOutputStream: 字节缓冲流，提高文件写入效率

ByteArrayOutputStream: 字节数组输出流，将字节内容写入字节数组

ObjectOutputStream: 对象输出流，将对象转化为流，用于序列化（可永久保存对象）

PrintStream : 打印流，就是 System.out

字符流：

1）Reader

InputStreamReader : 字符转换流：将字节输入流转化为字符输入流

BufferedReader: 字符缓冲流，提高字符读取效率，一行一行写入

（装饰器模式：BufferedReader 和 InputStreamReader）

FileReader: InputStreamReader的子类，有缺陷（不能指定编码格式，默认使用系统的编码格式）

2）Writer

OutStreamWriter: 字符转换流，将字节输出流转化为字符输出流

BufferedWriter : 字符缓冲流，提高字符写入效率(但不常使用，提供的功能较少)

PrintWriter: 字符打印流，可以用来替代BufferedWriter(建议使用)

其中的方法： write()：将字符写入

print()：将字符转化为字符串，再将其写入

对象序列化和反序列化：可用于永久保存对象，

序列化与反序列化也是Java文件传输的一种机制

序列化：将对象转化为流，以二进制的形式写入文件中

前提：该对象必须实现 Serializable 接口

该对象的属性也必须是可序列化的

注意：如果某个属性不想被序列化的化就可用 transient 修饰，可防止被序列化

做法：利用ObjectOutputStream将对象变为字节输入流

例：

Student s = new Student("chen",001);

ObjectOutputStream os = new ObjectOutputStream( new FileOutputStream( "Student.obj" ) );//文件格式没有限制

os.writeObject(s);//将对象序列化

os.close();

反序列化：利用 ObjectInputStream 将字节内容还原成对象（相当于创建了新的对象）

前提：你得有被序列化好了的对象文件（例：Student.obj ）

ObjectInputStream is = new ObjectInputStream( new FileInputStream("Student.obj"))；

Student s = (Student) is.readObject();//假设已知对象是 Student 时

System.out.println( s );

注意：

1）除了序列化对象，也可以将基本类型进行序列化

2）读入和写出的顺序要一致，否则就会报错 EOFException（文件读写错误）

3）如果读到文件末尾，也会报 EOFException 异常

4）建议在序列化对象时，多序列化一个结束标志（null）,

这样当读到 null 时，就知道已经读到文件末尾了，避免了发生异常

克隆对象：也是一种创建对象的方法

前提：克隆需要对象实现 Cloneable 接口，并重写 Object的 clone() 方法

@Override
protected Object clone() throws CloneNotSupportedException {
// 必须调用Object父类的克隆方法
return super.clone();
}

设计模式

原型模式：不用构造方法，根据一个已有的对象来创建新的对象

克隆（clone）应用的就是原型模式

浅拷贝：克隆就是浅拷贝，如果拷贝的属性是引用类型的，那么只会拷贝该属性的地址没有 " 真正 " 的创建新的对象

深拷贝：序列化和反序列化，完全是创建了一个新的对象

代码：

            // 序列化
            ObjectOutputStream os = new ObjectOutputStream( new ByteArrayOutputStream());
            os.writeObject(this); // 写入当前对象
            byte[] bytes = bos.toByteArray(); // 得到字节结果

            // 反序列化
            ObjectInputStream is = new ObjectInputStream(new ByteArrayInputStream(bytes));
            Object o =  is.readObject();//将字节内容还原成对象

扩展：

1）for-each底层是通过迭代器来遍历的

                     List<Integer> list = new ArrayList<>();
                 
                     for (Integer i : list) {
                             System.out.println(i);
                     }

                     // 原理就是 迭代器

                    Iterator<Integer> iterator = list.iterator();
                    while( iterator.hasNext() ){
                                Integer i = iterator.next();
                                System.out.println(i);
                    }

2) 自动装箱 XXX.valueOf( xxx ) 和自动拆箱 .xxxValue() 的原理

Integer i = 1; // 自动装箱等价于 Integer i = Integer.valueOf(1);

int j = i; // 自动拆箱等价于 int j = i.intValue();

3）String字符常量相加（ + ）时，先拼接再编译(在内存中开辟空间)

String变量相加（ + ）时，先编译 (在内存中开辟空间) 再拼接

4）static int i = 0； i++; 和 int i=0； i++;的区别：

静态变量（全局变量）存放在方法区，进行运算之前要先拿到该静态变量的值：getstatic，

再进行运行，最后将结果再 putstatic 放回到方法区(会产生线程并发问题)

底层源码操作：