2019-05-31 Java学习日记 day21 IO流字符流

IO

字符流

　　字符流是可以直接读写字符的IO流

　　字符流读取字符，就要先读到字节数据，然后转为字符，如果写出字符，需要把字符转为字节再写出

FileReader

　　FileReader类的read（）方法可以按照字符大小读取

public class demo1_filereader {

    public static void main(String[] args) throws IOException {
        //demo1();
        FileReader f1 =new FileReader("xxx.txt");
        int x;
        while((x =f1.read()) != -1){  //通过项目默认的码表一次读取一个字符
            System.out.print((char)x);
        }
    }

    public static void demo1() throws FileNotFoundException, IOException {
        FileReader f1 =new FileReader("xxx.txt");
        int x=f1.read();
        System.out.println(x);
        char c=(char)x;
        System.out.println(c);
        f1.close();
    }

}

FileWriter类的write（）方法可以自动把字符转为字节写出

public static void main(String[] args) throws IOException {
        FileWriter f1=new FileWriter("tan.txt");
        f1.write("大家好");
        
        f1.close();

    }

}

字符流的拷贝

public class demo3_fierreader {

    public static void main(String[] args) throws IOException {
        FileReader f1 =new FileReader("xxx.txt");
        FileWriter f2 =new FileWriter("zzz.txt");
        
        int c;
        while((c =f1.read()) != -1){
            f2.write(c);
        }
        f1.close();
        f2.close();  //writer类中有一个2k的小缓冲区，如果不关流，就会将内容写到缓冲区里，关流会，缓冲会将缓冲区内的刷新
        

    }

}

什么情况下使用字符流

　　*字符流也可以拷贝文本文件，但不推荐使用，因为读取时会把字节转为字符，写出时还要把字符转回字节

　　*程序需要读取一段文本，或者需要写出一段文本的时候可以使用字符流

　　　　读取的时候时按照字符的大小读取的，不会出现半个中文

　　　　写出的时候可以直接将字符串写出，不用转换为字节数组

字符流是否可以拷贝非纯文本的文件

　　不可以拷贝非纯文本的文本

　　因为在读的时候会将字节转为字符，在转换过程中，可能找不到对应的字符，就会用 ？ 代替，写出的时候会将字符串转换成字节写出去

　　如果时 ？ 直接写出，这样写出之后的文件就乱了，看不了了

 

自定义字符数组的拷贝

                FileReader f1 =new FileReader("xxx.txt");
        FileWriter f2 =new FileWriter("yyy.txt");
        char [] arr=new char[1024];
        int len; 
        while((len =f1.read(arr)) != -1){ //将文件上的数据读取到字符数组中
            f2.write(arr,0,len);            //将字符数组中的数据写到文件上
        }
        f1.close();
        f2.close();        

带缓冲的字符流

BufferedReader的read（）方法读取字符时会一次读取若干字符到缓冲区，然后逐个返回给程序，降低读取文件的次数，提高效率

BufferdWriter的write（）方法写出字符时会先写道缓冲区，缓冲区写满时才会写到文件，降低写文件的次数，提高效率

readLine（）和 newLine（）方法

BufferedReader的 readLine（）方法可以读取一行字符（不包含换行符号）

public class demo4_buffered {

    public static void main(String[] args) throws IOException {
        BufferedReader b1 =new BufferedReader(new FileReader("xxx.txt"));
        String line;
        
        while((line = b1.readLine()) != null){
            System.out.println(line);
        }
        b1.close();
    }

}

BufferdWriter的 newLine（）可以输出一个跨平台的换行符号“ ”

newLine（）是跨平台的方法

“ ”只支持的是windows系统

BufferedReader b1 =new BufferedReader(new FileReader("xxx.txt"));
        BufferedWriter b2=new BufferedWriter(new FileWriter("yyy.txt"));
        String line;
        while((line= b1.readLine()) !=null){
            b2.write(line);
            b2.newLine();
        }
        b1.close();
        b2.close();

将文本反转

public class test1 {

    public static void main(String[] args) throws IOException {
        //创建输入输出流对象
        BufferedReader br =new BufferedReader(new FileReader("xxx.txt"));
        
        //创建集合对象
        ArrayList<String> list =new ArrayList<>();
        //将读到的数据存储在集合中
        String line;
        while((line =br.readLine()) !=null){
            list.add(line);
        }
        br.close(); //关流
        //倒着遍历集合蒋书记写到文件上
        BufferedWriter bw =new BufferedWriter(new FileWriter("jung.txt"));
        for (int i = list.size() -1; i >=0; i--) {
            bw.write(list.get(i));
            bw.newLine();
        }
        

        bw.close();
    }

}

LineNumberReader

　　LineNumberReader时BufferedReader的子类，具有相同的功能，并且可以统计行号

　　　　*调用getLineNumder（）方法可以获取当前行号

　　　　*调用getLineNumder（）方法可以设置当前行号

public class demo5_number {
    public static void main (String args []) throws IOException{
        LineNumberReader num1=new LineNumberReader(new FileReader("jung.txt"));
         String line ;
         num1.setLineNumber(100);
         while((line =num1.readLine()) !=null){
             System.out.println(num1.getLineNumber()+":"+line);
         }
         num1.close();
    }
}

装饰设计模式

耦合性不强，被装饰的类变化与装饰类的变化无关

public class demo6_wrap {

    public static void main(String[] args) {
        heima h =new heima(new Student());
        h.code();

    }

}
interface coder{
    public void code();
}
class Student implements coder{

    @Override
    public void code() {
        System.out.println("java");
        System.out.println("javawed");
        
    }
    
}
class heima implements coder{
    //获取被装饰类的引用
    private Student student;  //获取学生引用
    
    //在构造方法中传入被装饰类的对象
    public heima(Student student){
        this.student=student;
    }
    
    //对原有功能升级
    @Override
    public void code() {
        student.code();
        System.out.println("数据库");
        System.out.println("前端框架");
        
    }
}

使用指定的码表读写字符

　　FileReader 是使用默认码表读取文件，如果需要使用指定码表读取，那么可以使用IputStreamReader（字节流，编码表）

　　FileWriter 是使用默认码表写出文件，如果需要使用指定码表写出，那么可使用OutputStreamWriter（字节流，编码表）

public class demo7_TransIo {

    public static void main(String[] args) throws IOException {
        //demo1();        
        //demo2();
        
        //更有效的
        BufferedReader br = new BufferedReader(
        new InputStreamReader( new FileInputStream("utf-8.txt"),"utf-8"));
        
        BufferedWriter bw =new BufferedWriter(
        new OutputStreamWriter(new FileOutputStream("gbk.tx"),"gbk"));
        
        int c;
        while((c =br.read()) != -1){
            bw.write(c);
        }
        br.close();
        bw.close();
    }

    public static void demo2() throws UnsupportedEncodingException, FileNotFoundException, IOException {
        //指定码表读字符     指定码表写字符
        InputStreamReader isr =new InputStreamReader(new FileInputStream("utf-8.txt"),"utf-8");
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("gbk.txt"), "gbk");
        
        int c;
        while((c =isr.read()) != -1){
            osw.write(c);
        }
        isr.close();
        osw.close();
    }

    public static void demo1() throws FileNotFoundException, IOException {
        //用默认编码表读写，会出现乱码
        FileReader fr =new FileReader("utf-8.txt");
        FileWriter fw = new FileWriter("gbk.txt");
        
        int c;
        while((c=fr.read()) != -1){
            fw.write(c);
        }
        fr.close();
        fw.close();
    }

}

获取一个文本上每个字符出现的次数，将结果写在times.txt上

public class text3 {

    public static void main(String[] args) throws IOException {
        //创建带缓冲的输入对象
        BufferedReader br =new BufferedReader(new FileReader("jung.txt"));
        //创建双列集合对象TreeMap
        TreeMap<Character, Integer> tm =new TreeMap<>();
        
        //将读到额字符存储在双列集合中，存储的时候要做判断，如果不包含这个键，就将键和1存储，如果包含这个键，就将该键和值加1存储
        
        int ch;
        while((ch =br.read()) != -1){
            char c=(char)ch;
            tm.put(c, !tm.containsKey(c) ? 1 : tm.get(c) + 1);
        }
        br.close();
        BufferedWriter bw = new BufferedWriter(new FileWriter("times.txt"));
        for(Character key : tm.keySet()){
            switch (key) {
            case '	':
                bw.write("\t"+"="+tm.get(key));
                break;
            case '
':
                bw.write("\n"+"="+tm.get(key));
                break;
            case '
':
                bw.write("\r"+"="+tm.get(key));
                break;

            default:bw.write(key+"="+tm.get(key));
                break;
            }
            bw.newLine();
        }
        bw.close();

    }

}

练习一

public class test2 {

    public static void main(String[] args) throws IOException {
        
        BufferedReader br =new BufferedReader(new FileReader("zzz.txt"));
        
        String line =br.readLine();
        int times =Integer.parseInt(line);
        if (times > 0) {
            System.out.println("你还有"+times--+"次机会");
            FileWriter fw =new FileWriter("zzz.txt");
            fw.write(times+"");
            fw.close();
        }else{
            System.out.println("你的次数已到");
        }
        br.close();
    }

}

练习二

public class test4 {

    public static void main(String[] args) {
    File dir=getDir();
    print(dir);
    

    }


public static File getDir(){
    Scanner scanner =new Scanner(System.in);
    System.out.println("请输入一个文件夹路径");
    while (true) {
        String line =scanner.nextLine();
        File dir =new File(line);
        if (!dir.exists()) {
            System.out.println("你录入的文件路径不存在，请重新录入");
        }else if(dir.isFile()){
            System.out.println("你录入的文件夹路径，请重新录入");
        }else {
            return dir;
        }
        
    }
}
 public static void print(File dir){
     
     File [] subFiles=dir.listFiles();
     for (File file : subFiles) {
        if (file.isFile() && file.getName().endsWith(".java")) {
            System.out.println(file);
        }else if(file.isDirectory()){
            print(file);
        }
    }
 }
}