Java进阶之属性集&缓冲流&转换流&序列化流&打印流

最新推荐文章于 2024-07-08 14:58:49 发布

Williamsgogogo

最新推荐文章于 2024-07-08 14:58:49 发布

阅读量113

点赞数

分类专栏： java进阶文章标签： java

本文链接：https://blog.csdn.net/tysearch/article/details/116352513

版权

java进阶专栏收录该内容

18 篇文章 0 订阅

订阅专栏

一、IO流的异常处理

1.1 jdk7之前的异常处理

/*
    JDK7之前IO流的异常处理
 */
public class Demo01Exception {
    public static void main(String[] args) {
        Writer w = null;
        try {
            //创建字符输出流对象
            w = new FileWriter("iotest\\file01.txt");
            //写数据
            w.write("你好");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                //必须流对象创建成功，那么我们才需要释放资源.
                //如果流对象创建成功了，那么w的值不是null
                if (w != null) {
                    //释放资源
                    w.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

1.2 jdk7的异常处理

在JDK7的时候，多了一种try...with...resource的语句，可以十分方便的处理IO流中的异常。

try...with...resource就是一种特殊的try..catch语句。

格式：
        try(创建流对象的代码) {
            ...
        } catch(异常类名 变量名) {
            ...
        }

作用：在try后面小括号中创建的流对象，无论如何都会自动调用close方法。

注意：

在try后面小括号中可以创建多个流对象，多个流对象之间使用分号隔开

public class Demo02Exception {
    public static void main(String[] args) {
        try (Writer w = new FileWriter("iotest\\file02.txt")) {
            //写数据
            w.write("你好");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

二、Properties

Properties是双列集合，叫做属性集。

特点：

Properties实现Map接口，拥有Map接口中的所有的方法
Properties没有泛型，里面的键和值都是字符串
Properties支持和流一起操作，可以从流中加载键值对【从文件中读取键值对】

2.1 Properties的方法

构造方法：

Properties()：创建的是不包含任何元素的Properties集合

常用成员方法：

Object setProperty(String key, String value)：添加键值对元素
String getProperty(String key)：根据键获取值
Set<String> stringPropertyNames()：获取Properties中所有的键并放入到Set集合中返回

public class Demo01Properties {
    public static void main(String[] args) {
        //创建Properties集合
        Properties p = new Properties();
        //Object setProperty(String key, String value)：添加键值对元素。
        p.setProperty("it001", "jack");
        p.setProperty("it002", "rose");
        p.setProperty("it003", "tony");
        //输出结果
        System.out.println(p);
        //String getProperty(String key)：根据键获取值。
        System.out.println("it001对应的值：" + p.getProperty("it001"));
        System.out.println("=================================");
        //Set<String> stringPropertyNames()：获取Properties中所有的键并放入到Set集合中返回。
        Set<String> set = p.stringPropertyNames();
        //遍历Properties集合
        for (String s : set) {
            System.out.println(s + "-" + p.getProperty(s));
        }
    }
}

2.2 Properties从文件读取键值对

Properties中和流相关的方法。

void load(InputStream inStream)：参数要传递字节输入流
void load(Reader reader)：参数要传递字符输入流

load方法可以将文件中的键值对读取【加载】到Properties中

Properties集合操作的文件是有要求的：

文件一般以.properties结尾【.properties文件一般叫做配置文件】（软性要求）
文件中的键值对必须按照下面格式保存（硬性规定）
键=值
键=值
键=值

Properties集合读取文件中键值对的步骤：

创建Properties集合
创建输入流对象
调用load方法，传递输入流对象，将文件中的键值对读取到Properties集合
释放资源

public class Demo02Properties {
    public static void main(String[] args) throws IOException {
        //1. 创建Properties集合。
        Properties p = new Properties();
        //2. 创建输入流对象。
        InputStream is = new FileInputStream("iotest\\config01.properties");
        //3. 调用load方法，传递输入流对象，将文件中的键值对读取到Properties集合
        p.load(is);
        System.out.println(p);
        //4. 释放资源。
        is.close();
		
		//创建输入流对象
		Reader r = new FileReader("iotest\\config01.properties");
		//调用load方法，传递输入流对象，将文件中的键值对读取到Properties集合
		p.load(r);
		System.out.println(p);
		//释放资源。
        r.close();
    }
}

三、缓冲流

使用普通流操作数据存在效率太低的问题。

缓冲流的特点是效率高，缓冲流可以起到加速的作用。

缓冲流本身并不具备读或者写的功能，缓冲流的主要作用是对其他流进行加速，因为缓冲流内部有一个数组作为了缓冲区，所以可以加速。

字节缓冲流

字节输入缓冲流：BufferedInputStream
字节输出缓冲流：BufferedOutputStream

字符缓冲流

字符输入缓冲流：BufferedReader
字符输出缓冲流：BufferedWriter

3.1 字节缓冲流

字节缓冲流的构造方法：

BufferedInputStream(InputStream in): 参数要传递字节输入流
BufferedOutputStream(OutputStream out)：参数要传递字节输出流

字节缓冲流中读写的方法：

字节缓冲流是属于字节流的，所以里面读写的方法和之前字节流读写的方法一模一样

字节缓冲流的使用步骤：

创建字节缓冲流
读或写
释放资源

public class Demo02BufferedStream {
    public static void main(String[] args) throws IOException {
        //创建字节缓冲输入流
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("iotest\\aa.jpg"));
        //创建字节缓冲输出流
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("iotest\\bb.jpg"));
        //记录时间
        long start = System.currentTimeMillis();
        //定义变量，用来接收读取到的字节
        int i;
        //开始循环
        while ((i = bis.read()) != -1) {
            bos.write(i);
        }
        //记录时间
        long end = System.currentTimeMillis();
        System.out.println(end - start);//42
        
        //记录时间
        start = System.currentTimeMillis();
        //定义数组，用来保存读取到的数据
        byte[] bArr = new byte[1024];
        //定义变量表示读取到的字节个数
        int len;
        while((len = bis.read(bArr) != -1) {
        	bos.write(bArr,0,len);
        }

		//记录时间
		end = System.currentTimeMillis();
		System.out.println(end - start);//0
        //释放资源
        bos.close();
        bis.close();
    }
}

3.2 字符缓冲流

字符缓冲流构造方法：

BufferedReader(Reader in)：参数要传递字符输入流
BufferedWriter(Writer out)：参数要传递字符输出流

字符缓冲流读写的方法：

字符缓冲流是字符流，里面读写的方法和之前字符流的读写方法一模一样
BufferedWriter中有一个方法可以实现跨平台的换行
void newLine():一个跨平台的换行符
BufferedReader中有一个方法可以读取一行数据：
String readLine()：读取一行数据并返回，如果已经读取结束了，返回null值。
【注意：readLine不会读取换行符，只能读取换行符之前的内容】

字符缓冲流的使用步骤：

创建流
读或写
关闭流
【如果是字符输出流，需要刷新】

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

    /*
        String readLine()：读取一行数据并返回，如果已经读取结束了，返回null值。
     */
    public static void method2() throws IOException {
        //创建字符输入缓冲流
        BufferedReader br = new BufferedReader(new FileReader("day11\\file03.txt"));
        //使用循环读取
        //定义变量，用来保存每次读取到的一行数据
        String line;
        //开始循环
        /*
            条件位置做了哪些事情
                1. 通过字符输入缓冲流调用readLine方法读取一行数据。
                2. 将读取到的这行数据赋值给了变量line
                3. 判断line是否不等于null，如果line不是null，表示读取到了数据，就进行处理。
         */
        while ((line = br.readLine()) != null) {
            System.out.println(line);
        }
         //释放资源
        br.close();
	}
 	/*
        void newLine():一个跨平台的换行符
     */
    public static void method() throws IOException {
        //创建流对象
        BufferedWriter bw = new BufferedWriter(new FileWriter("day11\\file03.txt"));
        //写数据
        bw.write("窗含西岭千秋雪");
        //void newLine():一个跨平台的换行符
        bw.newLine();
        bw.write("门泊东吴万里船");
        //关流
        bw.close();
    }
}

四、转换流

编码和解码：

编码：字符 -> 字节
解码；字节 -> 字符

4.1 编码表

编码表（字符集）：字节和字符的对应关系表

编码表	每个字符占的字节数	内容	备注
ACSII码表	1	有128个英文字母数字以及标点符号
ISO8859-1(Latin)码表	1	有256个内容，包含了ASCII码表以及拉丁文
GB2312(1980)码表	1/2	支持六千多个汉字或者字符，包含了ASCII码表	汉字占2个字节
BIG5码表	1/2	支持繁体字，包含了ASCII码表	汉字占2个字节
GBK码表	1/2	支持两万多汉字或者字符，包含了ASCII码表	汉字占2个字节
Unicode国际标准码表	2	保存任何国家的任何语言	在unicode8.0版本，可以保存emoji
UTF-32	4	万国码
UTF-16	2/3/4	万国码
UTF-8	1/2/3/4	万国码	汉字占3个字节

在IDEA中，使用的默认编码是UTF-8

在windows中，使用的默认编码是UTF-8（最近win10更新，新版本的win10默认编码已经变成utf-8，如果没有更新，默认是GBK）

4.2 字符流读取乱码问题

当我们使用FileReader读取采用GBK编码的文件中的数据到idea中，会出现乱码现象。

这是因为文件采用的是GBK编码，而FileReader会采用idea默认的编码UTF-8进行读取，此时两个编码不一致，就引发了乱码问题。

如果想要读取GBK编码的文件，那么可以指定编码读取，如果要指定编码，需要使用转换流。

4.3 转换流指定编码读取

InputStreamReader是转换流，用来读取，可以【按照指定编码】将文件中的数据读取Java程序中。

InputStreamReader是字符流，可以以字符为单位进行读取。

InputStreamReader的构造方法：

InputStreamReader(InputStream in)：参数要传递字节输入流，使用这个构造方法创建的流将来会采用idea默认编码进行读取
InputStreamReader(InputStream in, String charsetName)：第一个参数是字节输入流，第二个参数是指定的编码方式，会采用指定的编码方式读取

InputStreamReader的读取方法：

InputStreamReader是字符流，所以里面读取方法的方法和字符流读取的方法是一模一样的

InputStreamReader使用步骤：

创建流
读数据
关闭流

注意：
使用转换流指定编码时，如果指定的编码不存在，那么会报错。

public class Demo02InputStreamReader {
    public static void main(String[] args) throws IOException {
        //readGBK();
        readUTF8();
    }

    /*
        读取UTF-8文件的数据
     */
    public static void readUTF8() throws IOException {
        //创建流
        InputStreamReader isr = new InputStreamReader(new FileInputStream("d:\\file02-utf8.txt"), "utf-8");
        //读取
        int i;
        while ((i = isr.read()) != -1) {
            System.out.print((char) i);
        }
        //释放资源
        isr.close();
    }


    /*
        读取GBK文件的数据
     */
    public static void readGBK() throws IOException {
        //1. 创建流，指定编码
        InputStreamReader isr = new InputStreamReader(new FileInputStream("d:\\file01-gbk.txt"), "gbk");
        //2. 读取数据
        int i;
        while ((i = isr.read()) != -1) {
            System.out.print((char) i);
        }
        //3. 释放资源
        isr.close();
    }
}

4.4 转换流指定编码写

OutputStreamWriter是转换流，用来写，可以【指定编码】将Java程序中的数据写到文件中。

OutputStreamWriter属于字符流，会以字符为单位写数据。

OutputStreamWriter构造方法：

OutputStreamWriter(OutputStream out)：参数要传递字节输出流，使用该构造方法创建的转换流将来会以idea默认编码去写数据
OutputStreamWriter(OutputStream out, String charsetName)：第一个参数是字节输出流；第二个参数是指定的编码方式,会按照指定编码写数据

OutputStreamWrite写数据方法：

OutputStreamWriter属于字符流，里面写数据的方法和之前的字符流写数据的方法一模一样

OutputStreamWriter使用步骤：

创建转换流，指定编码
调用write方法写数据
刷新
关流

public class Demo03OutputStreamWriter {
    public static void main(String[] args) throws IOException {
//        writeGBK();
        writeUTF8();
    }

    //向文件中写UTF-8编码的数据
    public static void writeUTF8() throws IOException {
        //创建OutputStreamWriter对象，并指定编码
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("d:\\file04-utf8.txt"), "utf-8");
        //写数据
        osw.write("你好");
        //刷新
        osw.flush();
        //释放资源
        osw.close();
    }

    //向文件中写入GBK编码的数据
    public static void writeGBK() throws IOException {
        //创建OutputStreamWriter对象，并指定编码
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("d:\\file03-gbk.txt"), "gbk");
        //写数据
        osw.write("你好");
        //刷新
        osw.flush();
        //释放资源
        osw.close();
    }
}

五、序列化流

5.1 序列化概述

在这里插入图片描述

5.2 序列化流的使用

ObjectOutputStream是序列化流，可以将Java程序中的对象写到文件中。

ObjectOutputStream构造方法：

ObjectOutputStream(OutputStream out)：参数要传递一个字节输出流

ObjectOutputStream写对象的方法【特有方法】：

void writeObject(Object obj)：将对象写到文件

ObjectOutputStream的使用步骤：

创建流
写对象
释放资源

向文件中写的对象必须要实现Serializable接口，Serializable里面什么都没有，仅仅起到标记作用。

public class Demo01ObjectOutputStream {
    public static void main(String[] args) throws IOException {
        //1. 创建流
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("iotest\\file04.txt"));
        //2. 写Person对象
        Person p = new Person("张三丰", 100);
        oos.writeObject(p);
        //3. 关闭流
        oos.close();
    }
}

5.3 反序列化的使用

ObjectInputStream是反序列化流，可以将文件中的对象读取到Java程序中。

ObjectInputStream构造方法：

ObjectInputStream(InputStream in)：参数要传递字节输入流

ObjectInputStream读取对象的方法【特有方法】：

Object readObject()：从文件中读取对象

ObjectInputStream使用步骤：

创建反序列化流
读取对象
释放资源

注意事项：如果使用反序列化流读取对象时，对象所属的类不存在，那么会报错。

public class Demo02ObjectInputStream {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //1. 创建反序列化流
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("iotest\\file04.txt"));

        //2. 读取对象
        Object obj = ois.readObject();
        System.out.println(obj);
        //Person p = (Person) obj;
        //System.out.println(p.getName() + "-" + p.getAge());

        //3. 释放资源
        ois.close();
    }
}

5.4 序列化中的static和transient

被static修饰的属性不能被序列化。被static修饰的属性属于类，不属于对象，而序列化操作写的是对象。
如果我们不希望某个属性被序列化，同时不希望使用static关键字，那么可以使用transient。

5.5 序列化中的序列号

Serializable这个接口中没有任何的方法。

这个接口只是起到一个标记作用，必须实现这个接口后，该类的对象才具备序列化的功能，才可以写到文件中。

对象中的版本号这个属性值是通过类中的内容计算得出的，如果类发生改变，版本号就会改变。

当从文件中读取对象时，会对比文件中保存的版本号和class文件中的版本号是否一致，如果不一致，就会报错。

如果要解决版本号冲突问题，我们可以给类固定一个版本号，不管该类怎么修改，版本号都不变。这样就解决了问题。

我们可以在类中提供一个常量，该常量表示类的版本号。
要求：

private static final 修饰
long类型的
必须叫做serialVersionUID

public class Person implements Serializable{
    private String name;
    private /*static*/ /*transient*/ int age;

    //给类固定一个版本号，不管这个类怎么修改，版本号(序列号)永远是1
    private static final long serialVersionUID = 1L;

	get...set...构造方法...toString
}

六、打印流

打印流的特点：

只有输出（写），没有输入（读）
写数据十分的方便

PrintStream构造方法：

PrintStream(String fileName)：参数要传递字符串的文件路径
PrintStream(File file)：参数要传递File对象
PrintStream(OutputStream out)：参数要传递字节输出流

PrintStream特有的写数据的方法：

void print(任何类型)：写任何类型的数据
void println(任何类型)：写任何类型的数据并自动换行

PrintStream的使用步骤：

创建打印流对象
调用方法写数据。
释放资源

public class Demo01PrintStream {
    public static void main(String[] args) throws FileNotFoundException {
        //1. 创建打印流对象
        PrintStream ps = new PrintStream("iotest\\file06.txt");
        //2. 调用方法写数据。
        //void print(任何类型)： 写任何类型的数据。
        //ps.print("你好");
        //ps.print("我好");
        //void println(任何类型)： 写任何类型的数据并自动换行。
        ps.println("你好");
        ps.println("我好");

        //3. 释放资源
        ps.close();
    }
}

七、commons-io

commons-io是由第三方（Apache）提供的IO流操作的工具包。

如果我们要使用第三方的工具包，一般要导入jar包。

jar包其实就是java的压缩包，里面保存了很多class文件。

导入jar包后，可以直接使用里面的内容。

导入jar包的步骤：

新建一个文件夹叫做lib
将jar包复制到lib文件夹下
点lib文件夹右键选择 Add as Library

7.1 commons-io初体验

IOUtils中的方法：

static int copy(InputStream input, OutputStream output)：复制文件，该方法适用于2G以下的文件
static long copyLarge(InputStream input, OutputStream output)复制文件，该方法适用于2G以上的文件

FileUtils中的方法：

static void copyFileToDirectory(File srcFile, File destDir)：将文件(srcFile)复制到一个文件夹(destDir)中
static void copyDirectoryToDirectory(File srcDir, File destDir)：将一个文件夹(srcDir)复制到另一个文件夹(destDir)中
static void writeStringToFile(File file, String data)：向文件中写字符串数据
static String readFileToString(File file)：从文件中读取数据，并返回读取到的内容

Williamsgogogo

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java进阶之属性集&缓冲流&转换流&序列化流&打印流

Java进阶之属性集&缓冲流&转换流&序列化流一、IO流的异常处理1.1 jdk7之前的异常处理1.2 jdk7的异常处理二、Properties2.1 Properties的方法2.2 Properties从文件读取键值对三、缓冲流一、IO流的异常处理1.1 jdk7之前的异常处理/* JDK7之前IO流的异常处理 */public class Demo01Exception { public static void main(String[] args)
复制链接

扫一扫