投稿
  1. 首页
  2. java

【JAVA】IO流

code • 2022-5-16 • java • 阅读 36

【JAVA】IO流,第1张

目录

【IO流】

【字节流】

【写数据】

【字节流的异常处理try...catch...finally】

【读数据】

【字节流——示例项目】

【字节缓冲流】

【字节缓冲流——示例项目】

【字符流】

【写数据】

【读数据】

【字符流——示例项目】

【字符缓冲流】

【字符缓冲流——示例项目】

【Properties】 

【IO流】

【概述】：

  • I表示intput，是数据从硬盘进内存的过程，称之为读。
  • O表示output，是数据从内存到硬盘的过程。称之为写。

【分类】：

【字节流】 【写数据】

【步骤】：

  • 创建字节输出流对象。

【构造方法】：

public FileOutputStream(String name)：创建文件输出流以指定的名称写入文件。

public FileOutputStream(Flie file)：创建文件输出流以指定的文件对象写入文件。

public FileOutputStream​(String name，boolean append)：创建文件输出流以指定的名称写入文件。如果第二个参数为true ，不会清空文件里面的内容。

例：

        FileOutputStream fos1=new FileOutputStream("G:\JAVA\a.txt");
        FileOutputStream fos2=new FileOutputStream(new File("G:\JAVA\a.txt"));

【注意】：

如果文件不存在，就创建。

如果文件存在就清空。

  • 写数据

public void write​(int b)：一次写一个字节数据

public void write​(byte[] b)：一次写一个字节数组数据

public void write​(byte[] b, int off, int len)：一次写一个字节数组的部分数据

例：

        FileOutputStream fos = new FileOutputStream("stream_io\a.txt");
        //一次写一个字节数据
        fos.write(97);
        //一次写一个字节数组数据
        byte[] bytes1 = {97, 98, 99};
        fos.write(bytes1);
        //一次写一个字节数组的部分数据
        byte[] bytes2 = {97, 98, 99, 100, 101};
        fos.write(bytes2,1,3);

【写数据换行 *** 作】：

String.getBytes():将字符串转化为字节数组

windows:\r\n

linux:\n

mac:\r

例：

        FileOutputStream fos = new FileOutputStream("stream_io\a.txt");
        fos.write(97);
        fos.write("\r\n".getBytes());
        fos.write(98);

【注意】：

写出的整数，实际写出的是整数在码表上对应的字母。

  • 释放资源

【成员方法】：

void close():释放资源

例：

        fos.close();

【注意】：

每次使用完流必须要释放资源。

【字节流的异常处理try...catch...finally】

finally：在异常处理时提供finally块来执行所有清除 *** 作。比如说IO流中的释放资源

特点：被finally控制的语句一定会执行，除非JVM退出

异常处理标准格式：try….catch…finally

例：

        FileOutputStream fos=null;
        try {
             fos = new FileOutputStream("stream_io\a.txt");
            fos.write(97);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fos!=null) {
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
【读数据】
  • 创建字节输入流对象

【构造方法】：

public FileInputStream(String name)：创建文件输出流以指定的名称写入文件。

public FileInputStream(Flie file)：创建文件输出流以指定的文件对象写入文件。

【注意】：

如果文件不存在，就直接报错

  • 读数据

public int read():从此输入流中读取一个字节的数据。

public int read(byte[] b):从此输入流b.length最多b.length字节的数据读b.length字节数组,返回的是读入缓冲区的总字节数,也就是实际的读取字节个数

public int read(byte[] b,int off,int len):从此输入流len最多len字节的数据读入一个字节数组。

例：

        FileInputStream fis = new FileInputStream("stream_io\a.txt");
        //一次读一个字节
        int b;
        while ((b = fis.read()) != -1) {
            System.out.println((char) b);
        }
        //一次读一个字节数组
        byte[] bytes = new byte[1024];
        int len;
        while ((len = fis.read(bytes)) != -1) {
            System.out.println(new String(bytes,0,len));
        }
        fis.close();

【注意】：

读出来的是文件中数据的码表值。 a -> 97

如果想要看到字符数据，强转成char类型

  • 释放资源

void close():释放资源

例：

        fis.close();

【注意】：

每次使用完流必须要释放资源。

【字节流——示例项目】

把"G:\\JAVA\\a.txt"复制到当前模块下


        //创建字节输入流，准备读数据
        FileInputStream fis = new FileInputStream("G:\JAVA\a.txt");
        //创建字节输出流，准备写数据
        FileOutputStream fos = new FileOutputStream("stream_io\a.txt");
        //一次读写一个字节
        int b;
        while ((b = fis.read()) != -1) {
            fos.write(b);
        }
        //一次读写一个字节数组
        byte[] bytes = new byte[1024];
        int len;
        while ((len = fis.read(bytes)) != -1) {
            fos.write(bytes, 0, len);
        }
        fis.close();
        fos.close();
【字节缓冲流】

【构造方法】：

BufferedOutputStream​(OutputStream out)：字节缓冲输出流

BufferedInputStream​(InputStream in)：字节缓冲输入流

例：

        //创建字节缓冲输入流，准备读数据
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("G:\JAVA\a.txt"));
        //创建字节缓冲输出流，准备写数据
        BufferedOutputStream bos  = new BufferedOutputStream(new FileOutputStream("stream_io\a.txt"));

【成员方法】：

同字节流

【字节缓冲流——示例项目】

利用字节缓冲流把"G:\\JAVA\\a.txt"复制到当前模块下

        //创建字节输入流，准备读数据
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("G:\JAVA\a.txt"));
        //创建字节输出流，准备写数据
         BufferedOutputStream bos  = new BufferedOutputStream(new FileOutputStream("stream_io\a.txt"));
        //一次读写一个字节
        int b;
        while ((b = bis.read()) != -1) {
            bos.write(b);
        }
        //一次读写一个字节数组
        byte[] bytes = new byte[1024];
        int len;
        while ((len = bis.read(bytes)) != -1) {
            bos.write(bytes, 0, len);
        }
        bis.close();
        bos.close();
【字符流】

【编码表】：

windows默认使用码表为：GBK，一个字符两个字节。

idea和以后工作默认使用Unicode的UTF-8编解码格式，一个中文三个字节。

【编码方法】：

byte[] getBytes​()：使用平台的默认字符集将该 String编码为一系列字节，将结果存储到新的字节数组中

byte[] getBytes​(String charsetName)：使用指定的字符集将该 String编码为一系列字节，将结果存储到新的字节数组中

例：

        String s = "张三李四";
        byte[] bytes1=s.getBytes(StandardCharsets.UTF_8);
        System.out.println(Arrays.toString(bytes1));
        byte[] bytes2=s.getBytes("GBK");
        System.out.println(Arrays.toString(bytes2));

【解码方法】：

String​(byte[] bytes)：通过使用平台的默认字符集解码指定的字节数组来构造新的 String

String​(byte[] bytes, String charsetName)：通过指定的字符集解码指定的字节数组来构造新的 String

例：

        byte[] bytes3 = {-27, -68, -96, -28, -72, -119, -26, -99, -114, -27, -101, -101};
        byte[] bytes4 = {-43, -59, -56, -3, -64, -18, -53, -60};
        String s1=new String(bytes3);
        System.out.println(s1);
        String s2=new String(bytes4,"GBK");
        System.out.println(s2);

【注意】：

字符流 = 字节流 + 编码表

  1. 想要进行拷贝，一律使用字节流或者字节缓冲流。
  2. 想要把文件中的数据读到内存中打印或者读到内存中运算，请使用字符输入流。
  3. 想要把集合，数组，键盘录入等数据写到文件中，请使用字符输出流。
  4. GBK码表一个中文两个字节，UTF-8编码格式一个中文3个字节。
【写数据】

【步骤】：

  • 创建字符输出流对象

【构造方法】：

public FileWriter(File file)：给一个File对象构造一个FileWrite对象

public FileWriter(String fileName)：构造一个给定文件名的FileWrite对象

public FileOutputStream​(String name，boolean append)：给一个File对象构造一个FileWrite对象。如果第二个参数为true ，不会清空文件里面的内容。

例：

        FileWriter fw1 = new FileWriter(new File("stream_io\a.txt"));
        FileWriter fw2 = new FileWriter("stream_io\a.txt");

【注意】：

如果文件不存在，就创建。但是要保证父级路径存在。

如果文件存在就清空。

  • 写数据

【成员方法】：

void write​(int c)：写一个字符

void write​(char[] cbuf)：写入一个字符数组

void write​(char[] cbuf, int off, int len)：写入字符数组的一部分

void write​(String str)：写一个字符串

void write​(String str, int off, int len)：写一个字符串的一部分

例：

        FileWriter fw = new FileWriter("stream_io\a.txt");
        //写出一个字符
        fw.write(97);
        char [] chars={97,98,99,100};
        //写出字符数组
        fw.write(chars);
        //写出字符数组的一部分
        fw.write(chars,0,2);
        //写一个字符串
        String line="张三李四";
        fw.write(line);
        //写一个字符串的一部分
        fw.write(line,0,2);
        fw.close();

【注意】：

写出int类型的整数，实际写出的是整数在码表上对应的字母。

写出字符串数据，是把字符串本身原样写出。

  • 释放资源

【成员方法】：

void flush()：刷新流，还可以继续写数据

void close()：释放资源

例：

        fw.flush();
        fw.close();

【注意】：

每次使用完流必须要释放资源。

【读数据】

【步骤】：

  • 创建字符输入流对象

【构造方法】：

public FileReader(String name)：创建一个新的FileReader，给定要读取的文件的名称。

public FileReader(Flie file)：创建一个新的FileReader，给出File读取。

例：

        FileReader fr1 = new FileReader("stream_io\a.txt");
        FileReader fr2 = new FileReader(new File("stream_io\a.txt"));
  • 读数据

【成员方法】：

int read​()：一次读一个字符数据

int read​(char[] cbuf)：一次读一个字符数组数据

例：

        FileReader fr = new FileReader("stream_io\a.txt");
        //一次读取一个字符
        int ch;
        while ((ch = fr.read()) != -1) {
            System.out.println((char) ch);
        }
        //一次读取多个字符
        char[] chars=new char[1024];
        int len;
        while ((len=fr.read(chars))!=-1){
            System.out.println(new String(chars,0,len));
        }
  • 释放资源

【成员方法】：

void close()：释放资源

例：

        fr.close();
【字符流——示例项目】

将键盘录入的用户名和密码保存到本地实现永久化储存

        Scanner sc=new Scanner(System.in);
        System.out.println("请输入用户名:");
        String username=sc.next();
        System.out.println("请输入密码:");
        String password=sc.next();
        FileWriter fw=new FileWriter("stream_io\log.txt");
        fw.write(username);
        fw.write("\r\n");
        fw.write(password);
        fw.flush();
        fw.close();
【字符缓冲流】

【构造方法】：

BufferedWriter​(Writer out)：字符输出缓冲流

BufferedReader​(Reader in)：字符输入缓冲流

例：

        //创建字符缓冲输入流，准备读数据
        BufferedReader br = new BufferedReader(new FileReader("stream_io\log.txt"));
        //创建字符缓冲输出流，准备写数据
        BufferedWriter bw = new BufferedWriter(new FileWriter("stream_io\log.txt"));

【成员方法】：

同字符流

【特有方法】：

  • BufferedWriter()特有：

void newLine​()：写一行行分隔符，行分隔符字符串由系统属性定义

  • BufferedReader()特有：

public String readLine​() ：读一行文字。 结果包含行的内容的字符串，不包括任何行终止字符，如果流的结尾已经到达，则为null

例：

        //BufferedWriter特有方法newline()
        BufferedWriter bw = new BufferedWriter(new FileWriter("stream_io\a.txt"));
        bw.write("aaa");
        bw.newLine();
        bw.write("bbb");
        bw.close();
        //BufferedReader特有方法newline()
        BufferedReader br = new BufferedReader(new FileReader("stream_io\a.txt"));
        String line = null;
        while ((line= br.readLine())!=null) {
            System.out.println(line);
        }
        br.close();
【字符缓冲流——示例项目】

读取文件中数据，排序后再次写到本地文件

        BufferedReader br = new BufferedReader(new FileReader("stream_io\a.txt"));
        String line = br.readLine();
        System.out.println("读取到的数据:" + line);
        br.close();
        String[] split = line.split(" ");
        int[] arr = new int[split.length];
        for (int i = 0; i < split.length; i++) {
            String smallStr = split[i];
            int number = Integer.parseInt(smallStr);
            arr[i] = number;
        }
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));
        BufferedWriter bw = new BufferedWriter(new FileWriter("stream_io\a.txt"));
        for (int i = 0; i < arr.length; i++) {
            bw.write(arr[i] + " ");
            bw.flush();
        }
        bw.close();
【Properties】 

【概述】：

  • 是一个Map体系的集合类
  • Properties中有跟IO相关的方法
  • 只存字符串

【构造方法】：

Properties()：创建一个没有默认值的空属性列表

【成员方法】：

同Map集合

【作为集合的特有方法】：

Object setProperty​(String key, String value)：设置集合的键和值，都是String类型，底层调用 Hashtable方法 put

String getProperty​(String key)：使用此属性列表中指定的键搜索属性

Set stringPropertyNames​()：从该属性列表中返回一个不可修改的键集，其中键及其对应的值是字符串

例：

        Properties prop = new Properties();
        prop.setProperty("江苏", "南京");
        prop.setProperty("安徽", "南京");
        prop.setProperty("山东", "济南");
        System.out.println(prop);
        String value = prop.getProperty("江苏");
        System.out.println(value);
        Set keys = prop.stringPropertyNames();
        for (String key : keys) {
            String value1 = prop.getProperty(key);
            System.out.println(key + "=" + value1);

【Properties和IO流结合的方法】：

void load​(InputStream inStream)：从输入字节流读取属性列表（键和元素对）

void load​(Reader reader)：从输入字符流读取属性列表（键和元素对）

void store​(OutputStream out, String comments)：将此属性列表（键和元素对）写入此 Properties表中，以适合于使用 load(InputStream)方法的格式写入输出字节流

void store​(Writer writer, String comments)：将此属性列表（键和元素对）写入此 Properties表中，以适合使用 load(Reader)方法的格式写入输出字符流

例：

        //读文件
        Properties prop1 = new Properties();
        FileReader fr = new FileReader("prop.properties");
        prop1.load(fr);
        System.out.println(prop1);
        fr.close();
        //写文件
        Properties prop2=new Properties();
        prop2.put("lisi","23");
        prop2.put("wangwu","23");
        FileWriter fw=new FileWriter("prop.properties");
        prop2.store(fw,null);
        fw.close();

【注意】：

comments是字符串注释，没有可写为null

欢迎分享，转载请注明来源：内存溢出

原文地址: http://outofmemory.cn/langs/921318.html

赞 (0)
打赏 微信扫一扫 微信扫一扫 支付宝扫一扫 支付宝扫一扫
code code 管理员组
0 0
上一篇 2022-05-16
下一篇 2022-05-16

发表评论

登录后才能评论

评论列表（0条）

保存