Java进阶学习10:【字节流、字符流、IO流的异常、Properties集合】

  • A+
所属分类:Java Java进阶

01. 字节输入流一次读取一个字节

/*
    InputStream是字节输入流, 可以将文件中的数据读取到Java程序中。
    InputStream是所有字节输入流的顶层父类, 他是一个抽象类,如果要用,需要使用它的子类,常用的子类是FileInputStream

    FileInputStream构造方法:
        FileInputStream(String name): 参数传递一个字符串类型的文件路径。 表示从这个文件中读取数据。 如果该文件不存在,那么抛出异常。
        FileInputStream(File file): 参数传递一个File类型的文件。 。 表示从这个文件中读取数据。 如果该文件不存在,那么抛出异常。

    常见方法:
        int read(): 从文件中读取一个字节的数据, 并返回读取到的数据。 如果已经读取结束,返回-1
        int read(byte[] b): 将数据读取到字节数组中, 字节数组长度是几,那么就最多一次读取几个。 返回读取到的字节个数, 如果已经读取结束,返回-1

    字节输入流的使用步骤:
        1. 创建FileInputStream字节输入流对象,绑定一个数据源文件。
        2. 调用方法读取数据。
        3. 调用流的close方法,释放资源

    注意: 一次读取一个字节的方式不能读取中文,因为一个中文占多个字节, 会把中文拆开读取。
 */
public class Demo01InputStream {
    public static void main(String[] args) throws IOException {
        //创建FileInputStream字节输入流对象,绑定一个数据源文件。
        InputStream is = new FileInputStream("day10\\source01.txt");

        //使用循环读取数据
        //定义变量i,用来保存每次读取到的字节
        int i;
        /*
            条件位置做了哪些事情
                1. 先使用输入流调用read方法,读取一个字节。
                2. 将读取到的字节赋值给变量i
                3. 判断i是否不等于-1, 如果i不是-1,那么表示真正读取到了数据,那么我们就可以进行处理
                读取到的数据保存到了i中,如果要处理读取到的数据,那么直接操作i即可
         */
        while((i = is.read()) != -1) {
            System.out.print((char)i);
        }

        //调用方法读取数据。
        //会读取一个字节, 并返回读取到的数据
        /*
        int i = is.read();
        System.out.println(i);//97

        //接着读
        i = is.read();
        System.out.println(i);//98

        //接着读
        i = is.read();
        System.out.println(i);//99

        //接着读
        i = is.read();
        System.out.println(i);//-1
        */

        //释放资源
        is.close();
    }
}

02. 字节输入流一次读取一个字节数组

/*
    字节输入流一次读取一个字节数组
         int read(byte[] b): 将数据读取到字节数组中, 字节数组长度是几,那么就最多一次读取几个。 返回读取到的字节个数, 如果已经读取结束,返回-1

    字节输入流的使用步骤:
        1. 创建字节输入流对象
        2. 调用read方法读取数据。
        3. 释放资源

    注意:字节输入流一次读取一个字节数组的方式也不能用于读取中文
 */
public class Demo02InputStream {
    public static void main(String[] args) throws IOException {
        //创建字节输入流对象
        InputStream is = new FileInputStream("day10\\source02.txt");
        //使用循环
        //定义一个byte数组,用来保存每次读取到的字节。
        byte[] bArr = new byte[1024];//数组一般是1024的整数倍, 最快的是1024 * 8
        //定义变量len,用于接收读取到的字节个数
        int len;
        /*
            条件位置做了哪些事情
            1. 调用了read方法,将数据读取到的bArr数组中
            2. 将读取到的字节的个数返回,并赋值给len。
            3. 判断len是否不是-1,如果不是-1,表示读取到了数据,那么就可以进行处理了。
            读取到的数据放在了bArr数组中
         */
        while((len = is.read(bArr)) != -1) {
            //将读取到的数据转成字符串并打印
            //读取到几个数据,就将几个数据转成字符串。
            System.out.print(new String(bArr, 0, len));
        }

        /*
        //调用read方法读取数据,一次读取一个字节数组的方式读取数据。
        //创建byte数组
        byte[] bArr = new byte[2];
        //将数据读取到参数bArr数组中, 因为参数bArr数组长度是2,所以会一次读取两个字节。 返回读取到的字节个数。
        int len = is.read(bArr);
        //输出
        System.out.println(new String(bArr, 0, len)); //ab
        System.out.println(len); //2
        //接着读
        len = is.read(bArr);
        System.out.println(new String(bArr, 0, len)); //cd
        System.out.println(len); //2

        //接着读
        len = is.read(bArr);
        System.out.println(new String(bArr, 0, len)); //e
        System.out.println(len); //1

        //接着读
        len = is.read(bArr);
        System.out.println(new String(bArr)); //ed
        System.out.println(len); //-1
        */
        //释放资源
        is.close();
    }
}

04. 使用字节流复制文件

/*
    文件复制。
    文件复制本质就是读和写, 将源文件中的字节读取出来,然后写到新的文件中即可。

    复制步骤:
        1. 创建一个字节输入流,用来读取
        2. 创建一个字节输出流,用来写。
        3. 开始循环读写。 每读取一次数据,就将读取到的数据写到目的地文件。
        4. 释放资源
 */
public class Demo03FileCopy {
    public static void main(String[] args) throws IOException {
        //创建一个字节输入流,用来读取
        InputStream is = new FileInputStream("d:\\aa.jpg");
        //创建一个字节输出流,用来写。
        OutputStream os = new FileOutputStream("e:\\aa.jpg");
        //开始循环读写。 每读取一次数据,就将读取到的数据写到目的地文件。

        //一次读取一个字节数组,然后将读取到的字节数组复制到目的地文件。
        byte[] bArr = new byte[1024];
        int len;
        while((len = is.read(bArr)) != -1) {
            //如果条件成立,那么就将读取到的数据写到目的地文件。
            //读取到的数据保存在了bArr这个数组中, 返回值len是读取到的个数。
            os.write(bArr, 0, len); //将bArr中的一部分写入到文件,从索引为0的位置开始写, 写len个
        }

        /*
        //一次读取一个字节,然后将读取到的字节写到目的地文件
        int i;//定义变量,用于接收每次读取到的字节
        while ((i = is.read()) != -1) {
            //如果读取到了数据,就将读取到的数据写到目的地文件。
            os.write(i);
        }
        */

        //释放资源
        os.close();
        is.close();
    }
}

05. 使用字符流一次读取一个字符

/*
    Reader是字符输入流, 以字符为单位进行读取, 可以将文件中的数据读取到Java中。
    Reader是所有字符输入流的顶层父类, 是一个抽象类,如果要用,需要用子类, 常用的子类是FileReader

    FileReader的构造方法:
        FileReader(String fileName): 参数要传递一个字符串类型的文件路径,表示从这个文件中读取数据。
        FileReader(File file): 参数要传递一个File的文件,表示从这个文件中读取数据

    FileReader的其他方法:
        int read(): 从文件中读取一个字符并返回,如果已经读取结束了,那么返回-1
        int read(char[] cbuf): 读取数据到字符数组中, 字符数组长度是几,那么就可以一次读取几个。并返回读取到的有效的字符个数。如果已经读取结束了,那么返回-1

   FileReader的使用步骤
        1. 创建字符输入流对象, 绑定一个数据源文件。
        2. 调用read方法,读取数据
        3. 释放资源
 */
public class Demo01Reader {
    public static void main(String[] args) throws IOException {
        //创建字符输入流对象, 绑定一个数据源文件。
        Reader r = new FileReader("day10\\source03.txt");
        //调用read方法,读取数据
        //使用一次读取一个字符的方式读取数据
        int i; //定义变量i,用来接收每次读取到的字符。
        /*
            条件位置做了下面的事情
                1. 使用输入流调用了read方法读取了一个字符。
                2. 将读取到的字符赋值给了变量i
                3. 判断变量i如果不是-1,那么表示读取到了数据,,那么我们就进行处理
         */
        while((i = r.read()) != -1) {
            System.out.print((char)i);
        }

        //释放资源
        r.close();
    }
}

06. 使用字符输入流读取一个字符数组

/*
    使用字符输入流一次读取一个字符数组
         int read(char[] cbuf): 读取数据到字符数组中, 字符数组长度是几,那么就可以一次读取几个。并返回读取到的有效的字符个数。如果已经读取结束了,那么返回-1

    字符输入流读取步骤:
        1. 创建字符输入流对象
        2. 调用read方法进行读取
        3. 调用close方法释放资源
 */
public class Demo02Reader {
    public static void main(String[] args) throws IOException {
        //创建字符输入流对象
        Reader r = new FileReader("day10\\source03.txt");
        //调用read方法进行读取(一次读取一个字符数组)
        //定义一个字符数组,用来接收每次读取到的数据
        char[] cArr = new char[1024];
        //定义变量len,用来接收每次读取到的字符的个数。
        int len;
        //开始循环读取
        /*
            条件位置做了哪些事情:
                1. 通过输入流调用了read方法,将数据读取到了cArr这个字符数组中。
                2. 返回了读取到的有效个数,并赋值给了变量len
                3. 判断len是否不等于-1,如果不是-1,那么表示读取到了数据,那么就在循环中进行处理。
         */
        while((len = r.read(cArr)) != -1) {
            //读取到几个内容,那么就将几个内容转成字符串输出
            System.out.println(new String(cArr, 0, len));
        }

        //释放资源
        r.close();
    }
}

07. 字符输出流的基本使用

/*
    Writer表示字符输出流, 可以将Java程序中的数据写到文件中, 字符输出流会以字符为单位进行输出。
    Writer是所有字符输出流的顶层父类,是抽象类。如果要用,需要使用子类, 最常用的子类是FileWriter

    FileWriter构造方法:
        FileWriter(String fileName):使用有参构造创建对象, 参数要传递一个字符串类型的文件,表示向这个文件写数据。
        FileWriter(File file): 参数要传递一个File类型的文件,表示想这个文件中写数据。

    FileWriter的其他方法:
        void write(String str): 向文件中写一个字符串
        void flush(): 刷新
        void close(): 关闭流。

    FileWriter的使用步骤:
        1. 创建一个FileWriter字符输出流
        2. 调用write方法写数据。
        3. 调用flush方法刷新。
        4. 调用close方法关闭。

    在所有的流中, 字符流,并且是字符输出流需要刷新。
 */
public class Demo01Writer {
    public static void main(String[] args) throws IOException {
        //创建FileWriter对象
        Writer w = new FileWriter("day10\\bb.txt");
        //调用write方法写数据。
        //字符输出流写数据的时候,先会把数据放到内存缓冲区中, 并没有直接写到文件中。
        //想要把内存缓冲区中的数据放到文件中,那么需要进行刷新操作。
        w.write("你好啊, 你今天早上洗头发了吗");
        //调用flush方法刷新
        w.flush();
        //释放资源
        w.close();
    }
}

08. 字符输出流刷新方法和close方法的区别

/*
    刷新方法和关闭方法的区别。
        flush:做的仅仅是刷新的操作。 流在刷新之后还可以使用。
        close:先刷新,然后关闭流。   流在关闭之后就不能使用了
 */
public class Demo02FlushAndClose {
    public static void main(String[] args) throws IOException {
        //创建一个FileWriter对象
        Writer w = new FileWriter("day10\\cc.txt");
        //调用write方法写数据
        w.write("你好");
        //调用flush刷新
        w.flush();
        //调用write方法写数据
        w.write("我好");
        w.flush();
        //调用close方法释放资源
        w.close();
        //w.write("大家好"); Stream closed
    }
}

09. 字符输出流写数据的5个方法

/*
    FileWriter写数据的5个方法:
        void write(String str): 向文件中写字符串
        void write(String str, int off, int len): 向文件中写入字符串的一部分。 从off位置开始写, 写len个。
        void write(int c): 向文件中写一个字符。
        void write(char[] cbuf): 向文件中写字符数组
        void write(char[] cbuf, int off, int len): 向文件中写字符数组的一部分。 从off位置开始写, 写len个。

    FileWriter的使用步骤
        1. 创建FileWriter对象
        2. 调用write方法,写数据。
        3. 调用flush方法刷新
        4. 调用close方法,释放资源。
 */
public class Demo02Writer {
    public static void main(String[] args) throws IOException {
        //创建FileWriter对象
        Writer w = new FileWriter("day10\\dd.txt");
        //调用write方法,写数据。
        //void write(String str): 向文件中写字符串
        w.write("hello");

        //void write(String str, int off, int len): 向文件中写入字符串的一部分。 从off位置开始写, 写len个。
        //w.write("hello", 1, 3);//将"hello"写到文件中,从索引为1的位置开始写, 写3个。

        //void write(int c): 向文件中写一个字符。
        //w.write(100);//d 写入的是100对应的ASCII码字符
        //w.write('z');
        //w.write('中');

        //void write(char[] cbuf): 向文件中写字符数组
        //char[] cArr = {'a', 'b', 'c', 'd', 'e'};
        //w.write(cArr);

        //void write(char[] cbuf, int off, int len): 向文件中写字符数组的一部分。 从off位置开始写, 写len个。
        //char[] cArr = {'a', 'b', 'c', 'd', 'e'};
        //w.write(cArr, 1,  2);//将cArr中的一部分写到文件中,从索引为1的位置开始写,写2个。

        //调用flush方法刷新
        w.flush();
        //调用close方法,释放资源。
        w.close();
    }
}

10. JDK7之前IO流的异常处理

/*
    释放资源的代码是无论如何一定要执行的, 所以可以把释放资源的代码放在finally代码块中。
 */
public class Demo01Exception {
    public static void main(String[] args)  {
        Writer w = null;
        try {
            //创建字符输出流对象
            w = new FileWriter("day10\\ee.txt");
            //调用write方法,写数据
            w.write("你好");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //释放资源
            try {
                //判断如果w是null, 表示字符输出流对象并没有创建成功,那么就不需要释放资源了。
                //如果w不是null,表示字符输出流对象才创建成功了,那么才释放资源
                if(w != null) {
                    w.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

11. JDK7之后的异常处理

/*
    JDK7之后多了一种语句叫做try...with...resource, 其实他就是一个特殊的try...catch语句

    格式:
        try(创建流对象的代码) {

        } catch(异常类名 变量名) {

        }

    作用: 在try后面小括号中创建的流对象,不管是否有异常都会调用close方法。
           在小括号中创建的流对象,系统会自动调用close方法, 不需要我们手动调用。

    注意:在try中可以创建多个对象, 多个对象之间使用分号隔开
 */
public class Demo02Exception {
    public static void main(String[] args) {
        try(Writer w = new FileWriter("day10\\ff.txt")) {
            //调用write方法写数据
            w.write("你好");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

12. Properties的介绍以及基本使用

/*
    Properties叫做属性集,是一个双列集合, Properties有下面的三个特点:
        1. Properties实现了Map接口, 拥有Map接口的所有的方法。
        2. 没有泛型, 键和值都是字符串。
        3. 支持对流进行操作, 可以从流(文件)中读取键值对。

    构造方法:
        Properties(): 空参构造。

    其他方法:
        (记住)Object setProperty(String key, String value): 向Properties中添加键值对。
        (记住)String getProperty(String key): 根据键获取值
        Set<String> stringPropertyNames(): 获取所有的键,并放入到Set集合中返回。
 */
public class Demo01Properties {
    public static void main(String[] args) {
        //创建Properties集合对象
        Properties p = new Properties();
        //向Properties添加数据
        p.setProperty("it001", "jack");
        p.setProperty("it002", "rose");
        p.setProperty("it003", "tom");

        //输出Properties中的内容
        System.out.println(p);
        //String getProperty(String key): 根据键获取值
        System.out.println(p.getProperty("it001"));//jack
        System.out.println(p.getProperty("it003"));//tom
        System.out.println("============================");
        //Set<String> stringPropertyNames(): 获取所有的键,并放入到Set集合中返回。
        Set<String> keys = p.stringPropertyNames();
        //遍历keys,拿到每一个key, 根据key获取value
        for(String key : keys) {
            System.out.println(key + ":" + p.getProperty(key));
        }
    }
}

13. Properties和流相关的方法

/*
    Properties可以从流(文件)中读取键值对

    和流相关的方法:
        void load(InputStream inStream): 参数要传递一个字节输入流。
        void load(Reader reader): 参数要传递字符输入流。

    使用步骤:
        1. 创建Properties对象
        2. 创建一个输入流对象,并绑定一个数据源文件。
        3. 调用load方法,将流(文件)中的键值对加载到Properties集合中。
        4. 释放资源。

    文件的要求:
        1. 文件一般以.properties结尾(软性要求)
        2. 文件中的键值对必须按照键=值的方式去存放, 每一个键值对要另起一行(硬性要求)
            键=值
            键=值
            键=值
 */
public class Demo02Properties {
    public static void main(String[] args) throws IOException {
        //创建Properties对象
        Properties p = new Properties();
        //创建一个输入流对象,并绑定一个数据源文件。
        InputStream is = new FileInputStream("day10\\config.properties");
        //调用load方法,将流(文件)中的键值对加载到Properties集合中。
        p.load(is);
        //输出Properties
        System.out.println(p);
        //释放资源。
        is.close();
    }
}
  • 资源分享QQ群
  • weinxin
  • 官方微信公众号
  • weinxin
沙海
C语言速查手册
网站https安全证书安装,伪静态配置
TripodCloud:性价比最高的CN2 GIA服务器
C语言项目源码分享

发表评论

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen: