java 学习7.23 字符流出现的原因 String中的编解码问题 转换流

21.01_IO流(字符流出现的原因及编码表概述和常见编码表))

A: 案例演示:	字符流出现的原因:由于字节流操作中文不是特别方便，所以，java就提供了字符流。
B: 码表
C:字符流:  字符流 = 字节流 + 编码表

21.02_IO流(String类中的编码和解码问题)

编码: 就是把字符串转换成字节数组

- 把一个字符串转换成一个字节数组

- public byte[] getBytes();使用平台的默认字符集将此 String编码为 byte 序列，并将结果存储到一个新的 byte 数组中。 

- public byte[] getBytes(String charsetName) 使用指定的字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。 

- 

- 解码: 把字节数组转换成字符串

- public String(byte[] bytes):	通过使用平台的默认字符集解码指定的 byte 数组，构造一个新的 String。

- public String(byte[] bytes, String charsetName) 通过使用指定的 charset 解码指定的 byte 数组，构造一个新的 String。

- 

- 使用什么字符集进行编码,那么就是使用什么字符集进行解码

- 

- 老地方  ----- 十进制   ---- 二进制  ---- 发出去

- 

- 接收 ---- 二进制  ---- 十进制  --- 老地方

  A:案例演示
  	String类中的编码和解码问题
  	默认的字符集是GBK的
String(byte[] bytes, String charsetName):通过指定的字符集解码字节数组
byte[] getBytes(String charsetName):使用指定的字符集合把字符串编码为字节数组
 
编码:把看得懂的变成看不懂的:	String -- byte[]
解码:把看不懂的变成看得懂的:	byte[] -- String

21.03_IO流(转换流OutputStreamWriter的使用)(掌握)

A:OutputStreamWriter的构造方法
	OutputStreamWriter(OutputStream out):根据默认编码(GBK)把字节流的数据转换为字符流
	OutputStreamWriter(OutputStream out,String charsetName):根据指定编码把字节流数据转换为字符流
B:案例演示:	OutputStreamWriter写出数据
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;

public class test7 {
    public static void main(String[] args) throws IOException {
        OutputStreamWriter out=new OutputStreamWriter(new FileOutputStream("a.txt"));
        out.write("我很快乐");
        out.flush();//字符写入一般得刷新
        out.write("我很快乐");
        out.flush();
        out.close();

    }
}

21.04_IO流(字符流的5种写数据的方式)(掌握)

A: 方法概述
	public void write(int c) 写一个字符
	public void write(char[] cbuf) 写一个字符数组
	public void write(char[] cbuf,int off,int len) 写一个字符数组的 一部分
	public void write(String str) 写一个字符串
	public void write(String str,int off,int len) 写一个字符串的一部分

B:案例演示:	字符流的5种写数据的方式
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;

public class test4 {
    public static void main(String[] args) throws IOException {
        InputStreamReader in=new InputStreamReader(new FileInputStream("a.txt"));
        int len=in.read();//一次读取一个字符  返回值为字符
        System.out.println(len);
        char []chars=new char[1024];//字符数组  充当缓冲区
         len=in.read(chars);//返回值为实际取到的个数
        System.out.println(len);
        String s=String.valueOf(chars);//将字符数组转换成字符串


        System.out.println(len);
    }
}

21.05_IO流(转换流InputStreamReader的使用)(掌握)

A:InputStreamReader的构造方法
	InputStreamReader(InputStream is):用默认的编码(GBK)读取数据
	InputStreamReader(InputStream is,String charsetName):用指定的编码读取数据
B:案例演示:	InputStreamReader读取数据

import java.io.*;

public class test8 {
    public static void main(String[] args) throws IOException {
        InputStreamReader in=new InputStreamReader(new FileInputStream("a.txt"));
        OutputStreamWriter out=new OutputStreamWriter(new FileOutputStream("b.txt"));
        char []chars=new char[1024];
        int len=0;
        while((len=in.read(chars))!=-1)
        {
            out.write(chars);
            out.flush();
        }
        in.close();
        out.close();
    }
}

21.06_IO流(字符流的2种读数据的方式)(掌握)

A:	方法概述
	public int read() 一次读取一个字符
	public int read(char[] cbuf) 一次读取一个字符数组 如果没有读到 返回-1
A:案例演示:	字符流的2种读数据的方式

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

public class test3 {
    public static void main(String[] args) throws IOException {
        OutputStreamWriter out=new OutputStreamWriter(new FileOutputStream("a.txt"));
        out.write('你');
        out.flush();
        char []arr={'a','b','c','d'};
        String a="aaaaa";
        out.write(arr);
        out.flush();
        out.write(arr,0,2);
        out.flush();
        out.write(a);
        out.flush();
        out.write(a,0,3);
        out.close();

    }
}

21.07_IO流(字符流复制文本文件)(掌握)

A:案例演示:	字符流复制文本文件
import java.io.*;

public class test5 {
    public static void main(String[] args) throws IOException {
        InputStreamReader in=new InputStreamReader(new FileInputStream("b.txt"));
        OutputStreamWriter out=new OutputStreamWriter(new FileOutputStream("a.txt"));
        //读一个字符  写一个字符
        int len=0;
        while((len=in.read())!=-1)
        {
            out.write(len);
            out.flush();//字符流记得刷新一下
        }
        in.close();
        out.flush();
    }
}

21.08_IO流(FileWriter和FileReader复制文本文件)(掌握)

A:FileReader和FileWriter的出现
	转换流的名字比较长，而我们常见的操作都是按照本地默认编码实现的，
	所以，为了简化我们的书写，转换流提供了对应的子类。	
	FileWriter
	FileReader
B:案例演示:	FileWriter和FileReader复制文本文件

字符流便捷类:	因为转换流的名字太长了,并且在一般情况下我们不需要制定字符集,
                 于是java就给我们提供转换流对应的便捷类
    转换流							便捷类
- OutputStreamWriter	-------		FileWriter
- InputStreamReader	-------		FileReader

21.09_IO流(字符缓冲流的基本使用)(掌握)

A:案例演示:	BufferedWriter写出数据  高效的字符输出流

import java.io.*;

public class test6 {
    public static void main(String[] args) throws IOException {
        //高效的字符流
        //BufferedReader
        // BufferedWriter


        // BufferedReader从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。
        //
        // 可以指定缓冲区的大小，或者可使用默认的大小。大多数情况下，默认值就足够大了。
        BufferedReader bfr=new BufferedReader(new FileReader("a.txt"));
        BufferedWriter bfw=new BufferedWriter(new FileWriter("b.txt"));
        char []chars=new char[1024];
        int len=0;
        while((len=bfr.read(chars))!=-1)
        {
            bfw.write(chars);
            bfw.flush();
        }
        bfr.close();
        bfw.close();
    }
}

B:案例演示:	BufferedReader读取数据  高效的字符输入流

 高效的字符流
	  高效的字符输出流:	BufferedWriter
	  		     构造方法:	public BufferedWriter(Writer w)
	 高效的字符输入流:	BufferedReader
	 		    构造方法:   public BufferedReader(Reader e)

21.10_IO流(字符缓冲流复制文本文件)(掌握)

A:案例演示:	字符缓冲流复制文本文件
import java.io.*;

public class test7 {
    public static void main(String[] args) throws IOException {
        BufferedReader in=new BufferedReader(new FileReader("a.txt"));
        BufferedWriter out=new BufferedWriter(new FileWriter("b.txt"));
        String line=null;
        while((line=in.readLine())!=null)
        {
            out.write(line);
            out.newLine();//写出一个换行符
            out.flush();
        }
        in.close();
        out.close();
    }
}

21.11_IO流(字符缓冲流的特殊功能)(掌握)

A:字符缓冲流的特殊功能
	BufferedWriter:	public void newLine():根据系统来决定换行符 具有系统兼容性的换行符
	BufferedReader:	public String readLine()：一次读取一行数据  是以换行符为标记的 读到换行符就换行 没读到数据返回null
		包含该行内容的字符串，不包含任何行终止符，如果已到达流末尾，则返回 null
B:案例演示:	字符缓冲流的特殊功能
import java.io.*;

public class test7 {
    public static void main(String[] args) throws IOException {
        BufferedReader in=new BufferedReader(new FileReader("a.txt"));
        BufferedWriter out=new BufferedWriter(new FileWriter("b.txt"));
        String line=null;
        while((line=in.readLine())!=null)
        {
            out.write(line);
            out.newLine();//写出一个换行符
            out.flush();
        }
        in.close();
        out.close();
    }
}

21.15_IO流(把集合中的数据存储到文本文件)(掌握)

A:案例演示: 需求：把ArrayList集合中的字符串数据存储到文本文件
分析:
- a: 创建一个ArrayList集合
- b: 添加元素
- c: 创建一个高效的字符输出流对象
- d: 遍历集合,获取每一个元素,把这个元素通过高效的输出流写到文本文件中
- e: 释放资源


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

public class test8 {
    public static void main(String[] args) throws IOException {
        ArrayList<String>list=new ArrayList<>();
        list.add("张飞");
        list.add("赵云");
        list.add("马超");
        list.add("黄忠");
        list.add("关羽");
        FileWriter writer=new FileWriter("username");
        for(String s:list)
        {
            writer.write(s);
            writer.write("\r\n");
            writer.flush();
        }
        writer.close();
    }
}

21.16_IO流(把文本文件中的数据存储到集合中)(掌握)

A:案例演示:	需求：从文本文件中读取数据(每一行为一个字符串数据)到集合中，并遍历集合
分析:
	 * 		a: 创建高效的字符输入流对象
	 * 		b: 创建一个集合对象
	 * 		c: 读取数据(一次读取一行)
	 * 		d: 把读取到的数据添加到集合中
	 * 		e: 遍历集合
	 * 		f: 释放资源
	 
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;

public class test9 {
    public static void main(String[] args) throws IOException {
        ArrayList<String >list=new ArrayList<>();
        BufferedReader in=new BufferedReader(new FileReader("username"));
        String line=null;
        while((line=in.readLine())!=null)
        {
            list.add(line);
        }
        for(String s:list)
        {
            System.out.println(s);
        }
        in.close();
    }
}

21.17_IO流(随机获取文本文件中的姓名)(掌握)

A:案例演示:	需求：我有一个文本文件，每一行是一个学生的名字，请写一个程序，每次允许随机获取一个学生名称
 * 分析:
	 * 		a: 创建一个高效的字符输入流对象
	 * 		b: 创建集合对象
	 * 		c: 读取数据,把数据存储到集合中
	 * 		d: 产生一个随机数,这个随机数的范围是 0 - 集合的长度 . 作为: 集合的随机索引
	 * 		e: 根据索引获取指定的元素
	 * 		f: 输出
	 * 		g: 释放资源
	 
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Random;

public class test10 {
    public static void main(String[] args) throws IOException {
        ArrayList<String>list=new ArrayList<>();
        BufferedReader in=new BufferedReader(new FileReader("username"));
        String line=null;
        while((line=in.readLine())!=null)
        {
            list.add(line);
        }
        Random random=new Random();
        int index=random.nextInt(list.size());
        String a=list.get(index);
        System.out.println(a);
    }
}

21.20_IO流(键盘录入学生信息按照总分排序并写入文本文件)(掌握)

A:案例演示:	需求：键盘录入3个学生信息(姓名,语文成绩(chineseScore),数学成绩(mathScore),英语成绩(englishScore)),按照总分从高到低存入文本文件
- 分析: 	
- a: 创建一个学生类: 姓名,语文成绩(chineseScore),数学成绩(mathScore),英语成绩(englishScore)
- b: 因为要排序,所以需要选择TreeSet进行存储学生对象
- c: 键盘录入学生信息,把学生信息封装成一个学生对象,在把学生对象添加到集合中
- d: 创建一个高效的字符输出流对象
- e: 遍历集合,把学生的信息写入到指定的文本文件中
- f: 释放资源





public class Student {
    private String name;
    private int chineseScore;
    private int mathScore;
    private int englishScore;

    public String getName() {
        return name;
    }

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

    public int getChineseScore() {
        return chineseScore;
    }

    public void setChineseScore(int chineseScore) {
        this.chineseScore = chineseScore;
    }

    public int getMathScore() {
        return mathScore;
    }

    public void setMathScore(int mathScore) {
        this.mathScore = mathScore;
    }

    public int getEnglishScore() {
        return englishScore;
    }

    public void setEnglishScore(int englishScore) {
        this.englishScore = englishScore;
    }
    //获取总分的方法
    public  int totalScore(){
        return this.chineseScore+this.mathScore+this.englishScore;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", chineseScore=" + chineseScore +
                ", mathScore=" + mathScore +
                ", englishScore=" + englishScore +
                '}';
    }
}





import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Comparator;
import java.util.Scanner;
import java.util.TreeSet;

public class test11 {
    public static void main(String[] args) throws IOException {
        TreeSet<Student> treeSet=new TreeSet<>(new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                int num=o1.totalScore()-o2.totalScore();
                int num1=num==0?o1.getName().compareTo(o2.getName()):num;
                return num1;

            }
        });
        for(int i=1;i<=3;i++)
        {
            Student student=new Student();
            Scanner se=new Scanner(System.in);
            System.out.println("请输入"+i+"个学生的名字");
            String name=se.nextLine();
            student.setName(name);
            System.out.println("请输入"+i+"个学生的语文成绩");
            int yw=se.nextInt();
            student.setChineseScore(yw);
            System.out.println("请输入"+i+"个学生的数学成绩");
            int sx=se.nextInt();
            student.setMathScore(sx);
            System.out.println("请输入"+i+"个学生的英语成绩");
            int yy=se.nextInt();
            student.setEnglishScore(yy);
            treeSet.add(student);
        }
        BufferedWriter writer=new BufferedWriter(new FileWriter("Student.txt"));
        writer.write("编号"+"\t"+"姓名"+"\t"+"语文"+"\t"+"数学"+"\t"+"外语"+"\t"+"总分");
        writer.newLine();
        writer.flush();
        int index=1;
        for(Student s:treeSet)
        {
            writer.write(index+"\t"+s.getName()+"\t"+s.getChineseScore()+"\t"+s.getMathScore()+"\t"+s.getEnglishScore());
            writer.newLine();
            writer.flush();
        }
        writer.close();

    }
}