java基础语言字符流

最新推荐文章于 2022-07-26 22:26:13 发布

奇犽0.0

最新推荐文章于 2022-07-26 22:26:13 发布

阅读量113

点赞数

分类专栏： java 基础 IO流文章标签： java 编程语言

本文链接：https://blog.csdn.net/guenping2020/article/details/110236366

版权

java 同时被 3 个专栏收录

6 篇文章 0 订阅

订阅专栏

基础

5 篇文章 0 订阅

订阅专栏

IO流

1 篇文章 0 订阅

订阅专栏

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

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java基础语言字符流

24.3.字符流3.1.为什么会出现字符流由于字节流操作中文不是特别的方便，所以Java就提供字符流字符流=字节流＋编码表用字书流复制文本文件时，文本文件也会有中文，但是没有问题，原因是最终底层操作会自动进行字节拼接成中文，如何识别是中文的呢?汉字在存储的时候，无论选择哪种编码存储，第一个字节都是负3.2.编码表基础知识:计算机中储存的信息都是用二进制数表示的;我们在屏幕上看到的英文、汉字等字符是二进制丁转换之后的结果按照某种规则，将字符存储到计算机中，称为编码。反之，将存储在
复制链接

扫一扫

专栏目录