JAVA~适合新手和复习~基础五（IO流、Stream流、序列化）

IO流

一个流可以理解为一个数据的序列。输入流表示从一个源读取数据，输出流表示向一个目标写数据。

FileInputStream

该流用于从文件读取数据，它的对象可以用关键字 new 来创建。

有多种构造方法可用来创建对象。

可以使用字符串类型的文件名来创建一个输入流对象来读取文件：

InputStream f = new FileInputStream("C:/java/hello");

也可以使用一个文件对象来创建一个输入流对象来读取文件。我们首先得使用 File() 方法来创建一个文件对象：

File f = new File("C:/java/hello"); 
InputStream in = new FileInputStream(f);

创建了InputStream对象，就可以使用下面的方法来读取流或者进行其他的流操作

序号	方法及描述
1	public void close() throws IOException{} 关闭此文件输入流并释放与此流有关的所有系统资源。抛出IOException异常。
2	protected void finalize()throws IOException {} 这个方法清除与该文件的连接。确保在不再引用文件输入流时调用其 close 方法。抛出IOException异常。
3	public int read(int r)throws IOException{} 这个方法从 InputStream 对象读取指定字节的数据。返回为整数值。返回下一字节数据，如果已经到结尾则返回-1。
4	public int read(byte[] r) throws IOException{} 这个方法从输入流读取r.length长度的字节。返回读取的字节数。如果是文件结尾则返回-1。
5	public int available() throws IOException{} 返回下一次对此输入流调用的方法可以不受阻塞地从此输入流读取的字节数。返回一个整数值。

FileOutputStream

该类用来创建一个文件并向文件中写数据。如果该流在打开文件进行输出前，目标文件不存在，那么该流会创建该文件。有两个构造方法可以用来创建 FileOutputStream 对象。

1 //使用字符串类型的文件名来创建一个输出流对象：
2 OutputStream f = new FileOutputStream("C:/java/hello")
3 //使用字符串类型的文件名来创建一个输出流对象：
4 File f = new File("C:/java/hello");
5 OutputStream fOut = new FileOutputStream(f);

创建OutputStream 对象完成后，就可以使用下面的方法来写入流或者进行其他的流操作。

序号	方法及描述
1	public void close() throws IOException{} 关闭此文件输入流并释放与此流有关的所有系统资源。抛出IOException异常。
2	protected void finalize()throws IOException {} 这个方法清除与该文件的连接。确保在不再引用文件输入流时调用其 close 方法。抛出IOException异常。
3	public void write(int w)throws IOException{} 这个方法把指定的字节写到输出流中。
4	public void write(byte[] w) 把指定数组中w.length长度的字节写到OutputStream中。

实例

 1 //文件名 :fileStreamTest2.java
 2 import java.io.*;
 3  
 4 public class fileStreamTest2 {
 5     public static void main(String[] args) throws IOException {
 6  
 7         File f = new File("a.txt");
 8         FileOutputStream fop = new FileOutputStream(f);
 9         // 构建FileOutputStream对象,文件不存在会自动新建
10  
11         OutputStreamWriter writer = new OutputStreamWriter(fop, "UTF-8");
12         // 构建OutputStreamWriter对象,参数可以指定编码,默认为操作系统默认编码,windows上是gbk
13  
14         writer.append("中文输入");
15         // 写入到缓冲区
16  
17         writer.append("\r\n");
18         // 换行
19  
20         writer.append("English");
21         // 刷新缓存冲,写入到文件,如果下面已经没有写入的内容了,直接close也会写入
22  
23         writer.close();
24         // 关闭写入流,同时会把缓冲区内容写入文件,所以上面的注释掉
25  
26         fop.close();
27         // 关闭输出流,释放系统资源
28  
29         FileInputStream fip = new FileInputStream(f);
30         // 构建FileInputStream对象
31  
32         InputStreamReader reader = new InputStreamReader(fip, "UTF-8");
33         // 构建InputStreamReader对象,编码与写入相同
34  
35         StringBuffer sb = new StringBuffer();
36         while (reader.ready()) {
37             sb.append((char) reader.read());
38             // 转成char加到StringBuffer对象中
39         }
40         System.out.println(sb.toString());
41         reader.close();
42         // 关闭读取流
43  
44         fip.close();
45         // 关闭输入流,释放系统资源
46  
47     }
48 }

Java中的目录(和Linux的几乎一样)

创建目录：

文件类中有两个方法可以用来创建文件夹：

mkdir( )方法创建一个文件夹，成功则返回true，失败则返回false。失败表明File对象指定的路径已经存在，或者由于整个路径还不存在，该文件夹不能被创建。
mkdirs()方法创建一个文件夹和它的所有父文件夹。

例子

 1 import java.io.File;
 2  
 3 public class CreateDir {
 4     public static void main(String[] args) {
 5         String dirname = "/tmp/user/java/bin";
 6         File d = new File(dirname);
 7         // 现在创建目录
 8         d.mkdirs();
 9     }
10 }

读取目录

一个目录其实就是一个 File 对象，它包含其他文件和文件夹。

如果创建一个 File 对象并且它是一个目录，那么调用 isDirectory() 方法会返回 true。

可以通过调用该对象上的 list() 方法，来提取它包含的文件和文件夹的列表。

下面展示的例子说明如何使用 list() 方法来检查一个文件夹中包含的内容：

 1 import java.io.File;
 2  
 3 public class DirList {
 4     public static void main(String args[]) {
 5         String dirname = "/tmp";
 6         File f1 = new File(dirname);
 7         if (f1.isDirectory()) {
 8             System.out.println("目录 " + dirname);
 9             String s[] = f1.list();
10             for (int i = 0; i < s.length; i++) {
11                 File f = new File(dirname + "/" + s[i]);
12                 if (f.isDirectory()) {
13                     System.out.println(s[i] + " 是一个目录");
14                 } else {
15                     System.out.println(s[i] + " 是一个文件");
16                 }
17             }
18         } else {
19             System.out.println(dirname + " 不是一个目录");
20         }
21     }
22 }
23 
24 
25 以上实例编译运行结果如下：
26 
27 目录 /tmp
28 bin 是一个目录
29 lib 是一个目录
30 demo 是一个目录
31 test.txt 是一个文件
32 README 是一个文件
33 index.html 是一个文件
34 include 是一个目录

删除目录或文件

删除文件可以使用 java.io.File.delete() 方法。

以下代码会删除目录 /tmp/java/，需要注意的是当删除某一目录时，必须保证该目录下没有其他文件才能正确删除，否则将删除失败。

测试目录结构：

/tmp/java/
|-- 1.log
|-- test

import java.io.File;
 
public class DeleteFileDemo {
    public static void main(String[] args) {
        // 这里修改为自己的测试目录
        File folder = new File("/tmp/java/");
        deleteFolder(folder);
    }
 
    // 删除文件及目录
    public static void deleteFolder(File folder) {
        File[] files = folder.listFiles();
        if (files != null) {
            for (File f : files) {
                if (f.isDirectory()) {
                    deleteFolder(f);
                } else {
                    f.delete();
                }
            }
        }
        folder.delete();
    }
}

从控制台读取多字符输入

 1 //使用 BufferedReader 在控制台读取字符
 2  
 3 import java.io.*;
 4  
 5 public class BRRead {
 6     public static void main(String[] args) throws IOException {
 7         char c;
 8         // 使用 System.in 创建 BufferedReader
 9         BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
10         System.out.println("输入字符, 按下 'q' 键退出。");
11         // 读取字符
12         do {
13             c = (char) br.read();
14             System.out.println(c);
15         } while (c != 'q');
16     }
17 }

以上实例编译运行结果如下:

输入字符, 按下 'q' 键退出。
runoob
r
u
n
o
o
b


q
q

从控制台读取字符串

//使用 BufferedReader 在控制台读取字符
import java.io.*;
 
public class BRReadLines {
    public static void main(String[] args) throws IOException {
        // 使用 System.in 创建 BufferedReader
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String str;
        System.out.println("Enter lines of text.");
        System.out.println("Enter 'end' to quit.");
        do {
            str = br.readLine();
            System.out.println(str);
        } while (!str.equals("end"));
    }
}

以上实例编译运行结果如下:

Enter lines of text.
Enter 'end' to quit.
This is line one
This is line one
This is line two
This is line two
end
end

控制台输出

 1 import java.io.*;
 2  
 3 //演示 System.out.write().
 4 public class WriteDemo {
 5     public static void main(String[] args) {
 6         int b;
 7         b = 'A';
 8         System.out.write(b);
 9         System.out.write('\n');
10     }
11 }

运行以上实例在输出窗口输出 "A" 字符

IO流的几种分类

按流向分（站在程序角度考虑）

输入流(input)
输出流(outpu）

按类型分:
字节流(InputStream/OutputStream)
任何文件都可以通过字节流进行传输。

字符流(Reader/Writer)
非纯文本文件，不能用字符流，会导致文件格式破坏，不能正常执行。

节点流(低级流:直接跟输入输出源对接)
FileInputStream/FileOutputStream/FileReader/FileWriter/PrintStream/PrintWriter.

处理流(高级流:建立在低级流的基础上)
转换流：InputStreamReader/OutputStreamWriter，字节流转字符流/字符流转字节流
缓冲流：BufferedInputStream/BufferedOutputStream BufferedReader/BufferedReader可对节点流经行包装，使读写更快

Stream

Stream 使用一种类似用 SQL 语句从数据库查询数据的直观方式来提供一种对 Java 集合运算和表达的高阶抽象。元素流在管道中经过中间操作（intermediate operation）的处理，最后由最终操作(terminal operation)得到前面处理的结果。

+--------------------+       +------+   +------+   +---+   +-------+
| stream of elements +-----> |filter+-> |sorted+-> |map+-> |collect|
+--------------------+       +------+   +------+   +---+   +-------+
有没有英语和我一样差的，哈哈

+--------------------+       +------+   +------+   +---+   +-------+
|       元素流        +-----> | 过滤  +-> | 排序  +-> |映射+-> | 收集 |
+--------------------+       +------+   +------+   +---+   +-------+




以上的流程转换为 Java 代码为：

List<Integer> transactionsIds = 
widgets.stream()
             .filter(b -> b.getColor() == RED)
             .sorted((x,y) -> x.getWeight() - y.getWeight())
             .mapToInt(Widget::getWeight)
             .sum();

什么是 Stream？

Stream（流）是一个来自数据源的元素队列并支持聚合操作

.元素是特定类型的对象，形成一个队列。 Java中的Stream并不会存储元素，而是按需计算。
.数据源 流的来源。 可以是集合，数组，I/O channel， 产生器generator 等。
.聚合操作 类似SQL语句一样的操作， 比如filter, map, reduce, find, match, sorted等。

和以前的Collection操作不同， Stream操作还有两个基础的特征：

*Pipelining: 中间操作都会返回流对象本身。 这样多个操作可以串联成一个管道， 如同流式风格（fluent style）。 这样做可以对操作进行优化， 比如延迟执行(laziness)和短路( short-circuiting)。
*内部迭代： 以前对集合遍历都是通过Iterator或者For-Each的方式, 显式的在集合外部进行迭代， 这叫做外部迭代。 Stream提供了内部迭代的方式， 通过访问者模式(Visitor)实现。

生成流

在 Java 8 中, 集合接口有两个方法来生成流：

stream() − 为集合创建串行流。

parallelStream() − 为集合创建并行流。

List<String> strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");
List<String> filtered = strings.stream().filter(string -> !string.isEmpty()).collect(Collectors.toList());

示例

1 long count = strings.stream()                   //声明作为流处理
2                 .filter(e -> e.isEmpty())      //中间操作，过滤空元素
3                 .count();                     //结束操作，计算

是不是想问count又是干嘛用的？？不要着急嘛来看下文！

中间操作

过滤filter

filter()方法用于通过设置的条件过滤出元素

1  List<String> strings =Arrays.asList("aa", "bb", "cc", "", "");
2         long count = strings.stream()           //声明作为流处理
3                 .filter(e -> e.isEmpty())      //中间操作，过滤空元素
4                 .count();                      //结束操作，计算
5         System.out.println(count);

Stream流属于延迟执行，只有调用了结束操作，才能触发整个的执行。如果未定义结束操作，那么流处理什么也不会做。

筛选limit/skip

limit()方法用于获取指定数量的流（前n个），skip()方法用于去除指定数量的流（前n个）

1 Random random = new Random();
2         random.ints()
3                 .limit(10)
4                 .skip(5)
5                 .forEach(value -> System.out.println(value));

映射map

map()方法用于映射每个元素到对应的结果，其实就是对结果进行转化

List<Integer> integers = Arrays.asList(3, 2, 5, 4, 6, 8, 9, 1);
        List<Integer> list = integers.stream()
                                     .map(i -> i * i)
                                     .collect(Collectors.toList());
        System.out.println(list.toString());

排序sorted

sorted()方法通过Comparable接口对流进行排序，也可以自定义

 Random random = new Random();
        random.ints().limit(10)
                     .sorted()
                     .forEach(System.out::println);

使用Comparator 来排序一个list

说明：统计学生毕业后薪资，将同学按年龄由大到小进行排序

 ArrayList<Student> students = new ArrayList<>();
        students.add(new Student("zx",28,8000));
        students.add(new Student("zr",29,8500));
        students.add(new Student("zt",25,8000));
        students.add(new Student("zy",35,10000));
        students.add(new Student("zu",22,6000));
        
        //默认升序排列，使用reversed()达到降序效果
        students.stream().sorted(Comparator.comparing(Student::getAge).reversed()) 
                         .forEach(System.out::println);

通过Comparator.thenComparing(Comparator<? super T> other) 实现多字段排序
说明：统计学生毕业后薪资，将同学按年龄由小到大进行排序，年龄相等时，按薪资升序排序

 students.stream().sorted(Comparator.comparing(Student::getAge).thenComparing(Student::getSalary))
                         .forEach(System.out::println);

去重distinct

哈哈不要找了，MySQL里的，不是集合的方法（那么jdk1.7没Stream去重复怎么做？）

迭代器去重，HashSet去重？哈哈都不错，但Stream出现了

distinct()方法通过流元素的hashCode和equals方法去除重复元素

 ArrayList<Student> students = new ArrayList<>();
        students.add(new Student("zx",25,8000));
        students.add(new Student("zx",25,8000));
        students.add(new Student("zt",35,10000));
        students.add(new Student("zt",35,10000));
        students.add(new Student("zu",22,6000));

        students.stream().distinct()
                         .forEach(System.out::println);

在Student类中增加hashCode()和equals()方法

@Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age &&
                salary == student.salary &&
                Objects.equals(name, student.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age, salary);
    }

迭代 forEach

forEach 迭代流中的每个数据，即对每个数据进行最后的处理（比如保存到数据库中或打印）

// 输出 10 个随机数 
Random random = new Random();
random.ints().limit(10).forEach(System.out::println);

聚合Collectors

Collectors 类实现了归约操作，例如将流转换成集合和聚合元素，可用于返回列表或字符串

Stream转化为List

 List<String> strings = Arrays.asList("aa", "bb", "", "cc", "dd", "ee", "", "ff");
        List<String> res = strings.stream()
                                  .filter(string -> !string.isEmpty())
                                  .collect(Collectors.toList());
        System.out.println(res);

Stream转化为Set

1  List<String> strings = Arrays.asList("aa", "bb", "", "bb", "dd", "dd", "", "aa");
2         Set<String> res = strings.stream()
3                                   .filter(string -> !string.isEmpty())
4                                   .collect(Collectors.toSet());
5         System.out.println(res);

Stream转化为String

List<String> strings = Arrays.asList("aa", "bb", "bb");
        String collect = strings.stream()
                                .filter(string -> !string.isEmpty())
                                .collect(Collectors.joining("qq","cc","oo"));
        System.out.println(collect);

结果：

ccaaqqbbqqbboo

joining参数说明：

第一个参数(delimiter)：在每一个元素后追加的元素
第二个参数(prefix)：在转化后的整个字符串首部追加的元素
第三个参数(suffix)：在转化后的整个字符串尾部追加的元素

统计SummaryStatistics

收集最终产生的统计结果，它们主要用于int，double，long等基本类型上

1  List<Integer> integerList = Arrays.asList(3, 2, 3, 4, 7, 9);
2         IntSummaryStatistics statistics = integerList.stream()
3                                                      .mapToInt((x) -> x)
4                                                      .summaryStatistics();
5         System.out.println("列表中最大的数 : " + statistics.getMax());
6         System.out.println("列表中最小的数 : " + statistics.getMin());
7         System.out.println("所有数之和 : " + statistics.getSum());
8         System.out.println("平均数 : " + statistics.getAverage());

结果：

列表中最大的数是：9

列表中最小的数是：2

所有数之和是：28

平均数：4.666666666666667

Java 序列化

Java 提供了一种对象序列化的机制，该机制中，一个对象可以被表示为一个字节序列，该字节序列包括该对象的数据、有关对象的类型的信息和存储在对象中数据的类型。将序列化对象写入文件之后，可以从文件中读取出来，并且对它进行反序列化，也就是说，对象的类型信息、对象的数据，还有对象中的数据类型可以用来在内存中新建对象。整个过程都是 Java 虚拟机（JVM）独立的，也就是说，在一个平台上序列化的对象可以在另一个完全不同的平台上反序列化该对象（跨平台）。

如何判断

1、该类必须实现 java.io.Serializable 接口。

2、该类的所有属性必须是可序列化的。如果有一个属性不是可序列化的，则该属性必须注明是短暂的。

常见例子

 1 import java.io.Serializable;
 2  
 3 public class User implements Serializable {
 4     private static final long serialVersionUID = 1L;
 5     public String name;
 6     public String sex;
 7     public int number;
 8     public transient int SSN;//SSN是短暂的
 9  
10     public String getName() {
11         return name;
12     }
13  
14     public void setName(String name) {
15         this.name = name;
16     }
17  
18     public String getAddress() {
19         return sex;
20     }
21  
22     public void setAddress(String address) {
23         this.sex = address;
24     }
25  
26     public int getNumber() {
27         return number;
28     }
29  
30     public void setNumber(int number) {
31         this.number = number;
32     }
33  
34     public int getSSN() {
35         return SSN;
36     }
37  
38     public void setSSN(int SSN) {
39         this.SSN = SSN;
40     }
41  
42  
43     public String toString(){
44         return "User:"+name+" "+sex+" "+number+" "+SSN;
45     }
46  
47 }

1、private static final long serialVersionUID = 1L;
是不是经常看到却不知道什么意思？

这个序列化ID起着关键的作用，它决定着是否能够成功反序列化！java的序列化机制是通过判断运行时类的serialVersionUID来验证版本一致性的，在进行反序列化时，
JVM会把传进来的字节流中的serialVersionUID与本地实体类中的serialVersionUID进行比较，如果相同则认为是一致的，便可以进行反序列化，否则就会报序列化版本不一致的异常。

当然这个语句也可以不写，Java序列化机制会根据编译时的class自动生成一个serialVersionUID作为序列化版本比较，当我们编写一个类时，随着时间的推移，我们因为需求改动，
需要在本地类中添加其他的字段，这个时候再反序列化时便会出现serialVersionUID不一致，导致反序列化失败。那么如何解决呢？便是在本地类中添加一个“serialVersionUID”变量，值保持不变，便可以进行序列化和反序列化。

2、如果某些数据不需要做序列化，比如上面的SSD？

解决办法：在字段面前加上 transient，这样即使在初始化时设置为111111111，但输出也是int的默认值0；

序列化对象

序列化：即将对象转化为二进制，用于保存，或者网络传输

ObjectOutputStream 类用来序列化一个对象，如下的 SerializeDemo 例子实例化了一个 Employee 对象，并将该对象序列化到一个文件中。该程序执行后，就创建了一个名为 employee.ser 文件。该程序没有任何输出，但是你可以通过代码研读来理解程序的作用。

注意： 当序列化一个对象到文件时，按照 Java 的标准约定是给文件一个 .ser 扩展名。

 1 import java.io.*;
 2  
 3 public class SerializeDemo
 4 {
 5    public static void main(String [] args)
 6    {
 7       Employee e = new Employee();
 8       e.name = "Reyan Ali";
 9       e.address = "Phokka Kuan, Ambehta Peer";
10       e.SSN = 11122333;
11       e.number = 101;
12       try
13       {
14          FileOutputStream fileOut =
15          new FileOutputStream("/tmp/employee.ser");
16          ObjectOutputStream out = new ObjectOutputStream(fileOut);
17          out.writeObject(e);
18          out.close();
19          fileOut.close();
20          System.out.printf("Serialized data is saved in /tmp/employee.ser");
21       }catch(IOException i)
22       {
23           i.printStackTrace();
24       }
25    }
26 }

此时我们打开跟目录employee.ser文件，发现里面的东西是乱码形式，我们看不懂，这是正常的，这是生成的二进制文件，计算机可以看懂就可以了；

反序列化对象

反序列化：与序列化相反，将二进制转化成对象。

下面的 DeserializeDemo 程序实例了反序列化，/tmp/employee.ser 存储了 Employee 对象。

 1 import java.io.*;
 2  
 3 public class DeserializeDemo
 4 {
 5    public static void main(String [] args)
 6    {
 7       Employee e = null;
 8       try
 9       {
10          FileInputStream fileIn = new FileInputStream("/tmp/employee.ser");
11          ObjectInputStream in = new ObjectInputStream(fileIn);
12          e = (Employee) in.readObject();
13          in.close();
14          fileIn.close();
15       }catch(IOException i)
16       {
17          i.printStackTrace();
18          return;
19       }catch(ClassNotFoundException c)
20       {
21          System.out.println("Employee class not found");
22          c.printStackTrace();
23          return;
24       }
25       System.out.println("Deserialized Employee...");
26       System.out.println("Name: " + e.name);
27       System.out.println("Address: " + e.address);
28       System.out.println("SSN: " + e.SSN);
29       System.out.println("Number: " + e.number);
30     }
31 }

这里要注意以下要点：

readObject() 方法中的 try/catch代码块尝试捕获 ClassNotFoundException 异常。对于 JVM 可以反序列化对象，它必须是能够找到字节码的类。如果JVM在反序列化对象的过程中找不到该类，则抛出一个 ClassNotFoundException 异常。

注意，readObject() 方法的返回值被转化成 Employee 引用。

当对象被序列化时，属性 SSN 的值为 111222333，但是因为该属性是短暂的，该值没有被发送到输出流。所以反序列化后 Employee 对象的 SSN 属性为 0。

posted @ 2023-03-27 11:32 这里那里阅读(547) 评论(0) 收藏举报

刷新页面返回顶部

"这里那里"