Java rop框架 javaio框架

转载

蓝月亮 2023-08-22 21:59:51

文章标签 Java rop框架 java 序列化 System 字符流 文章分类 Java 后端开发

I/O框架

1.什么是流
2.流的分类

字节流

1.文件字节流
2.字节缓冲流
3.对象流

3.1序列化
3.2反序列化
3.3序列化和反序列化的注意事项

字符流

1.文件字符流
2.字符缓冲流
3.打印流

转换流
File类

1.FileFilter接口

流

1.什么是流

概念：内存与存储设备之间数据传输的通道

2.流的分类

按照流向

输入流：将存储设备中的数据内容传输到内存中
输出流：将内存中的数据内容写入存储设备中

按单位

字节流：以字节为单位，可读写所有数据
字符流：以字符为单位，只能读写文本数据

按功能

节点流：具有实际传输数据的读写功能
过滤流：在节点流的基础上增强功能

字节流

字节流的父类（抽象类超类）
-InputStream：字节输入流
-OutStream：字节输出流

1.文件字节流

FileInputSteam：

public int read(byte[] b)//从流中读取多个字节，将读取到的内容存入b数组，返回实际读到的字节数；如果达到尾部折返回-1；

public class Demo01 {
    public static void main(String[] args) throws Exception{
        FileInputStream fileInputStream = new FileInputStream("d://1.txt");
//        //单个字节读取
//        int count=0;
//        while ((count=fileInputStream.read())!=-1){
//            System.out.print((char)count);
//        }
        //一次读取多个字节
        byte[] buf=new byte[3];
        int count1=0;
        while ((count1=fileInputStream.read(buf))!=-1){
            System.out.println(new String(buf,0,count1));
        }
        fileInputStream.close();
    }

}

Java rop框架 javaio框架_Java rop框架

FileOutSteam：

public void wirte(byte[] b)//一次写多个字节，将b数组中所有的字节，写入输出流

public class Demo02 {
    public static void main(String[] args) throws Exception{
        //如果再添加true作为第二个参数，可以一直追加，否则覆盖数据
        //FileOutputStream fileOutputStream = new FileOutputStream("d://bbb.txt",true);
        FileOutputStream fileOutputStream = new FileOutputStream("d://bbb.txt");
        //写入文件
//        fileOutputStream.write(97);
//        fileOutputStream.write('c');
//        fileOutputStream.write('d');
        String s = new String("abd");
        fileOutputStream.write(s.getBytes());
        //关闭流
        fileOutputStream.close();
    }
}

Java rop框架 javaio框架_序列化_02

综合使用

/**
 * 使用字节流实现文件复制
 */
public class Demo03 {
    public static void main(String[] args) throws Exception{
        //输入流
        FileInputStream fileInputStream = new FileInputStream("d://1.jpg");
        //输出流
        FileOutputStream fileOutputStream = new FileOutputStream("d://2.jpg");
        //创建缓存数组
        byte[] bytes=new byte[1024];
        int count=0;
        //边读边写
        while ((count=fileInputStream.read(bytes))!=-1){
            fileOutputStream.write(bytes,0,count);
        }
        //关闭资源
        fileInputStream.close();
        fileOutputStream.close();
        System.out.println("复制完成");
    }
}

2.字节缓冲流

缓冲流：BufferedInputStream/BufferedOutputStream

提高io效率，减少访问磁盘的次数
数据存储在缓冲区中，flush是将缓冲区的内容写入文件中，也可以直接close

BufferedInputStream

/**
 * 使用字节缓冲流
 */
public class Demo04 {
    public static void main(String[] args) throws Exception{
        //创建字节缓冲流
        FileInputStream fileInputStream = new FileInputStream("d://1.txt");
        BufferedInputStream bis = new BufferedInputStream(fileInputStream);
        //读取数据
        int count=0;
        while ((count=bis.read())!=-1){
            System.out.println((char)count);
        }
        //关闭资源
        bis.close();
    }
}

BufferedOutputStream

/**
 * 使用字节缓冲流写入文件
 */
public class Demo05 {
    public static void main(String[] args) throws Exception{
        //创建字节缓冲输出流
        FileOutputStream fileOutputStream = new FileOutputStream("d:1.txt");
        BufferedOutputStream bos = new BufferedOutputStream(fileOutputStream);
        //写入数据
        String s = new String("abcdefg");
        bos.write(s.getBytes());
        //关闭资源
        bos.close();
        System.out.println("写入成功！");
    }
}

3.对象流

对象流：ObjectInputStream/ObjectOutputStream

增强了缓冲区功能
增强了读写8种基本数据类型和字符串功能
增强了读写对象的功能

readObject()从流中读取一个对象
writeObject(Object obj)向流中写入一个对象

使用流传输对象的过程称为序列化和反序列化
实体类需要实现Serializable才可以序列化和反序列化

public class Student implements Serializable {
    private int sno;
    private String name;

    public Student() {
    }

    public Student(int sno, String name) {
        this.sno = sno;
        this.name = name;
    }

    public int getSno() {
        return sno;
    }

    public void setSno(int sno) {
        this.sno = sno;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
      @Override
    public String toString() {
        return "Student{" +
                "sno=" + sno +
                ", name='" + name + '\'' +
                '}';
    }
}

3.1序列化

/**
 * 使用对象流实现序列化
 */
public class Demo06 {
    public static void main(String[] args) throws Exception{
        //创建对象流
        FileOutputStream fileOutputStream = new FileOutputStream("d://1.txt");
        ObjectOutputStream oos = new ObjectOutputStream(fileOutputStream);
        //创建student对象
        Student student = new Student(23, "张三");
        //序列化写入文件
        oos.writeObject(student);
        //关闭资源
        oos.close();

    }
}

3.2反序列化

/**
 * 使用对象流实现反序列化
 */
public class Demo07 {
    public static void main(String[] args) throws Exception{
        //创建对象流
        FileInputStream fileInputStream = new FileInputStream("d://1.txt");
        ObjectInputStream ois = new ObjectInputStream(fileInputStream);
        //实现反序列化读取数据
        Student student = (Student)ois.readObject();
        //关闭资源
        ois.close();
        System.out.println(student.toString());
    }
}

3.3序列化和反序列化的注意事项

序列化类必须要实现Serializable接口
序列化类中对象属性也需要实现Serializable接口
序列化版本id，保证序列化和反序列化是同一个类
private static final long SerialVersionUIDAdder
使用transient（瞬间）修饰属性，这个属性不能序列化
静态属性不可以序列化
可以同时序列化多个对象，借助集合实现

字符流

Java rop框架 javaio框架_字符流_03

当编码方式与解码方式不一致时，就会出现乱码
字符流的父类（抽象类超类）

Read:字符输入流
Write:字符输出流

1.文件字符流

FileReader:

public int read(char[] c)//从流中读取多个字符，将读到的内容存入c数组中，返回实际读到的字符数；如果达到文件的尾部，则返回-1

public class Demo09 {
    public static void main(String[] args) throws Exception{
        //创建字符流
        FileReader fileReader = new FileReader("d://1.txt");
        //读取
//        int data=0;
//        while ((data=fileReader.read())!=-1){
//            System.out.println((char) data);
//        }
        char[] chars=new char[1024];
        int count=0;
        while ((count=fileReader.read(chars))!=-1){
              System.out.println(new String(chars,0,count));
        }
        //关闭资源
        fileReader.close();

    }
}

Java rop框架 javaio框架_字符流_04

FileWriter:

public void wirte(String str)//一次写多个字符，将b数组中所有的字符，写入输出流中

public class Demo10 {
    public static void main(String[] args) throws Exception{
        //创建字符流
        FileWriter fileWriter = new FileWriter("d://1.txt");
        //写入内容到文件
        for (int i = 0; i < 10; i++) {
            fileWriter.write("世界上最好的语言是java\n");
            fileWriter.flush();
        }
        //关闭资源
        fileWriter.close();
    }
}

Java rop框架 javaio框架_序列化_05

综合使用

/**
 * 使用字符流来实现复制文件,只可以复制文本，不可以复制图片和二进制文件
 */
public class Demo11 {
    public static void main(String[] args) throws Exception{
        //创建字符流
        FileReader fileReader = new FileReader("d://1.txt");
        FileWriter fileWriter = new FileWriter("d://2.txt");
        //边读边写
        int data=0;
        while((data=fileReader.read())!=-1){
            fileWriter.write((char)data);
        }
        //关闭资源
        fileReader.close();
        fileWriter.close();
    }
}

2.字符缓冲流

缓冲流：BufferedReader/BufferedWriter

高效读写
支持输入换行符
可一次写一行，读一行

BufferedReader

public class Demo12 {
    public static void main(String[] args) throws Exception{
        //创建字符缓冲流
        FileReader fileReader = new FileReader("d://1.txt");
        BufferedReader br = new BufferedReader(fileReader);
        //读取数据
        //1.第一种方式
//        char[] chars = new char[1024];
//        int count=0;
//        while ((count=br.read(chars))!=-1){
//            System.out.println(new String(chars,0,count));
//        }
        //2.第二种方式
        String line=null;
        while((line= br.readLine())!=null){
            System.out.println(line);
        }
        //关闭资源
        br.close();
    }
}

Java rop框架 javaio框架_序列化_06

BufferedWriter

public class Demo13 {
    public static void main(String[] args) throws Exception{
        //创建字符缓冲流
        FileWriter fileWriter = new FileWriter("d://3.txt");
        BufferedWriter bw = new BufferedWriter(fileWriter);
        //写入文件
        for (int i = 0; i <5 ; i++) {
            bw.write(new String("你好啊！！！！"));
            bw.newLine();
        }
        //关闭资源
        bw.close();
    }
}

Java rop框架 javaio框架_字符流_07

3.打印流

PrintWriter：

封装了print()/println()方法，支持写入后换行
支持数据原样打印

public class Demo14 {
    public static void main(String[] args) throws Exception{
        //创建打印流
        PrintWriter printWriter = new PrintWriter("d://2.txt");
        //打印数据
        printWriter.println(545);
        printWriter.println('a');
        printWriter.println(true);
        printWriter.println("nsidhk");
        //关闭资源
        printWriter.close();

    }
}

Java rop框架 javaio框架_System_08

转换流

桥转换流：InputSteamReader/OutputsteamWriter

可将字节流转换成字符流
可设置字符的编码方式

InputSteamReader

public class Demo15 {
    public static void main(String[] args) throws Exception{
        //创建转换流
        FileInputStream fileInputStream = new FileInputStream("d://1.txt");
        InputStreamReader isr = new InputStreamReader(fileInputStream,"utf-8");
        //读取内容
        int data=0;
        while ((data=isr.read())!=-1){
            System.out.print((char)data);
        }
        //关闭资源
        isr.close();
    }

}

Java rop框架 javaio框架_java_09

OutputsteamWriter

public class Demo16 {
    public static void main(String[] args) throws Exception{
        //创建转换流
        FileOutputStream fileOutputStream = new FileOutputStream("d://4.txt");
        OutputStreamWriter osw = new OutputStreamWriter(fileOutputStream, "utf-8");
        //写入文件
        for (int i = 0; i < 5; i++) {
            osw.write("你好啊兄弟！\n");
        }
        //关闭资源
        osw.close();
    }
}

Java rop框架 javaio框架_Java rop框架_10

File类

概念：代表物理磁盘符中的一个文件或者文件夹
方法：

/**
 * File类使用
 */
public class Demo17 {
    public static void main(String[] args) throws Exception {
        separator();
        fileopen();
        directoryopen();
    }
    //分割符
    public static void separator(){
        System.out.println("路径分隔符"+ File.pathSeparator);
        System.out.println("名称分隔符"+File.separator);
    }
    public static void fileopen() throws Exception {
        //创建文件
        File file = new File("d://5.txt");
        System.out.println(file);
        if (!file.exists()){
            boolean newFile = file.createNewFile();
            System.out.println("创建结果"+true);
        }
        //删除文件
        //1.直接删除
//        boolean delete = file.delete();
//        System.out.println("删除结果"+delete);
//        //2.使用jvm删除
//        file.deleteOnExit();
//        Thread.sleep(2000);

        //获取文件信息
        System.out.println("获取文件的绝对路径："+file.getAbsolutePath());
        System.out.println("获取文件的路径："+file.getPath());
        System.out.println("获取文件名字："+file.getName());
        System.out.println("获取父目录："+file.getParent());
        System.out.println("获取文件长度："+file.length());
        System.out.println("文件创建时间："+new Date(file.lastModified()).toLocaleString());

        //判断
        System.out.println("是否可写："+file.canWrite());
        System.out.println("是否为文件："+file.isFile());
        System.out.println("是否隐藏："+file.isHidden());
    }
    public static void directoryopen(){
        //创建文件夹
        File file = new File("d://aa//bb//cc");
        System.out.println(file);
        if (!file.exists()){
            //file.mkdir();//只能创建单级目录
            System.out.println("创建结果："+file.mkdirs());//创建多级目录
        }
        //删除文件
        //file.delete();//只能删除空目录
        //file.deleteOnExit();

        //获取文件夹信息
        System.out.println("获取文件的绝对路径："+file.getAbsolutePath());
        System.out.println("获取文件的路径："+file.getPath());
        System.out.println("获取文件名字："+file.getName());
        System.out.println("获取父目录："+file.getParent());
        System.out.println("获取文件长度："+file.length());
        System.out.println("文件创建时间："+new Date(file.lastModified()).toLocaleString());

        //判断
        System.out.println("是否可写："+file.canWrite());
        System.out.println("是否为文件："+file.isFile());
        System.out.println("是否隐藏："+file.isHidden());

        //遍历文件夹
        File file1 = new File("d://");
        String[] list = file1.list();
        System.out.println("-------------");
        for (String s : list) {
            System.out.println(s);
        }
    }

}

Java rop框架 javaio框架_字符流_11

1.FileFilter接口

public interface FileFilter

boolean accept(File pathname)

当调用File类中的listFiles()方法时，支持传入FileFilter接口接口实现类，对获取文件进行过滤，只有满足要求的文件才可以出现在listFiles()的返回值中

public class Demo18 {
    public static void main(String[] args) {
        File file = new File("d://");
        System.out.println(file);
        File[] files = file.listFiles(new FileFilter() {
            @Override
            public boolean accept(File pathname) {
                if (pathname.getName().endsWith(".txt")) {
                    return true;
                }
                return false;
            }
        });
        for (File file1 : files) {
            System.out.println(file1.getName());
        }
    }
}

Java rop框架 javaio框架_java_12

综合使用
递归遍历文件夹和删除文件夹

public class Demo20 {
    public static void main(String[] args) throws Exception{
        //创建集合
        Properties properties = new Properties();
        //添加数据
        properties.setProperty("username","张三");
        properties.setProperty("age","20");
        System.out.println(properties);
        //遍历
        //1.keySet
        //2.entrySet
        Set<Map.Entry<Object, Object>> entries = properties.entrySet();
        Iterator<Map.Entry<Object, Object>> iterator = entries.iterator();
        while (iterator.hasNext()){
            Map.Entry<Object, Object> next = iterator.next();
            Object key = next.getKey();
            Object value = next.getValue();
            System.out.println(key+"=========="+value);

        }
        //3.stringPropertyNames()
        Set<String> strings = properties.stringPropertyNames();
        for (String string : strings) {
            System.out.println(string+"======"+properties.getProperty(string));
        }
        //和流有关的方法
        PrintWriter printWriter = new PrintWriter("d://6.txt");
        properties.list(printWriter);
        printWriter.close();

        //store方法保存
        FileOutputStream fileOutputStream = new FileOutputStream("d://store.properties");
        properties.store(fileOutputStream,"注释");
        fileOutputStream.close();
        //load方法加载
        FileInputStream fileInputStream = new FileInputStream("d://store.properties");
        Properties properties1 = new Properties();
        properties1.load(fileInputStream);
        fileInputStream.close();
    }
}

Java rop框架 javaio框架_序列化_13

Java rop框架 javaio框架_java_14

Java rop框架 javaio框架_Java rop框架_15

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。

上一篇：docker 拉取 python3 python调用docker接口

下一篇：python 读取label的值 python读取数据的方法

提问和评论都可以，用心的回复会被更多人看到评论

发布评论

相关文章

官方博客	全部文章	热门标签	班级博客
了解我们	网站地图	意见反馈

鸿蒙开发者社区	51CTO学堂
51CTO	软考资讯