IO流(二)基础知识

最新推荐文章于 2024-09-15 09:47:04 发布

小毛腾

最新推荐文章于 2024-09-15 09:47:04 发布

阅读量88

点赞数

分类专栏： Java基础文章标签： java jvm 算法

本文链接：https://blog.csdn.net/maoteng999521/article/details/129188806

版权

Java基础专栏收录该内容

4 篇文章 0 订阅

订阅专栏

IO流

缓冲流分类

一、字节流字节缓冲输入流字节缓冲输入流

二、字符流字符缓冲输出流字符缓冲输出流

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jT6n6Suz-1677152969440)(D:\JAVA笔记（第一遍）\assets\1673586555475.png)]

一、字节流

1、字节缓冲输入流 BufferedInputStream

BufferedInputStream bis = new BufferedInputStream(包装前的字节输入流);

1、字节缓冲输出流 BufferedOutputStream

BufferedOutputStream bos = new BufferedOutputStream(包装前的字节输出流);

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-if23HYkn-1677152969441)(D:\JAVA笔记（第一遍）\assets\1673587037665.png)]

总结

相当于再普通的字节流上，加了一个缓冲区，缓冲区的大小是8KB。性能更好

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-foUoQdxG-1677152969441)(D:\JAVA笔记（第一遍）\assets\1673586908215.png)]

整体代码

package com.maoteng.d1_byte_buffer;

import java.io.*;

public class ByteBuffer {
    public static void main(String[] args) {
//
        try {
//            创建一个文件字节输入流管道，连通源文件
            InputStream is = new FileInputStream("D:\\JAVA笔记（第一遍）\\IO流.md");
//            包装成高级字节缓冲输入流
            BufferedInputStream bis = new BufferedInputStream(is);

//            创建一个文件字节输出流管道，连通目标文件
            OutputStream os = new FileOutputStream("D:/newdfasdfd.md");
//            将其包装为高级字节输出缓冲流
            BufferedOutputStream bos = new BufferedOutputStream(os);

//            进行读写数据
            byte[] buffer = new byte[1024];
            int len;
            while ((len=bis.read(buffer))!=-1){
                bos.write(buffer,0,len);
            }
            System.out.println("复制成功~");

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

二、字符流

字符缓冲输入流

BufferedReader stream = new BufferedReader(rd);

字符缓冲输出流

 BufferedWriter bufferedWriter = new BufferedWriter(writer);

整体代码

package com.maoteng.d3_char_buffer;

import java.io.*;

public class CharBufferDemo2 {
    public static void main(String[] args) {
//        创建一个字符输出流。连接目标文件
        try (
//
                Reader reader = new FileReader("io-app\\src\\date3.tet");
                Writer writer = new FileWriter("io-app\\tt", true);
                BufferedWriter bufferedWriter = new BufferedWriter(writer);
                BufferedReader bufferedReader = new BufferedReader(reader);
        ) {
            int len;
            char[] chars = new char[1024];
            while ((len = bufferedReader.read(chars)) != -1) {
                bufferedWriter.write(chars, 0, len);
            }
            System.out.println("复制成功");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

三、可以按行读取

{
            String len;    // 存储每次读取的一行字符
            while ((len = stream.readLine())!=null){
                // 打印每行数据
                System.out.println(len);
 }

整体代码

package com.maoteng.d3_char_buffer;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;

public class CharBufferDemo03 {
    public static void main(String[] args) {
        try (
            // 创建通道
                Reader rd = new FileReader("io-app\\tt");
            // 创建高级通道
                BufferedReader stream = new BufferedReader(rd);
        ) {
            String len;    // 存储每次读取的一行字符
            while ((len = stream.readLine())!=null){
                // 打印每行数据
                System.out.println(len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

高级IO流案例

目标  ：将乱序的出师表 ，排序好放入到另一个文件中

1、创建高级字符输入流和字符输出流

BufferedReader bufferedReader = new BufferedReader(基础输入流);
BufferedWriter bufferedWriter = new BufferedWriter(基础输出流);

2、读取每行数据，并存入到集合中

{
            String len;  // 记录每行字符
            List<String> list = new ArrayList<>();  // 存放每行字符
		// 读取每行数据放到记录中，如果不为空继续读，然后存到集合中
            while ((len = bufferedReader.readLine()) != null) {
                list.add(len);
}

3、进行排序

"一","二","三","四","五","陆","柒","八","九","十","十一"

1、首先制定大小比较规则

List<String> size = new ArrayList<>();  // 用于存储这些需要排序的元素
Collections.addAll(size,"一","二","三","四","五","陆","柒","八");

2、然后比较规则选择用—— 索引记录大小

①取其字符对应的索引

一.先帝创业未半而中道崩殂
二.宫中府中
三.侍中
四.将军向宠

int index = indexof(“字符”) 取索引字符无法固定→用o1 ,o2代替

取 . 之前的字符 substring (0, .的所索引); .的所索引怎么取 →indexof(“.”);

size.indexOf(o1.substring(0,o1.indexOf(".")))

升序：

size.indexOf(o1.substring(0,o1.indexOf(".")))
-size.indexOf(o2.substring(0,o2.indexOf(".")));

4、进行写入到新文件里

for (String s : list) {
                bufferedWriter.write(s);
                bufferedWriter.newLine();
            }

整体代码

package com.maoteng.d3_char_buffer;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class Test4 {
    /*
     *   目标  ：将乱序的出师表 ，排序好放入到另一个文件中
     */
    public static void main(String[] args) {
//        1、创建字符输入流，与源文件连接
        try (
                BufferedReader bufferedReader = new BufferedReader(new FileReader("io-app\\src\\csb.txt"));
                BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter("io-app/newcsb.txt"));
        ) {
//            2、读取每行数据，存入到字符串中并换行
            String len;
            List<String> list = new ArrayList<>();
            while ((len = bufferedReader.readLine()) != null) {
                list.add(len);
            }
//            指定一个大小规则
            List<String> size = new ArrayList<>();
            Collections.addAll(size,"一","二","三","四","五","陆","柒","八","九","十","十一");
            Collections.sort(list, new Comparator<String>() {
                @Override
                public int compare(String o1, String o2) {
                   return size.indexOf(o1.substring(0,o1.indexOf("."))) -size.indexOf(o2.substring(0,o2.indexOf(".")));
                }
            });

            System.out.println(list);
//            将文件写道另一个新的文件里
            for (String s : list) {
                bufferedWriter.write(s);
                bufferedWriter.newLine();
            }

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

总结：

排序规则不熟

就是subString截取字符串问题和 indexof 获取索引问题

例题：

张三，", “李四，”, “王五，”, "赵喜六，获取他们逗号前面的姓名

1、获取张三的索引

//        获取李四得索引
        int zhangsan = list.indexOf("张三");
        int lisi = list.indexOf("李四");
        System.out.println("张三得索引是："+zhangsan);
        System.out.println("李四得索引是："+lisi);

2、获取他们的姓名

//        截取 逗号前面得字符串
//        ①先获取逗号的索引   ②再进行逗号前面的截取
        for (String s : list) {
            int i = s.indexOf("，");//先获取逗号的索引
            String substring = s.substring(0, i);//②再进行逗号前面的截取
            System.out.println(substring);
        }

整体代码

package com.maoteng.d3_char_buffer;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class StringDemo02 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();

        Collections.addAll(list, "张三，", "李四，", "王五，", "赵喜六，");
//        获取李四得索引
        int zhangsan = list.indexOf("张三");
        int lisi = list.indexOf("李四");
        System.out.println("张三得索引是："+zhangsan);
        System.out.println("李四得索引是："+lisi);

//        截取 逗号前面得字符串
//        ①先获取逗号的索引   ②再进行逗号前面的截取
        for (String s : list) {
            int i = s.indexOf("，");
            String substring = s.substring(0, i);
            System.out.println(substring);
        }

    }
}

  System.out.println("张三得索引是："+zhangsan);
    System.out.println("李四得索引是："+lisi);

// 截取逗号前面得字符串
// ①先获取逗号的索引 ②再进行逗号前面的截取
for (String s : list) {
int i = s.indexOf(“，”);
String substring = s.substring(0, i);
System.out.println(substring);
}

}