关于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();
 <b style="color:transparent">来源gao@dai!ma.com搞$代^码网</b>   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());
}

喜欢 (0)赏

[搞代码]

分享 (0)