Day21JavaSE——IO流之字符流

最新推荐文章于 2022-09-28 02:17:35 发布
最新推荐文章于 2022-09-28 02:17:35 发布
阅读量348 收藏
点赞数
分类专栏： JavaSE 文章标签： java 字符串
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/adAir_liu/article/details/106581505
版权

Day21JavaSE——IO流之字符流

文章目录

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

字符流出现的原因

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

String中的编解码问题

public class Test1 {
    public static void main(String[] args) throws UnsupportedEncodingException {
        //编码
        //解码
        String str = "我爱你";
        //使用平台默认的码表进行编码
        byte[] bytes = str.getBytes();
        System.out.println(Arrays.toString(bytes));

        //解码
        String s = new String(bytes);
        System.out.println(s);

        //也就是说我们在编码和解码的时候使用同一张码表，就不会出现乱码的问题
        String str2 = "中文乱码问题";
        byte[] gbks = str2.getBytes("GBK");

        //解码
        String s1 = new String(gbks, "UTF-8");
        System.out.println(s1);

        //乱码就是编解码用的不是同一张码表
    }
}

字符流

Writer

OutputStreamWriter

public class Test1 {
    public static void main(String[] args) throws IOException {
        //OutputStreamWriter
        /*OutputStreamWriter 是字符流通向字节流的桥梁：
        * 可使用指定的 码表 将要写入流中的字符编码成字节。
        * 它使用的字符集可以由名称指定或显式给定，否则将接受平台默认的字符集。*/
        /*OutputStreamWriter(OutputStream out)
        * 创建一个使用默认字符编码的OutputStreamWriter。
        * OutputStreamWriter(OutputStream out, Charset cs)
        * 创建一个使用给定字符集的OutputStreamWriter。
        * OutputStreamWriter(OutputStream out, CharsetEncoder enc)
        * 创建一个使用给定字符集编码器的OutputStreamWriter。
        * OutputStreamWriter(OutputStream out, String charsetName)
        * 创建一个使用命名字符集的OutputStreamWriter。*/
        OutputStreamWriter out1 = new OutputStreamWriter(new FileOutputStream("a.txt"));

        //可以指定码表
        OutputStreamWriter out2 = new OutputStreamWriter(new FileOutputStream("b.txt"), "UTF-8");
    }
}
字符流的5种写数据的方式
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) 写一个字符串的一部分

public class Test2 {
    public static void main(String[] args) throws IOException {
        OutputStreamWriter out1 = new OutputStreamWriter(new FileOutputStream("a.txt"));
        System.out.println("==========写入字符==========");
        out1.write('我');
        out1.flush();

        System.out.println("==========写入换行符==========");
        out1.write("\r\n");

        System.out.println("==========写入字符串==========");
        out1.write("你好。。。。");
        //字符流需要刷新，将缓冲区中的数据刷新到磁盘中
        out1.write("\r\n");
        out1.flush();
        out1.write("公司的发货速度");
        out1.write("\r\n");
        out1.flush();
        //释放资源
        out1.close();//刷新并关闭
    }
}

public class Test3 {
    public static void main(String[] args) throws IOException {
        //创建一个文件对象并创建输出字符流对象，使用UTF-8编码
        OutputStreamWriter out1 = new OutputStreamWriter(new FileOutputStream("a.txt"), "GBK");
        out1.write("这样是不是乱码了");
        out1.write("\r\n");
        out1.flush();

        //一次写入一个字符数组
        out1.write(new char[]{'a','b','c','哈','哈'});
        out1.write("\r\n");

        //一次写入字符串的一部分
        out1.write("士大夫敢死队风格",2,3);
        out1.write("\r\n");

        //一次写入字符数组的一部分，从0索引处开始 写3个字符
        out1.write(new char[]{'a', 'b', 'c', '哈', '哈'},0,3);
        //字符流，记得要刷新
        out1.flush();
        //释放资源
        out1.close();

        System.out.println("================================");
        //追加写入
        //追加写入  在你传入的字节流中 给个true 表示追加写入
        OutputStreamWriter out2 = new OutputStreamWriter(new FileOutputStream("b.txt",true));
        out2.write("这样是不是乱码了");
        out2.write("\r\n");
        out2.flush();

        //一次写入一个字符数组
        out2.write(new char[]{'a','b','c','哈','哈'});
        out2.write("\r\n");

        //一次写入字符串的一部分
        out2.write("士大夫敢死队风格",2,3);
        out2.write("\r\n");

        //一次写入字符数组的一部分，从0索引处开始 写3个字符
        out2.write(new char[]{'a', 'b', 'c', '哈', '哈'},0,3);
        //字符流，记得要刷新
        out2.flush();
        //释放资源
        out2.close();
    }
}

public class Test4 {
    public static void main(String[] args) {
        //异常处理
        OutputStreamWriter out1 = null;
        try {
            out1 = new OutputStreamWriter(new FileOutputStream("a.txt"), "GBK");
            out1.write("这样是不是乱码了");
            out1.write("\r\n");
            out1.flush();

            //一次写入一个字符数组
            out1.write(new char[]{'a','b','c','哈','哈'});
            out1.write("\r\n");

            //一次写入字符串的一部分
            out1.write("士大夫敢死队风格",2,3);
            out1.write("\r\n");

            //一次写入字符数组的一部分，从0索引处开始 写3个字符
            out1.write(new char[]{'a', 'b', 'c', '哈', '哈'},0,3);
            //字符流，记得要刷新
            out1.flush();
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            //释放资源
            try{
                if(out1!=null){
                    out1.close();
                }
            }catch (IOException e){
                e.printStackTrace();
            }
        }
    }
}

Reader

InputStreamReader

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

public class Test1 {
    public static void main(String[] args) throws IOException {
        //InputStreamReader是字节流通向字符流的桥梁：
        //它使用指定的 码表 读取字节并将其解码为字符。
        //它使用的字符集可以由名称指定或显式给定，或者可以接受平台默认的字符集
        /*protected  Reader()
        * 创建一个新的字符流阅读器，其关键部分将在阅读器本身上同步。
        * protected  Reader(Object lock)
        * 创建一个新的字符流阅读器，其关键部分将在给定对象上同步。*/
        //输入流所关联的文件，如果不存在，就报错了
        InputStreamReader in1 = new InputStreamReader(new FileInputStream("e.txt"));
        //你也可以指定码表
        InputStreamReader in = new InputStreamReader(new FileInputStream("a.txt"), "UTF-8");
    }
}
字符流的2种读数据的方式
public class Test2 {
    public static void main(String[] args) {
        InputStreamReader in = null;
        InputStreamReader in1 = null;
        InputStreamReader in2 = null;
        try {
            in = new InputStreamReader(new FileInputStream("b.txt"));
            System.out.println("========一次读取一个字符========");
            int ch = in.read();
            System.out.println((char) ch);
            ch = in.read();
            System.out.println((char) ch);
            ch = in.read();
            System.out.println((char) ch);
            ch = in.read();
            System.out.println((char) ch);
            ch = in.read();
            System.out.println((char) ch);
            ch = in.read();
            System.out.println((char) ch);
            ch = in.read();
            System.out.println((char) ch);
            ch = in.read();
            System.out.println((char) ch);
            //如果读取不到，就返回-1 我们就可以使用 -1 来判断这个文件是否读取完毕
            ch = in.read();
            System.out.println(ch);

            System.out.println("=======一次读取一个字符数组=======");
            in1 = new InputStreamReader(new FileInputStream("a.txt"));
            //定义一个字符数组作为缓存区
            char[] dataBuffer = new char[1000];
            //一次取1000个字符放到数组中，返回值为实际取得的字符个数
            int len = in1.read(dataBuffer);
            System.out.println(len);
            System.out.println(Arrays.toString(dataBuffer));

            //将字符数组转换成字符串
            String s = String.valueOf(dataBuffer);
            System.out.println(s);

            System.out.println("=======读取字符数组的一部分=======");
            char[] dataBuffer1 = new char[1000];
            in2 = new InputStreamReader(new FileInputStream("a.txt"));
            int len2 = in2.read(dataBuffer1, 2, 8);
            System.out.println(len2);
            System.out.println(Arrays.toString(dataBuffer1));

            String s1 = String.valueOf(dataBuffer1);
            System.out.println(s1);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (in != null) {
                    in.close();
                }
                if (in1 != null) {
                    in1.close();
                }
                if (in2 != null) {
                    in2.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}
异常处理
public class Test3 {
    public static void main(String[] args) {
        //流的异常处理
        InputStreamReader in=null;
        try {
            in = new InputStreamReader(new FileInputStream("b.txt"));
            //定义一个字符数组来充当容器，可以一次取到这个容器中
            char[] dataBuffer = new char[1000];
            //一次读取一部分字符，放到字符数组中
            int len = in.read(dataBuffer, 0, 8);
            System.out.println(len);
            System.out.println(Arrays.toString(dataBuffer));
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if(in!=null){
                try {
                    in.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

高效字符流

public class Test1 {
    public static void main(String[] args) throws IOException {
        //高效的字符流
        //BufferedReader
        //BufferedWriter
      /*  构造方法摘要
        BufferedReader(Reader in)
        创建一个使用默认大小输入缓冲区的缓冲字符输入流。*/

        BufferedReader reader = new BufferedReader(new FileReader("Test1.java"));
      /*  BufferedWriter(Writer out)
        创建一个使用默认大小输出缓冲区的缓冲字符输出流。*/
        BufferedWriter writer= new BufferedWriter(new FileWriter("haha.java"));


        char[] chars = new char[2000]; //定义一个字符数组，充当缓冲区
        int len = 0;//用来记录实际读取到的字符个数
        int count = 1;
        while ((len = reader.read(chars)) != -1) {
            System.out.println("循环次数" + (count++));
            writer.write(chars, 0, len);
            writer.flush();
        }

        reader.close();
        writer.close();
    }
}

public class Test2 {
    public static void main(String[] args) throws IOException {
        //高效字符流
        //BufferedReader 里面有特有的方法 String readLine() 一次读一行文本
        //BufferedWriter void newLine() 写入一个换行符，具有平台兼容性。
        //使用高效的字符流。读取一行，写入一行来复制文件，逐行复制。
        BufferedReader reader = new BufferedReader(new FileReader("Test1.java"));
        BufferedWriter writer = new BufferedWriter(new FileWriter("hehe.java"));
        //循环的进行读取一行，写入一行
        //一行一行读取，读取不到返回的是null
        //定义一个变量，此函数以字符串的形式返回读取的那行文本
        String line=null;
        while ((line = reader.readLine()) != null) {
            writer.write(line);
            writer.flush();
        }
        reader.close();
        writer.close();
    }
}

案例演示

案例1

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

public class Test1 {
    public static void main(String[] args) {
        ArrayList<String> strings = new ArrayList<>();
        strings.add("aaa");
        strings.add("bbb");
        strings.add("ccc");
        strings.add("ddd");
        strings.add("eee");
        strings.add("fff");
        strings.add("ggg");
        strings.add("hhh");
        strings.add("iii");
        strings.add("jjj");
        BufferedWriter writer = null;
        try {
            writer = new BufferedWriter(new FileWriter("案例A把ArrayList集合中的字符串数据存储到文本文件.txt"));
            //char[] dataBuffer = new char[1000];
            for (int i = 0; i < strings.size(); i++) {
                char[] chars = strings.get(i).toCharArray();
                writer.write(chars);
                writer.newLine();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try{
                if(writer!=null){
                    writer.close();
                }
            }catch (IOException e){
                e.printStackTrace();
            }
        }
    }
}

案例2

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

public class Test2 {
    public static void main(String[] args) {
        BufferedReader reader=null;
        try {
            reader = new BufferedReader(new FileReader("案例A把ArrayList集合中的字符串数据存储到文本文件.txt"));
            ArrayList<String> strings = new ArrayList<>();
            String s = reader.readLine();
            while ( s != null) {
                strings.add(s);
                s = reader.readLine();
            }
            for (String string : strings) {
                System.out.println(string);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try{
                if(reader!=null){
                    reader.close();
                }
            }catch (IOException e){
                e.printStackTrace();
            }
        }
    }
}

案例3

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

public class Test3 {
    public static void main(String[] args) {
        //随机获取文本中的字符串
        BufferedReader reader = null;
        try {
            reader = new BufferedReader(new FileReader("案例A把ArrayList集合中的字符串数据存储到文本文件.txt"));
            ArrayList<String> strings = new ArrayList<>();
            String s = reader.readLine();
            while (s != null) {
                strings.add(s);
                s = reader.readLine();
            }
            Random random = new Random();
            int index = random.nextInt(strings.size());
            System.out.println(strings.get(index));
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try{
                if(reader!=null){
                    reader.close();
                }
            }catch (IOException e){
                e.printStackTrace();
            }
        }
    }
}

案例4（复制多级文件夹）必须掌握

/*A:案例演示:  需求: 复制多级文件夹
        * 分析:
        * a: 封装源目录为一个对象
        * b: 封装目标目录的父路径为一个File对象
        * c: 判断源文件是目录还是文件
        *   1、是目录
        *       获取源目录名字
        *       调用构造方法在目标目录中创建一个新目录，名字与源目录同名
        *       获取源目录对应的路径下所有的文件对应的File数组
        *       遍历数组,获取每一个元素,进行进行递归
        *   2、是文件
        *       封装源文件和目标文件(注意这里一定要是文件的路径，不能是文件夹)为流
        *       //封装IO流若是传入的File对象里面封装的是文件夹
        *       //就会报java.io.FileNotFoundException: D:\xxx(拒绝访问。)异常
        *       //流只能访问文件，不能访问文件夹
        *
        *       调用流的函数将源文件复制到目标文件
        *       释放资源*/

public class Test4 {
    public static void main(String[] args) {
        File srcFolder = new File("C:\\Users\\adair_liu\\Desktop\\Java");
        File aimFolder = new File("F:\\05学习");
        try {
            copyFolderUseFile(srcFolder,aimFolder);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    private static void copyFolderUseFile(File srcFolder,File aimFolder) throws IOException {
        //判断源文件是否是目录
        //获取源文件下的所有文件，遍历
        if(srcFolder.isDirectory()){
            //如果是就在目标文件夹下创建一个目录
            String srcName = srcFolder.getName();
            File file = new File(aimFolder, srcName);
            //创建文件夹
            file.mkdirs();
            //获取源目录下的文件列表
            File[] files = srcFolder.listFiles();
            //遍历列表
            for (File file1 : files) {
                //递归文件夹内的所有文件
                copyFolderUseFile(file1,file);
            }
        }else if(srcFolder.isFile()){
            //进入这里的就是文件，文件用流复制
            String srcName = srcFolder.getName();
            File file = new File(aimFolder, srcName);
            copyFileUseFlu(srcFolder,file);
        }
    }
    private static void copyFileUseFlu(File srcFolder,File aimFolder) throws IOException {
        FileInputStream dataIn = new FileInputStream(srcFolder);
        //之前在这里出现的java.io.FileNotFoundException: D:\xxx(拒绝访问。)异常
        //是因为IO流只能访问文件，而无法访问文件夹
        //所以在将文件对象封装成流时文件对象里面封装的是文件路径，而不是文件夹路径
        FileOutputStream dataOut = new FileOutputStream(aimFolder);
        //将源文件复制到目标文件
        byte[] dataBuffer = new byte[1024 * 8];
        int len=0;
        while ((len = dataIn.read(dataBuffer)) != -1) {
            dataOut.write(dataBuffer,0,len);
            dataOut.flush();
        }
        dataIn.close();
        dataOut.close();
    }
}

案例5

 /*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 Student(){}
    public Student(String name,int chineseScore,int mathScore,int englishScore){
        this.name=name;
        this.chineseScore=chineseScore;
        this.mathScore=mathScore;
        this.englishScore=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 getTotalScore(){
        return chineseScore+mathScore+englishScore;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return chineseScore == student.chineseScore &&
                mathScore == student.mathScore &&
                englishScore == student.englishScore &&
                Objects.equals(name, student.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, chineseScore, mathScore, englishScore);
    }

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

public class Test6 {
    public static void main(String[] args) {
        BufferedWriter stuWriter = null;
        TreeSet<Student> set = new TreeSet<>(new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                int num = o1.getTotalScore() - o2.getTotalScore();
                int num1 = num == 0 ? o1.getName().compareTo(o2.getName()) : num;
                return -num1;
            }
        });
        for (int i = 1; i < 4; i++) {
            Scanner sc = new Scanner(System.in);
            System.out.println("请输入第" + i + "个学生姓名");
            String name = sc.nextLine();
            System.out.println("请输入第" + i + "个学生语文成绩");
            int chinese = sc.nextInt();
            System.out.println("请输入第" + i + "个学生数学成绩");
            int math = sc.nextInt();
            System.out.println("请输入第" + i + "个学生英语成绩");
            int english = sc.nextInt();
            Student student = new Student(name, chinese, math, english);
            set.add(student);
        }
        try {
            stuWriter = new BufferedWriter(new FileWriter("student.txt",true));
            for (Student student : set) {
                stuWriter.write(student.getName()+"\t"+student.getChineseScore()+"\t"+student.getMathScore()+"\t"+student.getEnglishScore());
                stuWriter.newLine();
                stuWriter.flush();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try{
                if(stuWriter!=null){
                    stuWriter.close();
                }
            }catch (IOException e){
                e.printStackTrace();
            }
        }
    }
}

案例6

 /*A:案例演示:
         * 需求：键盘录入3个学生信息(姓名,语文成绩(chineseScore),数学成绩(mathScore),英语成绩(englishScore)),按照总分从高到低存入文本文件
         * //增加一个需求：每一次录入成绩，都保存在一个新的文件中
         * //遍历学生这个集合，把每个学生的信息，存储到文本文件中
         * //写个表头 改成追加写入
         * //用时间来命名这个文件名*/

public class Test7 {
    public static void main(String[] args) {
        BufferedWriter stuWriter = null;
        TreeSet<Student> set = new TreeSet<>(new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                int num = o1.getTotalScore() - o2.getTotalScore();
                int num1 = num == 0 ? o1.getName().compareTo(o2.getName()) : num;
                return -num1;
            }
        });
        for (int i = 1; i < 4; i++) {
            Scanner sc = new Scanner(System.in);
            System.out.println("请输入第" + i + "个学生姓名");
            String name = sc.nextLine();
            System.out.println("请输入第" + i + "个学生语文成绩");
            int chinese = sc.nextInt();
            System.out.println("请输入第" + i + "个学生数学成绩");
            int math = sc.nextInt();
            System.out.println("请输入第" + i + "个学生英语成绩");
            int english = sc.nextInt();
            Student student = new Student(name, chinese, math, english);
            set.add(student);
        }
        //增加一个需求：每一次录入成绩，都保存在一个新的文件中
        //遍历学生这个集合，把每个学生的信息，存储到文本文件中
        //写个表头 改成追加写入
        //用时间来命名这个文件名
        long ms = System.currentTimeMillis();
        //将ms值封装成具体的时间
        Date date = new Date(ms);
        String fileName = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒").format(date);
        try {
            stuWriter = new BufferedWriter(new FileWriter(fileName,true));
            stuWriter.write("序号\t\t\t\t姓名\t语文\t数学\t英语\t总分");
            stuWriter.newLine();
            stuWriter.flush();
            int i=1;
            for (Student student : set) {
                stuWriter.write((i++)+"\t"+student.getName()+"\t"+student.getChineseScore()+"\t"+student.getMathScore()+"\t"+student.getEnglishScore());
                stuWriter.newLine();
                stuWriter.flush();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try{
                if(stuWriter!=null){
                    stuWriter.close();
                }
            }catch (IOException e){
                e.printStackTrace();
            }
        }
    }
}
 stuWriter = new BufferedWriter(new FileWriter(fileName,true));
            stuWriter.write("序号\t\t\t\t姓名\t语文\t数学\t英语\t总分");
            stuWriter.newLine();
            stuWriter.flush();
            int i=1;
            for (Student student : set) {
                stuWriter.write((i++)+"\t"+student.getName()+"\t"+student.getChineseScore()+"\t"+student.getMathScore()+"\t"+student.getEnglishScore());
                stuWriter.newLine();
                stuWriter.flush();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try{
                if(stuWriter!=null){
                    stuWriter.close();
                }
            }catch (IOException e){
                e.printStackTrace();
            }
        }
    }
}
冰奶茶没有热量
关注
专栏目录
JavaSE——Day21——IO流之字符流
晃在云淡风轻
03-29 220
字符流出现的原因 A: 案例演示: 字符流出现的原因:由于字节流操作中文不是特别方便，所以，java就提供了字符流。 B: 码表 C:字符流: 字符流 = 字节流 + 编码表 import java.io.UnsupportedEncodingException; public class Demo1 { public static void main(String[] arg...
Day20JavaSE——IO流之字节流
adAir_liu的博客
06-06 358
Day20JavaSE——IO流之字节流 文章目录Day20JavaSE——IO流之字节流IO流概述字节流的抽象基类FileOutputStream&FileInputStreamFileOutputStreamFileInputStream高效字节输入输出流字节流复制文件复制文本文件&MP3文件异常处理 IO流概述 A:IO流概述 IO流用来处理设备之间的数据传输 Java对数据的操作是通过流的方式 Java用于操作流的对象都在IO包中 java.io B:IO流分类 a:按照数
JavaSE——IO流-字符流
m0_50928133的博客
02-07 134
字符流出现的原因 编码和解码 编码: 就是把字符串转换成字节数组 public byte[] getBytes(); 使用平台的默认字符集将此 String编码为 byte 序列，并将结果存储到一个新的 byte 数组中。 public byte[] getBytes(String charsetName) 使用指定的字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。 解码: 把字节数组转换成字符串 public String(byte[] bytes):
JavaSE——Day20——IO流之字节流
晃在云淡风轻
03-29 201
IO流概述及其分类、 概述 IO流：用于处理设备之间的数据传输。 Java对数据的操作都是通过流的方式。 Java用于操作流的对象都在IO包中。 分类 按照数据流向分类 输入流：读入数据 输出流：写出数据 按照数据类型分类 字节流：可以读写任何类型的文件，比如音频，视频，文本文件，可执行文件等。 字符流：只能读写文本文件 ...
JavaSE——IO流
Java
12-26 259
Java IO流
JavaSE——IO流总结
Demon_and_Angle_的博客
08-14 269
用来进行输入输出操作的流就称为IO流。换句话说，IO流就是以流的方式进行输入输出。
JavaSE——Day19——IO流的概述，异常，File文件类
晃在云淡风轻
03-29 159
IO流的概述 流是一组有顺序的，有起点和终点的字节集合，是对数据传输的总称或抽象。即数据在两设备间的传输称为流，流的本质是数据传输，根据数据传输特性将流抽象为各种类，方便更直观的进行数据操作。 IO流用来处理设备之间的数据传输（上传和下载文件）。 为什么讲解IO流之前要先讲解异常和File类呢？ 因为File表示的是IO流将来要操作的文件，所以我们要先学习File类。而常见操作文件无非就是上传和下...
JavaSE 一些技巧 04——IO流各种流常用代码整理
m0_46507516的博客
09-28 387
IO流，缓冲流，打印流
Day19JavaSE——IO概述&异常&File文件类
adAir_liu的博客
05-29 796
Day19JavaSE——IO概述&异常&File文件类 文章目录Day19JavaSE——IO概述&异常&File文件类IO概述异常概述&分类JVM默认处理异常的方式运行期异常try...catch的方式处理异常捕获多种异常try--catch--finally用法finally需要注意的问题finally关键字的面试题编译期异常Throwable的几个常见方法throw的概述以及和throws的区别自定义异常概述&基本使用案例演示(判断成绩范围)异常的注意
VIP09_JavaSE_JavaIO_File_day0307-1.rar
最新发布
10-08
1. **Java IO体系结构**：Java IO框架主要包括字节流和字符流，分为输入流和输出流。字节流处理单个字节的数据，如InputStream和OutputStream家族；字符流处理Unicode字符，如Reader和Writer家族。此外，还有缓冲流...
JavaSE - Day21 (IO流及其文件上与下载)
qq_58293159的博客
07-12 137
文件上传与复制
JavaSE——反射机制
weixin_56341892的博客
01-01 353
反射机制 一、反射机制概述 反射机制的作用 通过java语言中的反射机制可以操作字节码文件。优点类似于黑客。（可以读和修改字节码文件。）通过反射机制可以操作代码片段。（class文件。） 反射机制的相关类在哪个包下？ java.lang.reflect.*; 反射机制相关的重要的类 java.lang.Class：代表整个字节码，代表一个类型，代表整个类。 java.lang.reflect.Method：代表字节码中的方法字节码。代表类中的方法。 java.lang.reflect.Co
JavaSE之文件操作与IO流
weixin_51973131的博客
07-17 230
文件操作与IO流 File类 概述 java.io.File类是文件和目录路径名的抽象表示，主要用于文件和目录的创建、查找和删除等操作 构造方法 File(File parent, String child) 根据 parent 抽象路径名和 child 路径名字符串创建一个新 File 实例。 File(String pathname) 通过将给定路径名字符串转换为抽象路径名来创建一个新 File 实例。 File(String parent, String child) 根据 parent 路径名字符
Day05JavaSE——数组&递归
adAir_liu的博客
04-11 1414
数组&递归 文章目录数组&递归数组概述数组类似于一个容器，是内存空间中开辟出来的一个区域，这个区域用来存储多个同一数据类型的数据，这样避免了当大量变量数据需要使用时需要对每个数据进行声明。只要是数据类型相同都可以放进同一个数组空间。此时每个数据都称为这个数组内的元素。常用的数组分为一维数组和二维数组，当然也存在三维数组，但是在日常应用中我们应用最多的时一维数组和二维数组。数组可以存...
Day23JavaSE——多线程&实现
adAir_liu的博客
06-16 1259
Day23JavaSE——多线程&实现 文章目录Day23JavaSE——多线程&实现进程的概述和多进程的意义并行和并发的区别Java程序运行原理和JVM的启动是多线程的吗多线程实现方式一案例利用多线程复制文件线程优先级问题线程控制实现多线程方式二(解决了Java中只能单继承问题)实现多线程方式3卖电影票案例继承Thread类的方式卖电影票案例实现Runnable接口的方式卖电影票线程安全问题生产消费者线程案例同步代码块解决线程安全问题同步方法锁JVM内存模型JVM内存模型 多线程 进程
Java基础——常量与变量&进制转换法&GBK编码环境下如何编译utf-8编码的文件
adAir_liu的博客
03-31 1092
Java基础——常量与变量&进制转换法&GBK编码环境下如何编译utf-8编码的文件 文章目录Java基础——常量与变量&进制转换法&GBK编码环境下如何编译utf-8编码的文件常量字面值常量在代码中输出不同的常量进制法（仔细总结进制换算法）进制转换任意进制到10进制（位权展开法）十进制到任意进制原码，反码，补码（计算机底层在运算时是通过补码运算的）例题变量数据类型...
Java开发初识——JDk安装和环境变量配置、Java代码运行、常用DOS命令
adAir_liu的博客
03-29 982
Java课堂笔记 文章目录Java课堂笔记计算机基础知识01.01 计算机常用快捷键常用DOS命令01.02 Java语言基础01.03 java语言基础01.04 Java语言基础（JDK安装目录解释）了解01.05 Java语言基础（开发工具介绍）了解01.06 Java语言基础（helloWorld案例编写与运行）01.07 Java语言基础(HelloWorld案例常见问题小结)01.08...
Day04JavaSE——流程控制 & 方法
adAir_liu的博客
04-07 851
Day04JavaSE——流程控制 & 方法 文章目录Day04JavaSE——流程控制 & 方法条件语句if条件语句if-else语句if-else结构的语句形式一：if(布尔类型结果的表达式){需要执行的代码}形式二：if(条件){条件为真的情况处理}else{条件为假的情况处理}求出两个数字最大值三元表达式与if，else区别多条件选择语句switch多分支语句switc...
Java SE IO流异常处理与File类详解
Java提供了多种类型的流，如字节流（`InputStream`和`OutputStream`）、字符流（`Reader`和`Writer`）、缓冲流、对象流等，满足不同数据类型和效率需求。使用流时，通常需要创建流对象，然后进行数据的读写操作，并...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值