IO流java基础

最新推荐文章于 2022-07-26 22:26:13 发布
最新推荐文章于 2022-07-26 22:26:13 发布
阅读量233 收藏
点赞数
分类专栏： java 基础 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/guenping2020/article/details/110136098
版权

二十四.IO流

24.1.File

1.1.File 类概述和构造方法

File:它是文件和目录路径名的抽象表示

  • 文件和目录是可以通过File封装成对象的

  • 对于File而言，其封装的并不是一个真正存在的文件，仅仅是一个路径名而已。它可以是存在的，也可以是不存在的。将来是要通过具体的操作把这个路径的内容转换为具体存在的

方法名说明
File(String pathname)通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例。
File(String parent, String child)从父路径名字符串和子路径名字符串创建新的 File实例。
File(File parent, String child)从父抽象路径名和子路径名字符串创建新的 File实例。
import java.io.File;

public class FileDemo01 {
    public static void main(String[] args) {
//      File(String pathname)通过将给定的路径名字符串转换为抽象路径名来创建新的 `File`实例。
        File f1 = new File("E:\\javastudent\\src\\com\\java2\\java.txt");
        System.out.println(f1);
//      File(String parent,  String child)从父路径名字符串和子路径名字符串创建新的 `File`实例。
        File f2 = new File("E:\\javastudent\\src\\com\\java2","java.txt");
        System.out.println(f2);
//      File(File parent, String child)从父抽象路径名和子路径名字符串创建新的 `File`实例。
        File f3 = new File("E:\\javastudent\\src\\com\\java2");
        File f4 = new File(f3,"java.txt");
        System.out.println(f4);
    }
}
/*
E:\javastudent\src\com\java2\java.txt
E:\javastudent\src\com\java2\java.txt
E:\javastudent\src\com\java2\java.txt
*/

1.2.File类创建功能

方法名说明
public boolean createNewFile()当且仅当具有该名称的文件尚不存在时，原子地创建一个由该抽象路径名命名的新的空文件
public boolean mkdir()创建由此抽象路径名命名的目录
public boolean mkdirs()创建由此抽象路径名命名的目录，包括任何必需但不存在的父目录
import java.io.File;
import java.io.IOException;

/*
        public boolean createNewFile()当且仅当具有该名称的文件尚不存在时，原子地创建一个由该抽象路径名命名的新的空文件
        如果文件不存在,就创建文件,并返回true;
        如果文件存在,就不创建文件,并返回false

        public boolean mkdir() 创建由此抽象路径名命名的目录
        如果目录不存在,就创建文件,并返回true;
        如果目录存在,就不创建文件,并返回false

        public boolean mkdirs()创建由此抽象路径名命名的目录，包括任何必需但不存在的父目录
         如果目录不存在,就创建文件,并返回true;
        如果目录存在,就不创建文件,并返回false

        */
public class FileDemo02 {
    public static void main(String[] args) throws IOException {
    //需求1:我要在E:\专业书 目录下创建一个文件java.txt
        File f1 = new File("E:\\专业书\\java.txt");
        System.out.println(f1.createNewFile());
        System.out.println("-----");

    //需求2:我要在E:\专业书 目录下创建一个目录JavaSE
        File f2 = new File("E:\\专业书\\JavaSE");
        System.out.println(f2.mkdir());
        System.out.println("-----");

    //需求3:我要在E:\专业书 目录下创建一个多级目录JavaWEB\\HTML
        File f3 = new File("E:\\专业书\\JavaWEB\\\\HTML");
        System.out.println(f3.mkdirs());
        System.out.println("-----");

     //需求4:我要唉EE:\专业书 目录下创建一个文件javase.txt
     //创建什么就用什么方式
        File f4 = new File("E:\\专业书\\javaee.txt");
        System.out.println(f4.createNewFile());

    }
}

1.3.File类删除功能

方法名说明
public boolean delete()删除由此抽象路径名表示的文件或目录

绝对路径和相对路径的区别

  • 绝对路径:完整的路径名，不需要任何其他信息就可以定位它所表示的文件。例如: E:\\javastudent\\ljava.txt
  • 相对路径:必须使用取自其他路径名的信息进行解释。例: .\\java.txt

删除目录时的注意事项:

如果一个目录中有内容(目录，文件)，不能直接删除。应该先删除目录中的内容，最后才能删除目录

  • 当前目录： 以 ". / " 或者 省略 开头
  • 上一级目录：以" . . / " 开头
import java.io.File;
import java.io.IOException;

public class FileDemo03 {
    public static void main(String[] args) throws IOException {
       //需求1在当前模块目录下创建java.txt
        File f1 = new File(".\\java.txt");
        System.out.println(f1.createNewFile());
        //需求2:删除当前模块目录下的java.txt文件
        System.out.println(f1.delete());
        System.out.println("----");
        //需求3:在当前模块下创建目录
       File f2 = new File(".\\java3");
        System.out.println(f2.mkdir());
//      需求4:删除当前模块目录下的java3目录
        System.out.println(f2.delete());
        System.out.println("----");

        //需求5:在当前模块下创建一个目录java3,然后在该目录下创建一个文件java.txt
        //创建文件前要先创建文件夹
        File f3 = new File(".\\java4");
        System.out.println(f3.mkdir());

        File f4 = new File(".\\java4\\java.txt");
        System.out.println(f4.createNewFile());
//      需求6:删除当前模块下的目录java3
        System.out.println(f4.delete());
        System.out.println(f3.delete());
    }
}

1.4.File类判断和获取功能

在这里插入图片描述

public class FileDemo04 {
    public static void main(String[] args) throws IOException {
        //创建一个file对象
        File f = new File("java.txt");
//public boolean isDirectory() 测试此抽象路径名表示的File是否为目录
        System.out.println(f.isDirectory());
//public boolean isFile() 测试此抽象路径名表示的File是否为文件
        System.out.println(f.isFile());
//public boolean exists() 测试此抽象路径名表示的File是否存在
        System.out.println(f.exists());

//        public String getAbsoLutePath():返回此抽象路径名的绝对路径名字符串
//        public String getPath():将此抽象路径名转换为路径名字符串,返回给定的抽象路径名字符串表示
//        public String getName():返回由此抽象路径名表示的文件或目录的名称,返回的是用file封装的目录或名称
        System.out.println(f.getAbsolutePath());
        System.out.println(f.getPath());
        System.out.println(f.getName());
        System.out.println("--------");

        //public String[] list()返回此抽象路径名表示的目录中的文件和目录的名称字符串数组
        File f2 = new File("E:\\专业书\\测试");
        String[] strArray = f2.list();
        for (String str : strArray) {
            System.out.println(str);
        }
        System.out.println("--------");
        //public File[] listFiles()返回此抽象路径名表示的目录中的文件和目录的File对象数组

        File[] fileArray = f2.listFiles();
        for (File file : fileArray) {
//            System.out.println(file);
            if (file.isFile()) {
                System.out.println(file.getName());
            }
        }
    }
 /*
false
true
true
E:\javastudent\java.txt
java.txt
java.txt
--------
123.docx
321.txt
--------
123.docx
321.txt
 */

1.5.递归

递归概述:以编程的角度来看，递归指的是方法定义中调用方法本身的现象

递归解决问题思路:

把一个复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解
递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算

递归的注意事项:
递归一定要有出口。否则内存溢出
递归虽然有出口，但是递归的次数也不宜过多。否则内存溢出

public class DiGuiDemo {
    public static void main(String[] args) {
        int[] arr = new int[20];

        arr[0] = 1;
        arr[1] = 1;

        for (int i = 2; i < arr.length; i++) {
            arr[i] = arr[i - 1] + arr[i - 2];
        }
        System.out.println(arr[19]);
        System.out.println(f(20));
    }

    /*
        机柜解决问题,首先就是要定义一个方法,
            定义一个方法(n):表示第n个月的兔子对数
            那么,第n-1个月的兔子对数改如何表示呢?f(n-1)
            同理,第n-2个月的兔子对数该如何表示呢?f(n-2)
     */
    //StackOverflowError当堆栈溢出发生时抛出一个应用程序递归太深。
    public static int f(int n) {
        if (n == 1 || n == 2){
            return 1;
        }else {
            return f(n - 1) + f(n - 2);
        }
    }
}
/*
6765
6765
*/
1.5.1.案例:递归求阶乘

需求:用递归求5的阶乘，并把结果在控制台输出

分析:

①阶乘:一个正整数的阶乘是所有小于及等于该数的正整数的积，自然数n的阶乘写作n!

​ 5!=54321

②递归出口:1!= 1

③递归规则:n!=n*(n-1)!

​ 5! = 5*4!

public class DiGuiDemo02 {
    public static void main(String[] args) {
        int result = jc(5);
        System.out.println("五的阶乘是: "+result);

    }
    public static int jc(int n){
        if (n==1){
            return 1;
        }else {
            return n*jc(n-1);
        }
    }
}
//120
1.5.2.案例遍历目录

需求:给定一个路径(E\itcast)，请通过递归完成遍历该目录下的所有内容，并把所有文件的绝对路径输出在控制台

思路:

①根据给定的路径创建一个File对象

②定义一个方法，用于获取给定目录下的所有内容，参数为第1步创建的File对象

③获取给定的File目录下所有的文件或者目录的File数组

④遍历该File数组，得到每一个File对象

⑤判断该File对象是否是目录

​ 是:递归调用

​ 不是:获取绝对路径输出在控制台

⑥调用方法

在这里插入图片描述

24.2.字节流

2.1.IO流概述和介绍

IO流述

  • IO：输入/输出(Input/Output)
  • 流：是一种抽象概念，是对数据传输的总称。也就是说数据在设备间的传输称为流，流的本质是数据传输
  • IO流就是用来处理设备间数据传输问题的
  • 常见的应用:文件复制;文件上传;文件下载

IO流的分类

  • 按照数据的流向

    • 输入流：读数据
    • 输出流：写数据

  • 按照数据类型来分
    字节流
    字节输入流 ; 字节输出流
    字符流
    字符输入流 ; 字符输出流

一般来说，我们说IO流的分类是按照数据类型来分的那么这两种流都在什么情况下使用呢?

如果数据通过Window自带的记事本软件打开，我们还可以读懂里面的内容，就使用字符流，否则使用字节流。如果你不知道该使用哪种类型的流，就使用字节流

2.2 字节流写数据

字节流抽象基类

  • lnputStream:这个抽象类是表示字节输入流的所有类的超类
  • OutputStream:这个抽象类是表示字节输出流的所有类的超类
  • 子类名特点:子类名称都是以其父类名作为子类名的后缀

FileOutputStream:文件输出流用于将数据写入File

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

使用字节输出流写数据的步骤:

  • 创建字节输出流对象(调用系统功能创建了文件，创建字节输出流对象，让字节输出流对象指向文件)
  • 调用字节输出流对象的写数据方法
  • 释放资源(关闭此文件输出流并释放与此流相关联的任何系统资源)
import java.io.FileOutputStream;
import java.io.IOException;

public class FileOutputStreamDemo01 {
    public static void main(String[] args) throws IOException {
        //创建字节输出流对象
//FileOutputStream(Stringname):创建文件输出流以指定的名称写入文件
        FileOutputStream fos = new FileOutputStream(".\\fos.txt");
        /*
        做了三件事情;
            A:调用系统功能创建了文件
            B:创建了字节输出流对象
            c:让字节输出流对象指向创建好的文件
         */
//  void write (int b),将指定的字节写入此文件输出流
        fos.write(97);
//        fos.write(57);
//        fos.write(55);
//        最后都要释放资源
//void close ():关闭此文件输出流并释放与此流相关联的任何系统资源。
        fos.close();

    }
}

2.3.字节流写数据的三种方式

方法名说明
void write(int b)将指定的字节写入此文件输出流一次写一个字节数据
void write(byte[] b)将b.length字节丛指定的字节数组写入此文件输出流一次写一个字节数组数据
void write(byte[] b,int off,int len)将len字节从指定的字节数组开始，从偏移量off开始写入此文件输出流一次写一个字节数组的部分数据

构造方法;

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

FileOutputStream(file file):创建文件输出流以写入由指定的File对象表示的文件

import java.io.FileOutputStream;
import java.io.IOException;

public class FileOutputStreamDemo02 {
    public static void main(String[] args) throws IOException {
//FileOutputStream(String  name):创建文件输出流以指定的名称写入文件, 一般写这个方便
        FileOutputStream fos = new FileOutputStream(".\\fos.txt");
        //new File(name)自动封装了
//      FileOutputStream fos = new FileOutputStream(new File(".\\fos.txt"));

//FileOutputStream(file file):创建文件输出流以写入由指定的File对象表示的文件
//        FileOutputStream fos2 = new FileOutputStream(new File(".\\fos.txt"));

//  void write(int b)将指定的字节写入此文件输出流一次写一个字节数据
/*
        fos.write(97);
        fos.write(98);
        fos.write(99);
        fos.write(100);
        fos.write(101);*/

//void write(byte[] b)将b.length字节丛指定的字节数组写入此文件输出流一次写一个字节数组数据
///        byte[] bys = {97,98,99,100,101,102};
        //byte[] getBytes ():返回字符串对应的字节数组
        byte[] bys = "abcdefg".getBytes();
//        fos.write(bys);
///  void write(byte[] b,int off,int len)将len字节从指定的字节数组开始，从偏移量off开始写入此文件输出流一次写一个字节数组的部分数据
        fos.write(bys, 1, 3);

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

2.4.字节流写数据的两个小问题

1.字节流写数据如何实现换行

​ window: \r\n

​ linux: \n

​ mac: \r

2.字节流写数据如何实现追加写入

  • public FileOutputStream (String name , boolean append)

  • 创建文件输出流以指定的名称写入文件。如果第二个参数为true ，则字节将写入文件的末尾而不是开头

import java.io.FileOutputStream;
import java.io.IOException;

public class FileOutputStreamDemo03 {
    public static void main(String[] args) throws IOException {
        //创建字节流输出对象
//        FileOutputStream fos = new FileOutputStream(".\\fos.txt");
        FileOutputStream fos = new FileOutputStream(".\\fos.txt",true);

        //写数据
        for (int i = 0; i < 10; i++){
            fos.write("hello".getBytes());
            fos.write("\r\n".getBytes());
        }
        //释放资源
        fos.close();
    }
}

2.5.字节流写数据加异常处理

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

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

在这里插入图片描述

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class FileOutputStreamDemo04 {
    public static void main(String[] args) throws FileNotFoundException {
        FileOutputStream fos = null;
        try {
            fos = new FileOutputStream(".\\fos.txt");
            fos.write("hello".getBytes());

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fos != null)
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
        }

    }
}

2.6.字节流读数据(一次读一个字节数据)

需求:把文件fos.txt中的内容读取出来在控制台输出

FilelnputStream:从文件系统中的文件获取输入字节

  • FileInputStream(String name):通过打开与实际文件的连接来创建一个FileInputStream，该文件由文件系统中的路径名name 命名。

使用字节输入流读数据的步骤 :

① 创建字节输入流对象

② 调用字节输入流对象的读数据方法

③ 释放资源

import java.io.FileInputStream;
import java.io.IOException;

public class FileIntputStreamDemo01 {
    public static void main(String[] args) throws IOException {
        //创建字节输入流对象
        //FileInputStream(String name)
        FileInputStream fis = new FileInputStream("E:\\javastudent\\fos.txt");

//        调用字节输入流对象的读数据方法
//        int read() 从该输入流读取一个字节的数据。

/*
        //第一次读取数据
        int by = fis.read();
        System.out.println(by);
        System.out.println((char) by);
        System.out.println("-----");
        //第二次读取数据
        by = fis.read();
        System.out.println(by);
        System.out.println((char) by);
        System.out.println("-----");
        //再多读取两次
        by = fis.read();
        System.out.println(by);
        by = fis.read();
        System.out.println(by);
*/

/*        int by = fis.read();
        while (by != -1) {
            System.out.print((char) by);
            by = fis.read();
        }*/
//        优化上面的程序
        int by;
        /*
        fis.read( ):读数据
        by=fis.read():把读取到的数据赋值给by
        by != -1:判断读取到的数据是否是-1*/

        while ((by = fis.read()) != -1) {
            System.out.print((char) by);
        }
//        释放资源
        fis.close();
    }
}

2.7.案例:复制文本文件

需求:把“E:\\窗里窗外.txt”复制到模块目录下的“窗里窗外.txt"
分析:
①复制文本文件，其实就把文本文件的内容从一个文件中读取出来(数据源)，然后写入到另一个文件中(目的地)

数据源:

E:\\窗里窗外.txt —读数据— InputStream —FilelnputStream

目的地:

窗里窗外.txt—写数据— OutputStream -----FileOutputStream

思路:

①根据数据源创建字节输入流对象

②根据目的地创建字节输出流对象

③读写数据，复制文本文件(一次读取一个字节，一次写入一个字节)

④释放资源

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class CopyTxtDemo {
    public static void main(String[] args) throws IOException {
        //根据数据源创建字节输入流对象
        FileInputStream fis = new FileInputStream("E:\\窗里窗外.txt");
        //根据目的地创建字节输出流对象
        FileOutputStream fos = new FileOutputStream("窗里窗外.txt");
        //读写数据，复制文本文件(一次读取一个字节，一次写入一个字节)
        int by;
        while ((by=fis.read())!=-1){
            fos.write(by);
        }
        //释放资源
        fos.close();
        fis.close();
    }
}

2.8字节流读数据(一次读一个字节数组数据)

需求:把文件fos.txt中的内容读取出来在控制台输出

使用字节输入流读数据的步骤:
①创建字节输入流对象
②调用字节输入流对象的读数据方法
③释放资源

import java.io.FileInputStream;
import java.io.IOException;
import java.lang.String;

public class FileInputStreamDemo02 {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream("fos.txt");
//调用字节输入流对象的读数据方法
//int read (byte[] b)，从该输入流读取最多b.length个字节的数据到一个字节数组
//    byte[] bys =new byte[5];
//
//        //第一次读取数据
//        int len =fis.read(bys);
//        System.out.println(len);
//        //String (byte[] bytes)
//        System.out.println(new String(bys,0,len));
//
//        //第二次读取数据
//        len =fis.read(bys);
//        System.out.println(len);
//        System.out.println(new String(bys,0,len));
//
//        //第三次读取数据
//        len =fis.read(bys);
//        System.out.println(len);
        //String (byte[] bytes, int offset， int length)
//        System.out.println(new String(bys,0,len));
        byte[] bys = new byte[1024];//1024及其整数倍
        int len;
        while ((len = fis.read(bys)) != -1) {
            System.out.println(new String(bys,0,len));

        }
    //释放资源
        fis.close();
    }
}
/*
hello
world
*/

2.9.案例复制图片

需求:把“E:\litcastlImn.jpg”复制到模块目录下的“mn.jpg"

思路:

①根据数据源创建字节输入流对象

②根据目的地创建字节输出流对象

③读写数据，复制图片(一次读取一个字节数组，一次写入一个字节数组)

④释放资源

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class CopyJpgDemo {
    public static void main(String[] args) throws IOException {
        //根据数据源创建字节输入流对象
        FileInputStream fis = new FileInputStream("D:\\Backup\\我的文档\\My Pictures\\Saved Pictures\\mn.jpg");
        //根据目的地创建字节输出流对象
        FileOutputStream fos = new FileOutputStream("mn.jpg");

        //读取数据,复制图片(一次读取一个字节数组,一次写入一个字节数组)
        byte[] bys = new byte[1024];
        int len;
        while ((len = fis.read(bys)) != -1) {
            fos.write(bys, 0, len);
        }
        //释放资源
        fos.close();
        fis.close();
    }
}

2.10.字节缓冲流

字节缓冲流:

  • BufferOutputStream: 该类实现缓冲输出流。通过设置这样的输出流，应用程序可以向底层输出流写入字节，而不必为写入的每个字节导致底层系统的调用

  • BufferedInputStream: 创建Bufferedlnputstream将创建一个内部缓冲区数组。当从流中读取或跳过字节时，内部缓冲区将根据需要从所包含的输入流中重新填充，一次很多字节

构造方法:

  • 字节缓冲输出流: BufferedOutputStream(OutputStream out)
  • 字节缓冲输入流: BufferedInputStream(InputStream in)

为什么构造方法需要的是字节流，而不是具体的文件或者路径呢?

  • 字节缓冲流仅仅提供缓冲区，而真正的读写数据还得依靠基本的字节流对象进行操作
import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;

public class BufferStreamDemo {
    public static void main(String[] args) throws IOException {
//        字节缓冲输出流: BufferedOutputStream(OutputStream out)
/*        FileOutputStream fos = new FileOutputStream("bos.txt");
          BufferedOutputStream bos = new BufferedOutputStream(fos);*/
/*
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("bos.txt"));
        //写数据
        bos.write("hello\r\n".getBytes());
        bos.write("world\r\n".getBytes());
        bos.close();*/
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("bos.txt"));
        //读数据
        //一次读取一个字节数据
/*        int by;
        while ((by=bis.read())!=-1){
            System.out.print((char) by);
        }
        System.out.println("-----");
        bis.close();*/
//      一次读取一个字节数据的数据
        byte[] bys = new byte[1024];
        int len;
        while ((len=bis.read(bys))!=-1){
            System.out.println(new String(bys,0,len));

        }
        bis.close();
    }
}

2.11.复制视频(改成了gif图)

需求:把“E:字节流复制图片.avi”复制到模块目录下的“字节流复制图片.aviT

思路:

①根据数据源创建字节输入流对象

②根据目的地创建字节输出流对象

③读写数据，复制视频

④释放资源

1.基本字节流一依读写一个字节

/*
    四种方式实现复制视频,并记录每种方式复制视频的时间
        1.基本字节流一依读写一个字节 共耗时: 4986毫秒
        2.基本字节流一次读写一个字节数组 共耗时: 5253毫秒
        3.字节缓冲流一次读写一个字节	共耗时: 54毫秒
        4.字节缓冲流一次读写—个字节数组 共耗时: 5毫秒
*/

import java.io.*;

public class CopyVideo {
    public static void main(String[] args) throws IOException {
        //记录开始时间
        long startTime = System.currentTimeMillis();

        //复制视频
//        method1();
//        method2();
//        method3();
          method4();


        //记录结束时间
        long endTime = System.currentTimeMillis();
        System.out.println("共耗时: " + (endTime - startTime) + "毫秒");
    }
    //        4.字节缓冲流一次读写—个字节数组
    public static void method4() throws IOException {
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("D:\\Backup\\我的文档\\My Pictures\\Saved Pictures\\上个图很难吗.gif"));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("上个图很难吗.gif"));

        byte[] bys = new byte[1024];
        int len;
        while ((len=bis.read(bys))!=-1){
            bos.write(bys,0,len);

        }
        bos.close();
        bis.close();
    }
    //        3.字节缓冲流一次读写一个字节
    public static void method3() throws IOException {
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("D:\\Backup\\我的文档\\My Pictures\\Saved Pictures\\上个图很难吗.gif"));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("上个图很难吗.gif"));
        int by;
        while ((by = bis.read()) != -1) {
            bos.write(by);
        }
        bos.close();
        bis.close();
    }

    public static void method2() throws IOException {
        FileInputStream fis = new FileInputStream("D:\\Backup\\我的文档\\My Pictures\\Saved Pictures\\上个图很难吗.gif");
        FileOutputStream fos = new FileOutputStream("上个图很难吗.gif");

        byte[] bys = new byte[1024];
        int len;
        while ((len = fis.read()) != -1) {
            fos.write(bys, 0, len);
        }
        fos.close();
        fis.close();
    }

    public static void method1() throws IOException {
        FileInputStream fis = new FileInputStream("D:\\Backup\\我的文档\\My Pictures\\Saved Pictures\\上个图很难吗.gif");
        FileOutputStream fos = new FileOutputStream("上个图很难吗.gif");

        int by;
        while ((by = fis.read()) != -1) {
            fos.write(by);
        }
        fos.close();
        fis.close();
    }
}

24.3.字符流

3.1.为什么会出现字符流

由于字节流操作中文不是特别的方便，所以Java就提供字符流

字符流=字节流＋编码表

用字书流复制文本文件时，文本文件也会有中文，但是没有问题，原因是最终底层操作会自动进行字节拼接成中文，如何识别是中文的呢?

  • 汉字在存储的时候，无论选择哪种编码存储，第一个字节都是负

3.2.编码表

基础知识:

  • 计算机中储存的信息都是用二进制数表示的;我们在屏幕上看到的英文、汉字等字符是二进制丁转换之后的结果

  • 按照某种规则，将字符存储到计算机中，称为编码。反之，将存储在计算机中的二进制数按照某种规则解析显示出来，称为解码。这里强调一下:按照A编码存储，必须按照A编码解析，这样才能显示正确的文本符号。否则就会导致乱码现象

    字符编码:就是一套自然语言的字符与二进制数之间的对应规则(A65)

字符集:

  • 是一个系统支持的所有字符的集合，包括各国家文字、标点符号、图形符号、数字等

  • 计算机要准确的存储和识别各种字符集符号，就需要进行字符编码，一套字符集必然至少有一套字符编码。常见字符集有ASCII字符集、GBXXX字符集、Unicode字符集等

ASCIl字符集:

  • ASCII(American Standard Code for Information Interchange，美国信息交换标准代码):是基于拉丁字母的一套电脑编码系统，用于显示现代英语，主要包括控制字符(回车键、退格、换行键等)和可显示字符(英文大小写字符、阿拉伯数字和西文符号)

  • 基本的ASCII字符集，使用7位表示一个字符，共128字符。ASCII的扩展字符集使用8位表示一个字符，共256字符，方便支持欧洲常用字符。是一个系统支持的所有字符的集合，包括各国家文字、标点符号、图形符号、数字等

GBXXX字符集:

  • GB2312:简体中文码表。一个小于127的字符的意义与原来相同，但两个大于127的字符连在一起时，就表示一个汉字，这样大约可以组合了包含7000多个简体汉字，此外数学符号、罗马希腊的字母、日文的假名等都编进去了，连在ASCII里本来就有的数字、标点、字母都统统重新编了两个字节长的编码，这就是常说的"全角"字符，而原来在127号以下的那些就叫"半角"字符了

  • ==GBK:==最常用的中文码表。是在GB2312标准基础上的扩展规范，使用了双字节编码方案，共收录了21003个汉字，完全兼容GB2312标准，同时支持繁体汉字以及日韩汉字等

  • GB18030:最新的中文码表。收录汉字70244个，采用多字节编码，每个字可以由1个、2个或4个字节组成。支持中国国内少数民族的文字，同时支持繁体汉字以及日韩汉字等

Unicode字符集:

  • 为表达任意语言的任意字符而设计，是业界的一种标准，也称为统一码、标准万国码。它最多使用4个字节的数字来表达每个字母、符号，或者文字。有三种编码方案，UTF-8、UTF-16和UTF32。最为常用的UTF-8编码

  • UTF-8编码:可以用来表示Unicode标准中任意字符，它是电子邮件、网页及其他存储或传送文字的应用中，优先采用的编码。互联网工程工作小组(IETF）要求所有互联网协议都必须支持UJTF-8编码。它使用—至四个字节为每个字符编码

    编码规则:

    ​ 128个US-ASCII字符，只需一个字节编码

    ​ 拉丁文等字符，需要二个字节编码

    ​ 大部分常用字(含中文)，使用三个字节编码

    ​ 其他极少使用的Unicode辅助字符，使用四字节编码

小结:采用何种规则编码,就要采用对应规则解码,否则就会出现乱码

3.3.字符串中的编码解码问题

编码:

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

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

解码:

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

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

import java.io.UnsupportedEncodingException;
import java.util.Arrays;

public class StringDemo {
    public static void main(String[] args) throws UnsupportedEncodingException {
        //定义一个字符串
        String s = "中国";
//      byte[]getBytes():使用平台的默认字符集将该String编码为一系列字节，将结果存储到新的字节数组中

//        byte[] bys = s.getBytes();//[-28, -72, -83, -27, -101, -67]

//       byte[] bys = s.getBytes("UTF-8");//[-28, -72, -83, -27, -101, -67]
        byte[] bys = s.getBytes("GBK");//[-42, -48, -71, -6]
        System.out.println(Arrays.toString(bys));

//        String(byte[] bytes):通过使用平台的默认字符集解码指定的字节数组来构造新的String
//        String ss = new String(bys);

//        String(byte[] bytes, String charsetName):通过指定的字符集解码指定的字节数组来构造新的String
//        String ss = new String(bys,"UTF-8");平台默认字符集
        String ss = new String(bys,"GBK");
        System.out.println(ss);
    }
}
/*
[-42, -48, -71, -6]
中国
*/

3.4.字符流中的编码解码问题

字符流抽象基类

  • Reader: 字符输入流的抽象类
  • Writer:字符输出流的抽象类

字符流中和编码解码问题相关的两个类:

  • lnputStreamReader

  • OutputStreamWriter

import java.io.*;

public class ConversionStreamDemo {
    public static void main(String[] args) throws IOException {
/*      OutputStreamWriter (OutputStream out）创建一个使用默认字符编码的outputStreamWriter。
        OutputStreamWriter (OutputStream out，String chorsetName)创建一个使用命名字符集的outputStreamWriter*/
//        FileOutputStream fos = new FileOutputStream("osw.txt");
//        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("osw.txt"));//中国
//        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("osw.txt"),"UTF-8");//中国
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("osw.txt"), "GBK");//�й�
        osw.write("中国");
        osw.close();

/*      InputStreamReader (InputStream in)创建一个使用默认字符集的InputStreamReader。
        InputStreamReader (InputStream in，String charsetName)创建一个使用命名字符集的InputStreamReader。*/
        //GBk写的GBK的编码方式读
        InputStreamReader isr = new InputStreamReader(new FileInputStream("osw.txt"),"GBK");
        //一次读取一个字符数据
        int ch;
        while ((ch = isr.read()) != -1) {
            System.out.print((char)ch);
        }
        isr.close();
    }
}
/*
中国
*/

3.5字符流写数据的5中方式

方法名说明
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)写一个字符串的一部分
方法名说明
flush()刷新流,还可以继续写数据
close()关闭流,释放资源,但是在关闭之前会先刷新流.一旦关闭,就不能再写数据

void write(int c) 写一个字符

/*构造方法:
   OutputStreamWriter (OutputStream out):创建一个使用默认字符编码的OutputStreamWriter*/

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;

public class OutputStreamWriterDemo {
    public static void main(String[] args) throws IOException {
    //   OutputStreamWriter (OutputStream out):创建一个使用默认字符编码的OutputStreamWriter*/
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("osw.txt"));

        //void write(int c)写一个字符
        osw.write(97);
        //viod flush();刷新流
        osw.flush();
        osw.write(98);
        osw.flush();
        osw.write(100);
        
        osw.close();
    }
}

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

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;

public class OutputStreamWriterDemo {
    public static void main(String[] args) throws IOException {
    //   OutputStreamWriter (OutputStream out):创建一个使用默认字符编码的OutputStreamWriter*/
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("osw.txt"));

//        void write(char[] cbuf)写入一个字符数组
        char[] chs = {'a','b','c','d','e'};
        osw.write(chs);

        osw.close();
    }
}

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

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;

public class OutputStreamWriterDemo {
    public static void main(String[] args) throws IOException {
    //   OutputStreamWriter (OutputStream out):创建一个使用默认字符编码的OutputStreamWriter*/
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("osw.txt"));

        char[] chs = {'a','b','c','d','e'};
//        void write(char[] cbuf, int off, int len)写入字符数组的一部分
//          osw.write(chs,0,chs.length);
            osw.write(chs,1,3);
        osw.close();
    }
}

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

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;

public class OutputStreamWriterDemo {
    public static void main(String[] args) throws IOException {
    //   OutputStreamWriter (OutputStream out):创建一个使用默认字符编码的OutputStreamWriter*/
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("osw.txt"));

        char[] chs = {'a','b','c','d','e'};

//        void write(String str)  写一个字符串
            osw.write("abcdef");

        osw.close();
    }
}

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

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;

public class OutputStreamWriterDemo {
    public static void main(String[] args) throws IOException {
    //   OutputStreamWriter (OutputStream out):创建一个使用默认字符编码的OutputStreamWriter*/
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("osw.txt"));
        
        char[] chs = {'a','b','c','d','e'};
//void write(String str, int off, int len)  写一个字符串的一部分
//        osw.write("abcdef",0,"abcdef".length());
            osw.write("abcdef",1,3);

        osw.close();
    }
}

3.6.字符流读数据的两种方式

方法名说明
int read()一次读一个字符数据
int read(char[] cbuf)一次读一个字符数组数据

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

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;

public class InputStreamReaderDemo {
    public static void main(String[] args)throws IOException {
        InputStreamReader isr = new InputStreamReader(new FileInputStream("osw.txt"));
   int ch;
        while ((ch=isr.read())!=-1){
            System.out.print((char)ch);
        }
    isr.close();
    }
}
/*
hello
world
java
*/

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

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;

public class InputStreamReaderDemo {
    public static void main(String[] args) throws IOException {
        InputStreamReader isr = new InputStreamReader(new FileInputStream("osw.txt"));

        char[] chs = new char[1024];
        int len;
        while ((len = isr.read(chs)) != -1) {
            System.out.print(new String(chs, 0, len));
        }
        isr.close();
    }
}
/*
hello
world
java
*/

3.7.案例复制java文件

需求:把模块目录下的student.java复制到模块目录下的 Copy.java

思路:

1:根据数据源创建字符输入流对象

2:根据目的地创建字符输出流对象

3:读写数据，复制文件

4:释放资源

import java.io.*;

public class CopyJavaDemo01 {
    public static void main(String[] args) throws IOException {
//      1.根据数据源创建字符输入流对象
        InputStreamReader isr = new InputStreamReader(new FileInputStream("E:\\javastudent\\src\\com\\java2\\ArrayText\\Student.java"));
//      2:根据目的地创建字符输出流对象
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("Copy.java"));

        //读写数据,复制文件
        //一次读写一个字符数据
/*        int ch;
        while ((ch=isr.read())!=-1){
            osw.write(ch);
        }*/
        
     //一次读写一个字符数据数组
        char[] chars = new char[1024];
        int len;
        while ((len=isr.read(chars ))!=-1) {
            osw.write(chars, 0, len);

        }
        isr.close();
        osw.close();
    }
}

3.8.案例复制java文件(改进版)

分析:

①转换流的名字比较长，而我们常见的操作都是按照本地默认编码实现的，所以，为了简化书写，转换流提供了对应的子类

②FileReader:用于读取字符文件的便捷类

​ FileReader(String fileName)

③FileWriter:用于写入字符文件的便捷类

​ FileWriter(String fileName)

④数据源和目的地的分析

​ 数据源: “E:\javastudent\src\com\java2\ArrayText\Student.java”–读数据----Reader — InputStreamReader— FileReader

​ 目的地: Student.java—写数据— Writer —OutputStreamWriter—FileWriter

需求:把模块目录下的student.java复制到模块目录下的 Copy.java

思路:
①根据数据源创建字符输入流对象

②根据目的地创建字符输出流对象

③读写数据,复制文件

④释放资源

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class CopyJavaDemoUp {
    public static void main(String[] args) throws IOException {
        //根据数据源创建字符输入流对象
        FileReader fr = new FileReader("E:\\javastudent\\src\\com\\java2\\ArrayText\\Student.java");
        //根据目的地创建字符输出流对象
        FileWriter fw = new FileWriter("Copy.java");
        //读写数据,复制文件
/*        int ch;
        while ((ch=fr.read())!=-1){
            fw.write(ch);
        }*/
        char[] ch = new char[1024];
        int len;
        while ((len = fr.read(ch)) != -1){
            fw.write(ch,0,len);
        }
            //释放资源
            fr.close();
        fw.close();
    }
}

3.9.字符缓冲流

字符缓冲流:

  • BufferedWriter:将文本写入字符输出流，缓冲字符，以提供单个字符，数组和字符串的高效写入，可以指定缓冲区大小，或者可以接受默认大小。默认值足够大，可用于大多数用途

  • BufferedReader:从字符输入流读取文本，缓冲字符，以提供字符，数组和行的高效读取，可以指定缓冲区大小，或者可以使用默认大小。默认值足够大，可用于大多数用途

构造方法:

  • BufferedWriter(Writer out)

  • BufferedReader(Reader in)

import java.io.*;

/*
构造方法:
      BufferedWriter(Writer out)

      BufferedReader(Reader in)
*/
public class BufferedStreamDemo01 {
    public static void main(String[] args) throws IOException {
        //  BufferedWriter(Writer out)
/*        BufferedWriter bw = new BufferedWriter(new FileWriter("bw.txt"));
        bw.write("hello\r\n");
        bw.write("world\r\n");
        bw.write("java\r\n");
        bw.close();*/
//      BufferedReader(Reader in)
        BufferedReader br = new BufferedReader(new FileReader("bw.txt"));
        //一次读一个字符数据
/*        int ch;
        while ((ch = br.read()) != -1) {
            System.out.print((char) ch);
        }*/
        
        //一次读取一个字符数据数组
        char[] chs = new char[1024];
        int len;
        while ((len = br.read(chs))!= -1) {
            System.out.println(new String(chs,0,len));
        }
        br.close();
    }
}

3.10.案例复制java文件(字符缓冲流改进版)

需求:把模块目录下的student.java复制到模块目录下的 Copy.java

思路:

①根据数据源创建字符缓冲输入流对象

②根据目的地创建字符缓冲输出流对象

③读写数据，复制文件

④释放资源

import java.io.*;

public class CopyJavaDemo {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new FileReader("E:\\javastudent\\src\\com\\Java1\\Text5\\StudentManager.java"));
        BufferedWriter bw = new BufferedWriter(new FileWriter("StudentManager.java"));

/*        int ch;
        while ((ch=br.read())!=-1){
            bw.write(ch);
        }*/
        char[] chs = new char[1024];
        int len;
        while ((len=br.read(chs))!=-1){
            bw.write(chs,0,len);
        }


        br.close();
        bw.close();
    }
}

3.11.字符缓冲流特有功能

BufferedWriter:

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

BufferedReader:

  • public String readLine():读一行文字。结果包含行的内容的字符串，不包括任何行终止字符，如果流的结尾已经到达，则为null
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class BufferedStreamDemo02 {
    public static void main(String[] args) throws IOException {
/*        BufferedWriter bw = new BufferedWriter(new FileWriter("bw.txt"));

        for (int i = 0; i < 10; i++) {
            bw.write("hello" + i);
//    void newLine():写一行行分隔符，行分隔符字符串由系统属性定义
            bw.newLine();//万用换行

            bw.flush();
        }
        bw.close();*/
        BufferedReader br = new BufferedReader(new FileReader("bw.txt"));
//        public String readLine()读一行文字。结果包含行的内容的字符串，不包括任何行终止字符，如果流的结尾已经到达，则为null

        String line;
        while ((line = br.readLine()) != null) {
            System.out.println(line);
        }
        br.close();
    }
}

3.12.案例复制java文件(字符缓冲流特有的功能改进版)

import java.io.*;

public class CopyJavaDemo02 {
    public static void main(String[] args) throws IOException {
        //根据数据源创建字符缓冲流输入流对象
        BufferedReader br = new BufferedReader(new FileReader("E:\\javastudent\\src\\com\\Java1\\Text5\\StudentManager.java"));
        //根据目的地创建字符缓冲流输出流对象
        BufferedWriter bw = new BufferedWriter(new FileWriter("Copy.java"));
        //读取数据复制文件,使用字符缓冲流特有的功能实现
        String line;
        while ((line = br.readLine()) != null) {
            bw.write(line);//写数据
            bw.newLine();//写换行符
            bw.flush();//刷新流
        }
        //释放资源
        br.close();
        bw.close();
    }
}

3.13.IO流小结

字节流

在这里插入图片描述

在这里插入图片描述

字符流

在这里插入图片描述

在这里插入图片描述

24.4.字符流案例

4.1.案例:集合到文件

需求:把ArrayList集合中的字符串数据写入到文本文件。要求:每一个字符串元素作为文件中的一行数据

思路:

①创建ArrayList集合

②往集合中存储字符串元素

③创建字符缓冲输出流对象

④遍历集合，得到每一个字符串数据

⑤调用字符缓冲输出流对象的方法写数据释放资源

⑥释放资源

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;

public class ArrayListToTxtDemo {
    public static void main(String[] args) throws IOException {
        //创建ArrayList集合
        ArrayList<String> array = new ArrayList<>();

        //往集合中储存字符串元素
        array.add("hello");
        array.add("world");
        array.add("java");
        //创建字符缓冲输出流对象
        BufferedWriter bw = new BufferedWriter(new FileWriter("array.txt"));
        //遍历集合记得字符串的数据
        for (String s :array){
           //调用字符缓冲输出流对象的方法写数据
            bw.write(s);
            bw.newLine();
            bw.flush();
        }
        bw.close();
    }

4.2.案例:文件到集合

需求:把文本文件中的数据读取到集合中，并遍历集合。要求:文件中每一行数据是一个集合元素

思路:
①创建字符缓冲输入流对象

②创建ArrayList集合对象

③调用字符缓冲输入流对象的方法读数据

④把读取到的字符串数据存储到集合中

⑤释放资源

⑥遍历集合

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;

public class TxtToArrayListDemo {
    public static void main(String[] args) throws IOException {
        //创建字符缓冲流对象
        BufferedReader br = new BufferedReader(new FileReader("array.txt"));
        ArrayList<String> array = new ArrayList<>();
        //调用字符缓冲输入流对象的方法读取数据
        String line;
        while ((line=br.readLine())!=null){
            //把读取到的字符串数据储存到集合中
            array.add(line);
        }
            br.close();
        for (String s :array ){
            System.out.println(s);
        }
    }
}

4.3.案例:点名器

需求:我有一个文件里面存储了班级同学的姓名，每一个姓名占一行，要求通过程序实现随机点名器.

思路:

①创建字符缓冲输入流对象

②创建ArrayList集合对象

③调用字符缓冲输入流对象的方法读数据

④把读取到的字符串数据存储到集合中

⑤释放资源

⑥使用Random产生一个随机数，随机数的范围在:[O,集合的长度)

⑦把第6步产生的随机数作为索引到ArrayList集合中获取值

⑧把第7步得到的数据输出在控制台

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Random;

public class CallNameDemo {
    public static void main(String[] args)throws IOException {
        //创建字符缓冲输入流对象
        BufferedReader br = new BufferedReader(new FileReader("name.txt"));
        ArrayList<String> array = new ArrayList<>();

        //调用字符缓冲输入流对象的方法读数据
        String line;
        while ((line=br.readLine())!=null){
            array.add(line);
        }
        br.close();
        Random r =new Random();
        int index = r.nextInt(array.size());
//        ⑦把第6步产生的随机数作为索引到ArrayList集合中获取值
        String name = array.get(index);
//        ⑧把第7步得到的数据输出在控制台
        System.out.println("幸运者是, "+ name);
    }
}
/*
幸运者是, 小小
*/

幽鬼
裂魂人
德鲁伊
月之女祭司
昆卡
小小
马格纳斯
哈斯卡
路西法
卡尔

4.4.案例:集合到文件(改进版)

需求:把ArrayList集合中的学生数据写入到文本文件。要求:每一个学生对象的数据作为文件中的一行数据

格式:学号,姓名,年龄,居住地 举例:itheima001,林青霞,30,西安

思路:

①定义学生类

②创建ArrayList集合

③创建学生对象

④把学生对象添加到集合中

⑤创建字符缓冲输出流对象

⑥遍历集合，得到每一个学生对象

⑦把学生对象的数据拼接成指定格式的字符串⑧调用字符缓冲输出流对象的方法写数据

⑧释放资源

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;

public class ArrayLIstToFileDemo {
    public static void main(String[] args) throws IOException {
        ArrayList<Student> array = new ArrayList<>();
        Student s1 = new Student("001", "卡尔", 300, "西安");
        Student s2 = new Student("002", "昆卡", 30, "武汉");
        Student s3 = new Student("003", "蓝猫", 20, "杭州");
        array.add(s1);
        array.add(s2);
        array.add(s3);

        BufferedWriter bw = new BufferedWriter(new FileWriter("student.txt"));

        for (Student s : array) {
            //把学生对象的数据拼接成指定格式的字符串
            StringBuffer sb = new StringBuffer();
            sb.append(s.getSid()).append(", ").append(s.getName()).append(", ").append(s.getAge()).append(", ").append(s.getAddress());
            bw.write(sb.toString());
            bw.newLine();
            bw.flush();
        }
        bw.close();
    }
}

public class Student {
    private String sid;
    private String name;
    private int age;
    private String address;

    public Student() {
    }

    public Student(String sid, String name, int age, String address) {
        this.sid = sid;
        this.name = name;
        this.age = age;
        this.address = address;
    }

    public String getSid() {
        return sid;
    }

    public void setSid(String sid) {
        this.sid = sid;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }
}

4.5.案例:文件到集合(改进版)

需求:把文本文件中的数据读取到集合中，并遍历集合。要求:文件中每一行数据是一个学生对象的成员变量值

​ 举例: itheima001,林青霞,30,西安

思路:

①定义学生类

②创建字符缓冲输入流对象

③创建ArrayList集合对象

④调用字符缓冲输入流对象的方法读数据

⑤把读取到的字符串数据用split()进行分割,得到一个字符串数组

⑥创建学生对象

⑦把字符串数组中的每一个元素取出来对应的赋值给学生对象的成员变量值

⑧把学生对象添加到集合

⑨释放资源

⑩遍历集合

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;

public class FileToArrayListDemo {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new FileReader("student.txt"));
        //创建集合
        ArrayList<Student> array = new ArrayList<>();

//        ④调用字符缓冲输入流对象的方法读数据
        String line;
        while ((line = br.readLine()) != null) {
//            把读取到的字符串数据用split()进行分割,得到一个字符串数组
            String[] strArray = line.split(",");

//            创建学生对象
            Student s = new Student();
//            把字符串数组中的每一个元素取出来对应的赋值给学生对象的成员变量值
            s.setSid(strArray[0]);
            s.setName(strArray[1]);
            s.setAge(Integer.parseInt(strArray[2]));
            s.setAddress(strArray[3]);
//           把学生对象添加到集合
            array.add(s);
        }
        br.close();
        for (Student s : array) {
            System.out.println(s.getSid() + ", " + s.getName() + ", " + s.getAge() + ", " + s.getAddress());
        }
    }
}
/*
001,  卡尔, 48, 西安
002,  昆卡, 30, 武汉
003,  蓝猫, 20, 杭州
*/

student.txt

001, 卡尔,48,西安
002, 昆卡,30,武汉
003, 蓝猫,20,杭州
奇犽0.0
关注
专栏目录
基本字节流（FileOutputStream，FileInputStream）
林高禄
05-09 8760
FileOutputStream 创建字节输出流对象（调用系统功能创建文件，创建字节输出流对象，让字节输出流对象指向文件） 调用字节输出流对象的写数据方法 释放资源（关闭此文件输出流并释放与此流相关联的任何系统资源） package com.testIO; import java.io.*; /** * @author 林高禄 * @create 2020-05-09-11:10 */ public class FileOutputStreamDemo { public st.
python 异步io_Python通过select实现异步IO的方法
weixin_39788256的博客
11-29 120
本文实例讲述了Python通过select实现异步IO的方法。分享给大家供大家参考。具体如下：在Python中使用select与poll比起在C中使用简单得多。select函数的参数是3个列表，包含整数文件描述符，或者带有可返回文件描述符的fileno()方法对象。第一个参数是需要等待输入的对象，第二个指定等待输出的对象，第三个参数指定异常情况的对象。第四个参数则为设置超时时间，是一个浮点数。指定...
python 管道 异步读取 select_Python使用select实现异步通信
weixin_39791225的博客
12-20 153
当一个服务器需要与多个客户端进行通信时，可以使用多进程或者多线程的服务器，也可以使用select模块，它可以实现异步通 信。Python中的select模块包含了poll()和select(),select的原型为 (rlist,wlist,xlist[,timeout]),其中rlist是等待读取的对象，wlist是等待写入的对象，xlist是等待异常的对 象，最后一个是可选对象，指定等待的时间...
IO流(1):基础字节流、字符流
超级无敌小胖头
03-25 317
文章目录一、IO概述1. 什么是IO?2. IO的分类2.1 按流动的方向分2.2 按数据的类型分3. IO流中的根类二、字节流1. 一切皆字节2. 字节输出流(抽象类)：OutputStream3. FileOutputStream3.1 构造方法3.2 写出字节数据3.2.1 写出单个字节3.2.2 写出字节数组3.2.3 写出指定起点和长度的字节数组3.3 数据追加续写(2个相关的构造方法...
基本字节流与字符流
AYtang_的博客
03-27 269
IO笔记 流：一组有序的字节集合，是数据在两个设备的传输个设备的传输 流的本质是数据传输，按照处理数据类型的不同，分为字节流 字符流 字节流以字节为单位，8bit ,包含两个抽象类 InputString OutoutString 字符流以字符为单位，根据码表映射字符，16bit,包含两个抽象类 Reader Writer （Unicode 中每个字符都使用了多个字节，所以字节流不适用于处理此类信...
java基础之IO流
06-18
### Java IO流基础知识点 #### 一、IO流概述 - **定义**：在Java中，IO流（Input/Output Streams）是用来处理输入输出的基本工具。流是一种有序的数据集合，通常涉及从源到目的地的数据传输过程。源可以是文件、...
Java_IO.rar_IO流 java_java io流
09-21
Java IO流是Java编程语言中处理输入输出的重要组成部分，它为数据传输提供了高效且灵活的方式。在Java中，IO流可以分为两类：字节流（处理单个字节）和字符流（处理Unicode字符）。此外，它们又可以分为四大类：输入...
Java基础篇：IO流.pdf
05-19
Java IO流是Java编程语言中用于处理输入输出操作的一个重要概念。它允许程序读取数据源或向数据目的地写入数据。Java中的IO流主要分为输入流和输出流两大类，每类又可以根据数据处理方式的不同细分为多种具体实现。...
java基础 IO流
09-05
java基础中的IO流是Java提供的一套用于文件读写操作的流式API，它包括字节流和字符流两种基本类型。字节流主要用在处理二进制数据，而字符流则是处理文本数据。 首先，文档中提到了`File`类，它是IO流操作中用于...
1、字节流详解
shiyu_951的博客
07-26 6565
Java IO 字节流详解
python调用其他程序并控制输入输出_python调用外部子进程，通过管道实现异步标准输入和输出的交互...
weixin_39706861的博客
11-21 417
我们通常会遇到这样的需求：通过C++或其他较底层的语言实现了一个复杂的功能模块，需要搭建一个基于Web的Demo，方法查询数据。由于Python语言的强大和简洁，其用来搭建Demo非常合适，Flask框架和jinja2模块功能为python提供了方便的web开发能力。同时，python能够很方便的同其他语言的代码交互。因此我们选择python作为开发Demo的工具。假设我们需要调用的模块（提供底层...
python_readlines()
01-02 244
# -*- coding: gbk -*- import paramiko import string import re ssh = paramiko.SSHClient() ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy()) ssh.connect("XX.XX.XX.XX",22,"root", "mi...
【Java】基本字节流输入输出类的使用
Hello, New World!
03-16 1048
文章目录1. 基本字节输入输出流实现类2. 输入输出字节流的分类3. 抽象父类：InputStream & OutputStream3.1 实现类：字节节点流 FileOutputStream & FileInputStream3.2 实现类：字节过滤流（缓冲流）BufferedOutputStream & BufferedInputStream3.3 实现类：字节过滤流（...
python 管道 异步读取 stdout select_如何从subprocess.Popen.stdout（非阻塞）读取所有可用数据？...
weixin_40002238的博客
12-20 372
对Popen的stdout进行增量解析并不是一个真正的问题。只需在线程中插入一个管道，并让它在输出中移动，寻找分隔符。根据您的偏好，它可以将其导入另一个类似管道/文件的管道，或者以异步模式将解析的“块”放在“堆栈”上。下面是基于自定义分隔符的stdout异步“分块”示例：import cStringIOimport uuidimport threadingimport osclass InputS...
python stdout.read()阻塞_python - stdout readline（）阻塞 - 堆栈内存溢出
weixin_39768917的博客
12-10 1283
我正在尝试通过Python 2.7运行Minecraft服务器，并且工作正常。 但是，当我尝试将其传递给stop命令时，它直到服务器输出某些内容后才执行任何操作。这是我的代码：import os, sys, subprocess, threading, timeclass Server:def start(self):t = threading.Thread(target=self.run)t....
Python 利用多线程实时读取subprocess.Popen的程序输出的stdout和stderr，并且向其中实时传入input信息。
weixin_41102672的博客
05-27 2569
有些时候我们想在图形界面中嵌入一个命令行，方便进行交互。但是获取程序的输入和输出是比较困难的,网上也很少有类似的教程。最后我综合了stackoverflow上的一些代码得出了结论。 设想以下的应用场景：想要写一个PythonIDE，这个IDE要带有Shell，也就是一个REPL环境。要求则是用subprocess.Popen创建一个新的Python的命令行解释器，将用户输入的文本发送给这个命令行解释器，然后把这个解释器的输出的文本发送到文本显示窗口。这样，运行图形界面的解释器就只有tkinter即可，真正的
python stdout timeout_Python：subprocess32 process.stdout.readline()等待时间
weixin_42431713的博客
02-03 952
如果我使用例如“ls -Rlah /”运行以下函数“run”,我会立即通过print语句获得输出import subprocess32 as subprocessdef run(command):process = subprocess.Popen(command,stdout=subprocess.PIPE,stderr=subprocess.STDOUT)try:while process.p...
python readline函数 阻塞_stdout readline（）阻塞
weixin_39581719的博客
02-09 2064
我试图通过python2.7运行minecraft服务器，它运行得很好。但是当我试图向它传递stop命令时，它不会做任何事情，直到服务器输出一些东西。在这是我的代码：import os, sys, subprocess, threading, timeclass Server:def start(self):t = threading.Thread(target=self.run)t.daemon...
Java基础教程：IO流详解
"Java基础知识，特别是关于IO流的整理，涵盖了File类的使用以及字节流和字符流的概念。这份文档包含对不同读取文件方法的示例代码，旨在帮助学习者理解Java中的输入/输出操作。" 在Java中，IO（Input/Output）流是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值