Java编程基础22——IO(字符流)&字符流其余内容&递归

时间  2019-11-10
标签 java 编程 基础 字符 其余 内容 递归 栏目 Java 繁體版
原文   原文链接

1_字符流FileReader

  • 1.字符流是什么java

    • 字符流是能够直接读写字符的IO流
    • 字符流读取字符, 就要先读取到字节数据, 而后转为字符. 若是要写出字符, 须要把字符转为字节再写出.

  • 2.FileReadermysql

    • FileReader类的read()方法能够按照字符大小读取
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
public class Demo1_FileReader {
    public static void main(String[] args) throws IOException {
//        demo1();
        FileReader fr = new FileReader("xxx.txt");
        int c;
        while((c = fr.read()) != -1) {    //经过项目默认的码表一次读取一个字符,赋值给c
            System.out.print((char)c);    //将读到的字符强转后打印
        }
        fr.close();
    }

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

2_字符流FileWriter

  • FileWriter类的write()方法能够自动把字符转为字节写出
import java.io.FileWriter;
import java.io.IOException;
public class Demo2_fileWriter {
    public static void main(String[] args) throws IOException {
        FileWriter fw = new FileWriter("yyy.txt");
        fw.write("你们好，SE快学完了！");
        fw.write(97);
        fw.close();
    }
}

3_字符流的拷贝

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
public class Demo3_Copy {
    public static void main(String[] args) throws IOException {
        FileReader fr = new FileReader("xxx.txt");
        FileWriter fw = new FileWriter("zzz.txt");
        
        int c;
        while((c = fr.read()) != -1) {
            fw.write(c);
        }
        
        fr.close();
        //Writer类中有一个2k的小缓冲区，若是不关流，就会将内容写到缓冲区里，关流会将缓冲区内容写出并结束
        fw.close();            
    }
}

4_什么状况下使用字符流

  • 字符流也能够拷贝文本文件, 但不推荐使用. 由于读取时会把字节转为字符, 写出时还要把字符转回字节.
  • 程序须要读取一段文本, 或者须要写出一段文本的时候可使用字符流
  • 读取的时候是按照字符的大小读取的,不会出现半个中文
  • 写出的时候能够直接将字符串写出,不用转换为字节数组

图片描述

5_字符流是否能够拷贝非纯文本的文件

  • 不能够拷贝非纯文本的文件
  • 由于在读的时候会将字节转换为字符，在转换过程当中,可能找不到对应的字符，就会用?代替，写出的时候会将字符转换成字节写出去，若是是?，直接写出，这样写出以后的文件就乱了，看不了了。

6_自定义字符数组的拷贝

public static void main(String[] args) throws IOException {    
        FileReader fr = new FileReader("xxx.txt");
        FileWriter fw = new FileWriter("yyy.txt");
        
        char[] arr = new char[1024];
        
        int len;
        while((len = fr.read(arr)) != -1) {        //将文件上的数据读取到字符数组中
            fw.write(arr, 0, len);                //将字符数组中的数据写到文件上
        }
        
        fr.close();
        fw.close();
    }

7_带缓冲的字符流

  • BufferedReader的read()方法读取字符时会一次读取若干字符到缓冲区, 而后逐个返回给程序, 下降读取文件的次数, 提升效率
  • BufferedWriter的write()方法写出字符时会先写到缓冲区, 缓冲区写满时才会写到文件, 下降写文件的次数, 提升效率
public static void main(String[] args) throws IOException {
        BufferedReader    br = new BufferedReader(new FileReader("xxx.txt"));
        BufferedWriter    bw = new BufferedWriter(new FileWriter("yyy.txt"));
        
        int c;
        while((c = br.read()) != -1) {    //read一次,会先将缓冲区读满,从缓冲去中一个一个的返给临时变量c
            bw.write(c);                //write一次,是将数据装到字符数组,装满后再一块儿写出去
        }
        
        br.close();
        bw.close();
    }

8_readLine()和newLine()方法

  • BufferedReader的readLine()方法能够读取一行字符(不包含换行符号)
  • BufferedWriter的newLine()能够输出一个跨平台的换行符号"rn"
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class Demo4_Buffered {
    public static void main(String[] args) throws IOException {
//        demo1();
        BufferedReader br = new BufferedReader(new FileReader("zzz.txt"));
        BufferedWriter bw = new BufferedWriter(new FileWriter("aaa.txt"));
        String line;
        while((line = br.readLine()) != null) {
            bw.write(line);
            bw.newLine();            //写出回车换行符,跨平台的
            bw.write("\r\n");        //只支持windows系统
        }
        br.close();
        bw.close();
    }
    private static void demo1() throws FileNotFoundException, IOException {
        BufferedReader br = new BufferedReader(new FileReader("zzz.txt"));
        String line;
        while((line = br.readLine()) != null) {
            System.out.println(line);
        }
        br.close();
    }
}

9_将文本反转

  • 将一个文本文档上的文本反转,第一行和倒数第一行交换,第二行和倒数第二行交换
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;

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

10_LineNumberReader

  • LineNumberReader是BufferedReader的子类, 具备相同的功能, 而且能够统计行号spring

    • 调用getLineNumber()方法能够获取当前行号
    • 调用setLineNumber()方法能够设置当前行号
import java.io.FileReader;
import java.io.IOException;
import java.io.LineNumberReader;

public class Demo6_LineNumberReader {
    public static void main(String[] args) throws IOException {
        LineNumberReader lnr = new LineNumberReader(new FileReader("zzz.txt"));
        
        String line;
        lnr.setLineNumber(100);            //设置行号
        while((line = lnr.readLine()) != null) {
            System.out.println(lnr.getLineNumber() + ":" + line);    //获取行号
        }
        
        lnr.close();
    }
}

11_装饰设计模式

  • 优势：耦合性不强，被装饰的类的变化与装饰类的变化无关
public class Demo7_Wrap {
    public static void main(String[] args) {
        AllIdea ai = new AllIdea(new Student());
        ai.code();
    }
}

interface Coder{
    public void code();
}

class Student implements Coder{

    @Override
    public void code() {
        System.out.println("JavaSE");
        System.out.println("JavaWEB");
    }
}

class AllIdea implements Coder{
    //1.获取被装饰类的引用
    private Student s;
    //2.在构造方法中传入被装饰的对象
    public AllIdea(Student s) {
        this.s = s;
    }
    //3.对原有的功能进行升级
    @Override
    public void code() {
        s.code();
        System.out.println("mysql");
        System.out.println("spring");
    }
}

12_使用指定的码表读写字符

  • FileReader是使用默认码表读取文件, 若是须要使用指定码表读取, 那么可使用InputStreamReader(字节流,编码表)
  • FileWriter是使用默认码表写出文件, 若是须要使用指定码表写出, 那么可使用OutputStreamWriter(字节流,编码表)
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.UnsupportedEncodingException;

public class Demo8_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.txt"), "gbk"));
        
        int c;
        while((c = br.read()) != -1) {
            bw.write(c);
        }
        br.close();
        bw.close();
    }

    private 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();
    }

    private 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();
    }
}

13_转换流图解

  • 画图分析转换流

图片描述

14_获取文本上字符出现的次数

  • 获取一个文本上每一个字符出现的次数,将结果写在times.txt上
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.TreeMap;

public class Demo91_test {
    public static void main(String[] args) throws IOException {
        //1.建立带缓冲的输入流对象
        BufferedReader br = new BufferedReader(new FileReader("zzz.txt"));
        //2.建立双列集合对象TreeMap
        TreeMap<Character, Integer>    tm = new TreeMap<>();
        //3.将读到的字符存储在双列集合中，存储的时候要作判断，若是不包含这个键，就将键和1存储，
        //若是包含这个键，就将该键和值加1存储
        int ch;
        while((ch = br.read()) != -1) {
            char c = (char)ch;                //向下强制类型转换
            /*if(!tm.containsKey(c)) {
                tm.put(c, 1);
            }else {
                tm.put(c, tm.get(c) + 1);
            }*/
            tm.put(c, !tm.containsKey(c) ? 1 : tm.get(c) + 1);
        }
        //4.关闭输入流
        br.close();
        //5.建立输出流对象
        BufferedWriter bw = new BufferedWriter(new FileWriter("times.txt"));
        //6.遍历集合将集合中的内容写到times.txt中
        for (Character key : tm.keySet()) {
            switch (key) {
            case '\t':
                bw.write("\\t" + "=" + tm.get(key));
                break;
            case '\n':
                bw.write("\\n" + "=" + tm.get(key));
                break;
            case '\r':
                bw.write("\\r" + "=" + tm.get(key));
                break;
            default:
                bw.write(key + "=" + tm.get(key));    //写出键和值
                break;
            }
            bw.newLine();
        }
        //7.关闭输出流
        bw.close();
    }
}

15_试用版软件

  • 当咱们下载一个试用版软件,没有购买正版的时候,每执行一次就会提醒咱们还有多少次使用机会用学过的IO流知识,模拟试用版软件,试用10次机会,执行一次就提示一次您还有几回机会,若是次数到了提示请购买正版
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class Demo92_test {
    public static void main(String[] args) throws IOException {
        //1.建立带缓冲的输入流对象，由于要使用readLine方法，能够保证数据的原样性
        BufferedReader br = new BufferedReader(new FileReader("config.txt"));
        //2.将读到的字符串转换为int数
        String line = br.readLine();
        int times = Integer.parseInt(line);        //将数字字符串转换为数字
        //3.对int数进行判断，若是大于0，就将其一一写回去，若是不大于0，就提示请购买正版。
        if(times > 0) {
            //4.在if判断中要将--的结果打印，并将结果经过输出流写到文件上
            System.out.println("您还有" + times-- + "次机会");
            FileWriter fw = new FileWriter("config.txt");
            fw.write(times-- + "");
            fw.close();
        }else {
            System.out.println("您的试用次数已到，请购买正版");
        }
        br.close();
    }
}

16_File类(递归)

  • 概念：方法本身调用本身sql

    • 弊端：是不能调用次数过多，容易致使栈内存溢出
    • 好处：不用知道循环次数
    • 构造方法不能试用递归调用
    • 递归调用是否必须有返回值（能够有也能够没有）
  • 案例：5的阶乘（5！）
5 * 4 * 3 * 2 * 1   
  5 * fun(4)(表明4!)
           4 * fun(3)(表明3!)
               3 * fun(2)(表明2!)
                   2 * fun(1)(表明1!)
public class Demo93_recursive {
    public static void main(String[] args) {
//        demo1();
        System.out.println(fun(10));
    }
    
    public static int fun(int num) {
        if(num == 1) {
            return 1;
        }else {
            return num * fun(num - 1);
        }
    }

    private static void demo1() {
        int result = 1;
        for(int i = 1; i <= 5; i++) {
            result = result * i;
        }
        System.out.println(result);
    }
}

17_File类(练习)

  • 需求:从键盘输入接收一个文件夹路径,打印出该文件夹下全部的.java文件名
import java.io.File;
import java.util.Scanner;
public class Demo94_test {
    public static void main(String[] args) {
        File dir = getDir();
        printJavaFile(dir);
    }
    /*获取键盘录入的文件夹路径
     * 1.返回值類型File
     * 2.不须要有参数*/
    public static File getDir() {
        Scanner sc = new Scanner(System.in);            //建立键盘录入对象
        System.out.println("请输入一个文件夹路径");
        while (true) {
            String line = sc.nextLine();                //将键盘录入的文件夹路径存储
            File dir = new File(line);
            if(!dir.exists()) {
                System.out.println("您录入的文件夹路径不存在，请从新录入");
            }else if(dir.isFile()) {
                System.out.println("您录入的是文件路径，请从新录入文件夹路径");
            }else {
                return dir;
            }
        }
    }
    /*获取文件夹路径下的全部.java文件
     * 1.返回值类型void
     * 2.参数列表File dir*/
    public static void printJavaFile(File dir) {
        //1.获取到该文件夹路径下的全部文件和文件夹，存储在File数组中
        File[] subFiles = dir.listFiles();
        //2.遍历数组，对每个文件或文件夹判断
        for(File subFile : subFiles) {
        //3.若是是文件，而且是.java的就打印
            if(subFile.isFile() && subFile.getName().endsWith(".java")) {
                System.out.println(subFile);
            //4.若是是文件夹，就递归调用    
            }else if(subFile.isDirectory()) {
                printJavaFile(subFile);
            }
        }
    }
}

18_总结

  • 1.会用BufferedReader读取GBK码表和UTF-8码表的字符
  • 2.会用BufferedWriter写出字符到GBK码表和UTF-8码表的文件中
  • 3.会使用BufferedReader从键盘读取一行
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程