关于java:字符流-字符缓冲流-IO流小结-案例集合到文件-案例文件到集合-案例点名器

字符流

字符流呈现起因

一个汉字如果是 GBK 编码，占用 2 字节，如果是 UTF- 8 编码，占用 3 个字节

编码表

字符集

采纳什么规定编码，就得采纳对应规定解码，否则就会呈现乱码

字符串中的编码解码问题

// 定义一个字符串
String s = "中国";

//byte[] getBytes(); 应用平台默认字符集将该 String 编码为一系列字节，将后果存储到新的字节数组中
byte[] bys = s.getBytes();
sout(Arrays.toString(bys));// 输入 -28 -72 -83 -27 -101 -67


//byte[] getBytes(String charsetName); 应用指定的字符集将该 String 编码为一系列字节，将后果存储到新的字节数组中
byte[] bys = s.getBytes(charsetName:"UTF-8");
sout(Arrays.toString(bys));// 输入 -28 -72 -83 -27 -101 -67

byte[] bys = s.getBytes(charsetName:"GBK");
sout(Arrays.toString(bys));// 输入 -42 -48 -71 -6

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

//String(byte[] bytes,String charsetName) 通过指定的字符集将该 String 编码为一系列字节，将后果存储到新的字节数组中
String ss = new String(bys,charsetName:"UTF-8");
sout(ss);

String ss = new String(bys,charsetName:"GBK");
sout(ss);

字符流中的编码解码问题

能够指定字符集
OutputStreamWriter 字符到字节，应用指定的编码将 写入的字符编码为字节，应用的字符集能够由名称指定，也能够被明确指定，或者应用默认的

FileOutputStream fos = new FileOutputStream(name:"myCharStream\osw.txt");
OutputStreamWriter osw = new OutputStreamWriter(fos);
// 简化一下
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(name:"myCharStream\osw.txt"));// 默认编码
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(name:"myCharStream\osw.txt",charsetName:"UTF-8"));// 指定编码

osw.write(str:"中国");
osw.close();

// 字节解码为字符
InputStreamReader isr = new InputStreamReader(new FileInputStream(name:"myCharStream\osw.txt"));// 默认编码

InputStreamReader isr = new InputStreamReader(new FileInputStream(name:"myCharStream\osw.txt",charsetName:"UTF-8"));// 指定编码

// 一次读取一个字符数据
int ch;
while((ch = isr.read()) != -1){System.out.print((char)by);
}
isr.close();

字符流写数据的 5 种形式

// 创立一个应用默认字符编码的 OutputStreamWriter
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(name:"myCharStream\osw.txt"));

//void write(int c) ** 写一个字符 **
osw.write(c:97);// 字符流写数据不能间接写到文件里去，当初还在缓冲区
//void flush() 刷新流
osw.flush();// 刷新一下数据就到文件里去了 要想写进去就得刷新


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


//void write(char[] cbuf,int off,int len) ** 写一个字符数组的一部分 **
osw.write(chs,off:0,chs.length);
osw.write(chs,off:1,len:3);// 从 1 索引开始写三个 就是 bcd

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

//void write(String str,int off,int len) ** 写一个字符串的一部分 **
osw.write(str:"abcde",off:0,chs.length);
osw.write(str:"abcde",off:1,len:3);// 从 1 索引开始写三个 就是 bcd

osw.close();// 敞开流会先刷新一下

flush 刷新后还能写，close 敞开前会刷新然而敞开了就不能写数据了

字符流读数据的 2 种形式

InputStreamReader isr = new InputStreamReader(new FileInputStream(name:"myCharStream\osw.txt"));// 默认编码

//int read(): 一次读一个字符数据
int ch;
while((ch = isr.read()) != -1){System.out.print((char)by);
}

//int read(char[] cubf): 一次读一个字符数组数据
char[] chs = new char[1024];
int len;
while((len = isr.read(chs)) != -1){System.out.print(new String(chs,offset:0,len));
}
isr.close();// 敞开流会先刷新一下

字节流和字符流读数据的形式是一样的

复制 java 文件

把模块目录下的 ”ConversionStreamDemo.java” 复制到模块目录下的 ”Copy.java”

// 数据源创立字符输出流对象
InputStreamReader isr = new InputStreamReader(new FileInputStream(name:"myCharStream\\ConversionStreamDemo.java"));// 默认编码

// 目的地创立字符输入流对象
OutputStreamWriter
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(name:"myCharStream\\Copy.java"));

// 读写数据复制文件
// 一次读写一个字符数据
int ch;
while((ch = isr.read()) != -1){osw.write(ch);
}

// 一次读写一个字符数组数据
char[] chs = new char[1024];
int len;
while((len = isr.read(chs)) != -1){osw.write(chs,off:0,len);
}

// 开释资源
osw.close();
isr.close();

复制 java 文件改进版

把模块目录下的 ”ConversionStreamDemo.java” 复制到模块目录下的 ”Copy.java”

// 数据源创立字符输出流对象
FileReader fr = new FileReader(fileName:"myCharStream\\ConversionStreamDemo.java");
// 目的地创立字符输入流对象
FileWriter fw = new FileWriter(fileName:"myCharStream\\Copy.java");

// 读写数据复制文件
// 一次读写一个字符数据
int ch;
while((ch = fr.read()) != -1){fw.write(ch);
}

// 一次读写一个字符数组数据
char[] chs = new char[1024];
int len;
while((len = fr.read(chs)) != -1){fw.write(chs,off:0,len);
}

// 开释资源
fw.close();
fr.close();

字符缓冲流

从字符输出流中读取文本，缓冲字符，能够指定缓冲区大小，或者应用默认大小

//BufferedWriter(Writer out)
FileWriter fw = new FileWriter(fileName:"myCharStream\\bw.txt");
BufferedWriter bw = new BufferedWriter(fw);

// 综合
BufferedWriter bw = new BufferedWriter(new FileWriter(fileName:"myCharStream\\bw.txt"));// 默认是 8192 字符的字符数组
bw.write(str:"hello\r\n");
bw.write(str:"world\r\n");
bw.close();

BufferedReader br = new BufferedReader(new FileReader(fileName:"myCharStream\\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.print(new String(chs,offset:0,len));
}

复制 java 文件 字符缓冲流改进版

把模块目录下的 ”ConversionStreamDemo.java” 复制到模块目录下的 ”Copy.java”

// 数据源创立字符输出流对象
BufferedReader br = new BufferedReader(new FileReader(fileName:"myCharStream\\ConversionStreamDemo.java"));
// 目的地创立字符输入流对象
BufferedWriter bw = new BufferedWriter(new FileWriter(fileName:"myCharStream\\Copy.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,off:0,len);
}

// 开释资源
bw.close();
br.close();

字符缓冲流特有性能

// 创立字符缓冲输入流
BufferedWriter bw = new BufferedWriter(new FileWriter(fileName:"myCharStream\\bw.txt"));
// 写数据
for(int i = 0;i < 10;i++){bw.write(str:"hello"+i);
    bw.write(str:"\r\n");
    // 或者不必下面的换行 用上面这种写法
    bw.newwLine();
    bw.flush();}


// 创立字符缓冲输出流
BufferedReader br = new BufferedReader(new FileReader(fileName:"myCharStream\\bw.txt"));
//public String readline(): 读一行文字
// 第一次读取数据 达到结尾就输入 null
String line = br.readLine();
sout(line);

// 循环改良
String line;
while((line = br.readLine())!=null){sout(line);// 不蕴含换行符
}
// 开释资源
bw.close();

复制 java 文件 字符缓冲流特有性能改进版

// 数据源创立字符输出流对象
BufferedReader br = new BufferedReader(new FileReader(fileName:"myCharStream\\ConversionStreamDemo.java"));
// 目的地创立字符输入流对象
BufferedWriter bw = new BufferedWriter(new FileWriter(fileName:"myCharStream\\Copy.java"));

// 读写数据复制文件
// 应用字符缓冲流特有性能实现
String line;
while((line = br.readLine())!=null){bw.write(line);// 不蕴含换行符 所有数据都在同一行
    bw.newwLine();
    bw.flush();}

// 开释资源
bw.close();
br.close();

IO 流小结

案例 汇合到文件

// 创立 ArrayList 汇合
ArrayList<String> array = new ArrayList<String>();
// 往汇合中存储字符串元素
array.add("Hello");
array.add("World");
array.add("Java");
// 目的地创立字符缓冲输入流对象
BufferedWriter bw = new BufferedWriter(new FileWriter(fileName:"myCharStream\\array.txt"));
// 遍历汇合，失去每一个字符串数据
for(String s；array){
    // 调用字符缓冲输入流对象的办法写数据
    bw.write(s);// 不蕴含换行符 所有数据都在同一行
    bw.newwLine();
    bw.flush();}
// 开释资源
bw.close();

案例 文件到汇合

// 数据源创立字符缓冲输出流对象
BufferedReader br = new BufferedReader(new FileReader(fileName:"myCharStream\\array.txt"));
// 创立 ArrayList 汇合对象
ArrayList<String> array = new ArrayList<String>();
// 调用字符缓冲输出流对象的办法读数据
String line;
while((line = br.readLine())!=null){array.add(line);
}
// 开释资源
br.close();
// 遍历汇合
for(String s；array){sout(s);
}

案例 点名器

// 数据源创立字符缓冲输出流对象
BufferedReader br = new BufferedReader(new FileReader(fileName:"myCharStream\\name.txt"));
// 创立 ArrayList 汇合对象
ArrayList<String> array = new ArrayList<String>();
// 调用字符缓冲输出流对象的办法读数据
String line;
while((line = br.readLine())!=null){
    // 把读取到的数据存储到汇合中
    array.add(line);
}
// 开释资源
br.close();
// 应用 Random 产生一个随机数，随机数的范畴在 0 - 汇合长度
Random r = new Random();
int index = r.nextInt(array.size());
// 把下面产生的随机数作为索引到汇合中获取值
String name = array.get(index);
// 输入
sout(name);

案例 汇合到文件改进版

// 创立 ArrayList 汇合
ArrayList<Student> array = new ArrayList<Student>();
// 创立学生对象
Student s1 = new Student(sid:"itheima001",name:"林青霞",age:"30",address:"西安");
Student s2 = new Student(sid:"itheima002",name:"张曼玉",age:"35",address:"武汉");
Student s3 = new Student(sid:"itheima003",name:"王祖贤",age:"33",address:"郑州");
// 把学生对象增加到汇合中
array.add(s1);
array.add(s2);
array.add(s3);
// 目的地创立字符缓冲输入流对象
BufferedWriter bw = new BufferedWriter(new FileWriter(fileName:"myCharStream\\Student.txt"));
// 遍历汇合，失去每一个学生对象
for(Student s；array){
    // 把学生对象的数据拼接成指定格局的字符串
    StringBuilder sb = new StringBuilder();
    sb.append(s.getSid()).append(",").append(s.getName()).append(",").append(s.getAge()).append(",").append(s.getAddress());
    // 调用字符缓冲输入流对象的办法写数据
    bw.write(sb.toString());// 不蕴含换行符 所有数据都在同一行
    bw.newwLine();
    bw.flush();}
// 开释资源
bw.close();

案例 文件到汇合改进版

// 数据源创立字符缓冲输出流对象
BufferedReader br = new BufferedReader(new FileReader(fileName:"myCharStream\\Student.txt"));
// 创立 ArrayList 汇合对象
ArrayList<Student> array = new ArrayList<Student>();
// 调用字符缓冲输出流对象的办法读数据
String line;
while((line = br.readLine())!=null){// 把读到的字符串数据用 split()进行宰割，失去一个字符串数组
    String[] strArray = line.split(reqex:",");
    // 创立学生对象
    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){sout(s.getSid()+","+s.getName()+","++s.getAge()+","+s.getAddress());
}