笔记1

最新推荐文章于 2024-02-29 22:22:55 发布

方长很方

最新推荐文章于 2024-02-29 22:22:55 发布

阅读量137

点赞数

本文链接：https://blog.csdn.net/AB__C/article/details/107429035

版权

1. 属性集

概述：
java.util.Properties 继承于Hashtable，来表示一个持久的属性集。它使用键值结构存储数据，每个键及其对应值都是一个字符串。该类也被许多Java类使用，比如获取系统属性时，System.getProperties 方法就是返回一个 Properties 对象。

1.1 Properties类

属性列表中每个键的对应值都是一个字符串，Properties集合是一个双列集合，key和value默认都是字符串。

构造方法:

public Properties()：创建一个空的属性列表。

基本的存储方法：

public Object setProperty(String key, String value)：保存一对属性，调用Hashtable的方法put。
public String getProperty(String key)：使用此属性列表中指定的键搜索属性值，此方法相当于Map集合中的方法get(key)。
public Set< String> stringPropertyNames()：返回所有键的名称的集合，相当于keySet方法。

Properties集合是唯一和IO流相结合的集合。

使用Properties集合中的方法store，把集合中的临时数据，持久化写入到硬盘中存储；

方法：

void store(Outputstream out, String comments)
void store(Writer writer, String comments)

参数：

Outputstream out,：字节输出流，不能写入中文；
Writer writer：字符输出流，可以写中文；
String comments：注释，可以解释说明保存的文件是做什么用的，不能使用中文，会产生乱码，默认是Unicode编码，一般使用空字符串。

使用Properties集合中的方法load，把硬盘中保存的文件（键值对），读取到集合中使用。

方法：

void load(InputStream inStream)
void load(Reader reader)

参数：

InputStream inStream：字节输入流，不能读取含有中文的键值对；
Reader reader：字符输入流，可以读取含有中文的键值对

注意：

存储键值对的文件中，键与值默认的链接符号可以使用=，空格(其他符号)；
存储键值对的文件中，可以使用#进行注释，被注释的键值对不会再被读取；
存储键值对的文件中，键与值默认都是字符串，不用再加引号。

public class DemoProperties {
    public static void main(String[] args) throws IOException {
        show03();
    }

    private static void show03() throws IOException {
        //创建Properties集合对象
        Properties prop = new Properties();
        //使用load读取保存键值对的文件
        prop.load(new FileReader("D:\\wenjian\\a.txt"));
        //遍历集合
        Set<String> set = prop.stringPropertyNames();
        for (String key: set) {
            String value = prop.getProperty(key);
            System.out.println(key + "=" + value);
        }
    }

    private static void show02() throws IOException {
        //创建Properties集合对象,添加数据
        Properties prop = new Properties();
        prop.setProperty("猪猪侠", "15");
        prop.setProperty("小菲菲", "14");
        prop.setProperty("超人强", "16");
        //2. 创建字节输出流/字符输出流对象
        FileWriter fw = new FileWriter("D:\\wenjian\\a.txt");
        //3. 使用Properties集合中的方法store，把集合中的临时数据，持久化写入到硬盘中存储
        prop.store(fw, " ");
        //4. 释放资源
        fw.close();
    }

    private static void show01() {
        //创建Properties集合对象
        Properties prop = new Properties();
        //使用setProperty往集合中添加数据
        prop.setProperty("猪猪侠", "15");
        prop.setProperty("小菲菲", "14");
        prop.setProperty("超人强", "16");
        //使用stringPropertyNames把集合中的键取出
        Set<String> set = prop.stringPropertyNames();
        for (String key: set) {
            String value = prop.getProperty(key);
            System.out.println(value);
        }
    }
}

2. 缓冲流

在读写数据时，让数据在缓冲区能够减少系统实际对原始数据来源的存取次数，因为一次能做多个数据单位的操作。使用缓冲区的流，一般都会比没有缓冲区的流效率更高。
缓冲流把数据从原始流成块读入或把数据积累到一个大数据块后再成批写出，通过减少资源的读写次数来加快程序的执行。

2.1 缓冲流的原理

在这里插入图片描述

2.2 BufferedInputStream字节缓冲输入流 & BufferedOutputStream字节缓冲输出流

java.io.BufferedOutputStream extends OutputStream

构造方法：

BufferedOutputStream(OutputStream out)：创建一个新的缓冲输出流，以将数据写入指定的基础输出流。
BufferedOutputStream(OutputStream out, int size)：创建一个新的缓冲输出流，以将具有指定缓冲区大小的数据写入指定的基础输出流。

参数：

OutputStream out：字节输出流，我们传递FileOutputStream，缓冲流会给FileOutputStream增加一个缓冲区，提高FileOutputStream的写入效率；
int size：指定缓冲流内部缓冲区的大小，不指定默认。

public class DemoBufferedOutputStream {
    public static void main(String[] args) throws IOException {
        //1. 创建FileOutputStream对象
        FileOutputStream fos = new FileOutputStream("D:\\wenjian\\a.txt");
        //2. 创建BufferedOutputStream对象，构造方法中传递fos，提高效率
        BufferedOutputStream bos = new BufferedOutputStream(fos);
        //3. 使用write，把数据写入到内部缓冲区
        bos.write("把数据写入到内部缓冲区".getBytes());
        //4. 把内部缓冲区的数据刷新到文件中
        bos.flush();
        //5. 释放资源
        bos.close();
    }
}

java.io.BufferedInputStream extends InputStream

构造方法：

BufferedInputStream(InputStream in)：创建 BufferedInputStream 并保存其参数，即输入流 in，以便将来使用。
BufferedInputStream(InputStream in, int size)：创建具有指定缓冲区大小的 BufferedInputStream，并保存其参数，即输入流 in，以便将来使用。

参数：

InputStream in：字节输入流，我们传递FileInputStream，缓冲流会给FileInputStream增加一个缓冲区，提高FileInputStream的读取效率；
int size：指定缓冲流内部缓冲区的大小，不指定默认。

public class DemoBufferedInputStream {
    public static void main(String[] args) throws IOException {
        //1. 创建FileInputStream对象
        FileInputStream fis = new FileInputStream("D:\\wenjian\\a.txt");
        //2. 创建BufferedInputStream对象，构造方法中传递fos，提高效率
        BufferedInputStream bis = new BufferedInputStream(fis);
        //3. 使用read，读取文件
        /*
        int len = 0; //记录每次读取到的字节
        while((len = bis.read()) != -1){
            System.out.println(len);
        }
        */
        byte[] b = new byte[1024];
        int len = 0;
        while((len = bis.read(b)) != -1){
            System.out.println(new String(b,0,len));
        }
        //4. 释放资源
        bis.close();
    }
}

2.3 BufferedWriter字符缓冲输入流 & BufferedReader字符缓冲输出流

java.io.BufferedWriter extends Writer

构造方法：

BufferedWriter(Writer out)：创建一个使用默认大小输出缓冲区的缓冲字符输出流。
BufferedWriter(Writer out, int sz)：创建一个使用指定大小输出缓冲区的新缓冲字符输出流。

参数：

Writer Out：字符输出流，我们传递FileWriter，缓冲流会给FileWriter增加一个缓冲区，提高FileWriter的写入效率；
int sz：指定缓冲区的大小，不写默认大小

特有的成员方法：
void newLine()：写入一个行分隔符，会根据不同的操作系统，获取不同的行分隔符

public class DemoBufferedWriter {
    public static void main(String[] args) throws IOException {
        //创建字符缓冲流对象
        BufferedWriter bw = new BufferedWriter(new FileWriter("D:\\wenjian\\a.txt"));
        //调用write，把数据写入到内存缓冲区中
        for (int i = 0; i < 5; i++) {
            bw.write("数据写入");
            bw.newLine(); //相当于bw.write("\r\n");
        }
        bw.flush();
        bw.close();
    }
}

java.io.BufferedReader extends Reader

构造方法：

BufferedReader(Reader in)：创建一个使用默认大小输入缓冲区的缓冲字符输入流
BufferedReader(Reader in, int sz)：创建一个使用指定大小输入缓冲区的缓冲字符输入流。

参数： Reader In：字符输出流，我们传递FileReader，缓冲流会给FileReader增加一个缓冲区，提高FileReader的写入效率；

特有的成员方法：
String readLine()：读取一个文本行。通过下列字符之一即可认为某行已终止，换行（‘\n’）、回车（’\r’）或回车后直接跟着换行。返回值为包含该行内容的字符串，不包含任何终止符，如果已经到达流末尾，则返回null。

public class DemoBufferedReader {
    public static void main(String[] args) throws IOException {
        //创建字符缓冲输入流对象
        BufferedReader br = new BufferedReader(new FileReader("D:\\wenjian\\a.txt"));
        //使用read/readLine读取文本
        String line;
        while((line = br.readLine()) != null){
            System.out.println(line);
        }
        br.close();
    }
}

3. 转换流

3.1 字符编码和字符集

在这里插入图片描述
概念：

字符集：就是某些特定字符的集合，如果把世界上不同国家文明的所有字符都放在一起组成一个集合，那么我们常见的 ASCII、GB2312、GBK、GB18030、BIG5 字符集都只是包含了该集合的一部分而已。而 Unicode 字符集是可以包含所有国家文明中的所有字符的。
字符编码：所有的文件在计算机中最终是以二进制序列来保存的，不同的序列就可以表示不同的内容。字符编码的目的就是对不同的字符编码设计合理的唯一二进制序列在计算机中进行存储表示。

3.2 编码引出的问题-FileReader读取GBK格式的文件

在IDEA中，使用FileReader读取项目中的文本文件。由于IDEA的设置，都是默认的UTF-8编码，所以没有任何问题。但是，读取Windows系统中创建的文本文件时，由于Windows系统默认的是GBK编码，就会出现乱码。

解决方法：
在这里插入图片描述

3.3 OutputStreamWriter

java.io.OutputStreamWriter extends Writer

OutputStreamWriter：是字符流通向字节流的桥梁，可使用指定的charset将要写入流中的字符编码成字节。

构造方法：

OutputStreamWriter(OutputStream out)：根据默认编码把字节流的数据转换为字符流
OutputStreamWriter(OutputStream out,String charsetName)：根据指定编码把字节流数据转换为字符流

参数：

OutputStream out：字节输出流，可以用来写转换之后的字节到文件中；
String charsetName：指定的编码表名称，不区分大小写，不指定默认使用UTF-8。

public class DemoOutputStreamWriter {
    public static void main(String[] args) throws IOException {
        //创建OutputStreamWriter对象
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("D:\\wenjian\\a.txt"), "utf-8");
        //使用write，把字符转化为字节存储在缓存区中
        osw.write("字符转换为字节");
        osw.flush();
        osw.close();
    }
}

3.4 InputStreamReader

java.io.OutputStreamReader extends Reader

InputStreamReader：是字节流通向字符流的桥梁，可使用指定的charset读取字节并将其解码为字符。

构造方法：

InputStreamReader(InputStream in)：创建一个默认编码集的InputStreamReader；
InputStreamReader(InputStream in,String charsetName)：创建一个指定编码集的InputStreamReader。

参数： InputStream in：字节输入流，用来读取文件中保存的字节。

注意事项： 构造方法中指定的编码表名称要和文件的编码相同，否则会产生乱码。

public class DemoInputStreamReader {
    public static void main(String[] args) throws IOException {
        InputStreamReader isr = new InputStreamReader(new FileInputStream("D:\\wenjian\\a.txt"), "utf-8");
        //使用read读取文件
        int len = 0;
        while((len = isr.read()) != -1){
            System.out.println((char)len);
        }
        isr.close();
    }
}

4. 序列化

序列化： 指堆内存中的java对象数据，通过某种方式把对存储到磁盘文件中，或者传递给其他网络节点。这个过程称为序列化，通常是指将数据结构或对象转化成二进制的过程。

反序列化： 把磁盘文件中的对象数据或者把网络节点上的对象数据，恢复成Java对象模型的过程。也就是将在序列化过程中所生成的二进制串转换成数据结构或者对象的过程

注意事项：

静态变量不会被序列化。
当一个父类实现序列化，子类自动实现序列化。
当一个对象的实例变量引用其他对象，序列化该对象时也把引用对象进行序列化。

4.1 对象的序列化-ObjectOutputStream

java.io.ObjectOutputStream extends OutputStream

构造方法： ObjectOutputStream(OutputStream out)：创建写入指定OutputStream的ObjectOutputStream。

特有的成员方法： void writeObject(Object obj)：将指定的对象写入ObjectOutputStream。

类通过实现Serializable接口以启用其序列化功能，未实现此接口的类无法使其任何状态序列化和反序列化

public class Person implements Serializable {
    private String name;
    private int age;
    ...
}

public class DemoObjectOutputStream {
    public static void main(String[] args) throws IOException {
        //创建ObjectOutputStream对象，构造方法中传递字节输出流
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("D:\\wenjian\\a.txt"));
        //使用writeObject将对象写入到文件中
        oos.writeObject(new Person("猪猪侠",18));
        oos.close();
    }
}

4.2 对象的反序列化-ObjectInputStream

java.io.ObjectInputStream extends InputStream

构造方法： ObjectInputStream(InputStream in)：创建从指定InputStream读取的ObjectInputStream。

特有的成员方法： Object readObject()：从ObjectInputStream读取对象。

public class DemoObjectInputStream {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("D:\\wenjian\\a.txt"));
        //使用readObject读取保存对象中的文件
        Object o = ois.readObject();
        ois.close();
        System.out.println(o);
    }
}

反序列化的前提：

类必须实现Serializable；
必须存在类对应的class文件。

另外，当JVM反序列化对象时，能找到class文件，但是class文件在序列化对象之后发生了修改，那么反序列化操作会失败，抛出异常

解决方案：private static final long serialVersionUID = 5L(随便写，序列号)；

4.3 transient关键字

transient关键字：瞬态关键字，被transient修饰的成员变量，不能被序列化。和static静态关键字的功能差不多，但是没有静态的含义。

5. 打印流

java.io.PrintStream：打印流，为其他输出流添加了功能，使他们能够方便的打印各种数据值表示形式。

PrintStream extends OutputStream

特点：

只负责数据的输出，不负责数据的读取。
与其他输出流不同，PrintStream永远不会抛出IOException。
有特有的方法void print(任意类型的值）、void println(任意类型的值并换行)。

构造方法：

printWriter(File file)：输出的目的地是一个文件；
printWriter(String filename)：输出的目的地是一个文件路径；
printWriter(OutputStream out)：输出的目的地是一个字节输出流。

注意： 如果使用继承自父类的write方法写数据，那么查看数据的时候会查询编码表，即97->a;如果使用自己特有的方法print/println方法写数据，那么数据原样输出，即97->97。

public class DemoPrintStream {
    public static void main(String[] args) throws FileNotFoundException {
        PrintStream ps = new PrintStream("D:\\wenjian\\a.txt");
        ps.write(97);
        ps.println(97);
        ps.close();
    }
}

还可以改变输出语句的目的地（打印流的流向），输出语句默认在控制台输出。

public class DemoPrintStream {
    public static void main(String[] args) throws FileNotFoundException {
        System.out.println("在控制台输出");
        PrintStream ps = new PrintStream("D:\\wenjian\\a.txt");
        //使用System.setOut方法将输出语句的目的地改为参数中传递的打印流的目的地
        System.setOut(ps);
        System.out.println("在打印流的目的地输出");
        ps.close();
    }
}