IO流 序列化&反序列化 Properties 缓冲流 字节流 字符流

最新推荐文章于 2024-10-01 18:51:18 发布
最新推荐文章于 2024-10-01 18:51:18 发布
阅读量209 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45273160/article/details/112521744
版权

在这里插入图片描述

package com.llb.io;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;

/**
 * 字节流
 */
public class MyByteIO {
    public static void main(String[] args) throws Exception {
//        myFileOutPut();
        myFileInPut();
    }
    private static void myFileOutPut()throws Exception{
        //创建字节输出流对象
        //告诉JVM要往哪个文件中写数据了
        //如果文件不存在  会自动创建一个
        //如果文件存在   会把文件清空
        //第二个参数表示续写功能  true
        FileOutputStream fos =
                new FileOutputStream(
                        new File("E:\\itheima\\test\\aaa\\c.txt"),true);
        //写数据   传递的是一个整数的话  实际写到文件中的是整数在码表中对应的那个字符
        fos.write(97);
        //实现换行
        fos.write("\r\n".getBytes());
        String str = "云想衣裳花想容，\t春风拂槛露华浓。\n若非群玉山头见，\t会向瑶台月下逢。";
        fos.write(str.getBytes());

        /*byte[] bytes = {97,98,99};
        fos.write(bytes);*/
        /*byte[] bytes = {97,98,99,100,101,102,103};
        fos.write(bytes,3,4);*/
        //释放资源
        //告诉操作系统  此文件已经不在操作中了
        fos.close();
    }

    private static void myFileInPut()throws Exception{
        //获取字节输入流对象
            //如果文件不存在会报错
        FileInputStream fis =
                new FileInputStream(
                        new File("E:\\itheima\\test\\aaa\\c.txt"));
        //读数据  一次读取一个字节
            //如果想要看到字符数据，要强转成char类型
//        int read = fis.read();
//        System.out.println((char)read);
        int b ;
        while ((b = fis.read()) != -1){
            System.out.println((char)b);
        }

        fis.close();
    }
}


package com.llb.io;

import java.io.*;

public class MyBuffered {
    public static void main(String[] args) throws Exception {
        //在底层创建了一个默认长度为8192的字节数组
        BufferedInputStream bis =
                new BufferedInputStream(
                        new FileInputStream("E:\\itheima\\test\\aaa\\a.mp4"));
        BufferedOutputStream bos =
                new BufferedOutputStream(
                        new FileOutputStream("E:\\itheima\\test\\copy.mp4"));
//        int b ;
//        while ((b=bis.read())!=-1){
//            bos.write(b);
//        }
        int len ;
        byte[] bytes = new byte[1024];
        while ((len=bis.read(bytes))!=-1){
            bos.write(bytes,0,len);
        }
        bos.close();
        bis.close();
    }
}


package com.llb.io;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;

/**
 * 文件拷贝
 */
public class FileCopy {
    public static void main(String[] args)throws Exception {
//        copy();
        copyBig();
    }
    private static void copy()throws Exception{
        FileInputStream fis =
                new FileInputStream(
                        new File("E:\\itheima\\test\\aaa\\a.mp4"));
        FileOutputStream fos =
                new FileOutputStream(
                        new File("E:\\itheima\\test\\a.mp4"));
        int b ;
        while ((b=fis.read())!=-1){
            fos.write(b);
        }
        fos.close();
        fis.close();
    }
    private static void copyBig() throws Exception {
        FileInputStream fis =
                new FileInputStream(
                        new File("E:\\itheima\\test\\aaa\\a.mp4"));
        FileOutputStream fos =
                new FileOutputStream(
                        new File("E:\\itheima\\test\\a.mp4"));
        byte[] bytes = new byte[1024];
        int count=0;
        int len;//本次读到的有效字节个数   读到了几个字节
        //把读取到的字节个数放到len里面
        //用 len 和 -1 比较，如果不等于-1表示读到了数据，如果等于-1表示读到了文件末尾
        while ((len = fis.read(bytes))!=-1){
            fos.write(bytes,0,len);
            count++;
        }
        System.out.println(count);
        fos.close();
        fis.close();
    }
}


package com.llb.io;

import java.io.*;

public class BufferedCopy {
    public static void main(String[] args) throws Exception {

        BufferedInputStream bis =
                new BufferedInputStream(
                        new FileInputStream("E:\\itheima\\test\\aaa\\a.mp4"));
        BufferedOutputStream bos =
                new BufferedOutputStream(
                        new FileOutputStream("E:\\itheima\\test\\copy.mp4"));

        byte[] bytes = new byte[1024];
        int len;
        while ((len=bis.read(bytes))!=-1){
            bos.write(bytes,0,len);
        }
        bos.close();
        bis.close();
    }
}


package com.llb.转换流;

import java.io.*;

/**
 *转换流
 */
public class Demo {
    public static void main(String[] args) throws Exception {

        OutputStreamWriter osw =
                new OutputStreamWriter(new FileOutputStream("Day12\\c.txt"),
                        "UTF-8");
        osw.write("悲莫悲兮生别离");

        osw.write("乐莫乐兮新相知");
        osw.close();
        InputStreamReader isr =
                new InputStreamReader(
                        new FileInputStream("Day12\\c.txt"),
                        "UTF-8");
        int len;
        char[] chars = new char[1024];
        while ((len=isr.read())!=-1){
            System.out.println(new String(chars,0,len));
        }
        isr.close();
    }
}


/**
* 序列化和反序列化
* 对象流
*/
package com.llb.对象操作流;

import java.io.*;
import java.util.ArrayList;

public class Exercise {
    public static void main(String[] args) throws Exception {
        Student student1 = new Student("刘备",18);
        Student student2 = new Student("关羽",19);
        Student student3 = new Student("张飞",17);
        ObjectOutputStream oos =
                new ObjectOutputStream(new FileOutputStream("Day12\\e.txt"));
//        oos.writeObject(student1);
//        oos.writeObject(student2);
//        oos.writeObject(student3);
        ArrayList<Student> list = new ArrayList<Student>();
        list.add(student1);
        list.add(student2);
        list.add(student3);
        oos.writeObject(list);
        oos.close();
        ObjectInputStream ois =
                new ObjectInputStream(new FileInputStream("Day12\\e.txt"));
        ArrayList<Student> o = (ArrayList<Student>) ois.readObject();
        for (Student student : o) {
            System.out.println(student);
        }
        ois.close();
    }
}
class Student implements Serializable {
    private static final long serialVersionUID=1L;
    private String username;
    private Integer age;

    @Override
    public String toString() {
        return "Student{" +
                "username='" + username + '\'' +
                ", age=" + age +
                '}';
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public Student(String username, Integer age) {
        this.username = username;
        this.age = age;
    }

    public Student() {
    }
}


package com.llb.对象操作流;

import java.io.*;

/**
 * 把对象以字节的方式写到本地文件，直接打开文件，是读不懂的，需再次用对象操作流读到内从中
 *
 * Serializable
 *   标记行接口，里面没有任何的抽象方法
 *   只要有一个类实现了这个方法，就标志这个类可以被序列化
 *
 *   serialVersionUID   序列号
 *     如果我们没有定义  JVM会帮我们根据类里面的信息计算出一个序列号
 *     如果我们修改了类中的信息  JVM会再次计算出一个序列号
 *
 */
public class Demo {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        /**
         * 序列化
         */
//        User user = new User("tom","123");
//        ObjectOutputStream oos =
//                new ObjectOutputStream(new FileOutputStream("Day12\\d.txt"));
//        oos.writeObject(user);
//        oos.close();
        /**
         * 反序列化
         */
        ObjectInputStream ois =
                new ObjectInputStream(new FileInputStream("Day12\\d.txt"));
        User user = (User) ois.readObject();
        System.out.println(user);
        ois.close();
    }
}
class User implements Serializable {
    
    private String username;
    //瞬态关键字
    private transient String password;
	//自定义序列号
    private static final long serialVersionUID=1L;

    @Override
    public String toString() {
        return "User{" +
                "username='" + username + '\'' +
                ", password='" + password + '\'' +
                '}';
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public User(String username, String password) {
        this.username = username;
        this.password = password;
    }

    public User() {
    }
}


package com.llb.字符流;

import java.io.*;
import java.util.Scanner;


public class Exercise {
    public static void main(String[] args) throws IOException {
        write();
    }
    /**
     * 键盘录入用户名和密码保存到本地实现永久化存储
     */
    private static void write()throws IOException{
        //键盘录入用户名和密码
        Scanner sc = new Scanner(System.in);
        System.out.println("请录入用户名");
        String username = sc.next();
        System.out.println("请录入密码");
        String password = sc.next();

        //分别把用户名和密码写到本地文件
        FileWriter fw = new FileWriter(new File("Day12\\a.txt"));
        //将用户名和密码写到文件中
        fw.write(username);
        fw.write("=");
        fw.write(password);
        fw.flush();
        fw.close();
    }
    private static void read() throws FileNotFoundException {
        FileReader fr = new FileReader(new File("Day12\\a.txt"));
        int len;

    }
}


package com.llb.字符流;

import javax.xml.transform.Source;
import java.io.*;
import java.util.Arrays;

public class BufferedExe {
    public static void main(String[] args) throws IOException {
        BufferedReader br =
                new BufferedReader(new FileReader("Day12\\b.txt"));
        String s = br.readLine();
        String[] s1 = s.split(" ");
        //字符串数组变成int类型数组
        int[] arr = new int[s1.length];
        //遍历s1数组  进行类型转换
        for (int i = 0; i < s1.length; i++) {
            String s3 = s1[i];
            //类型转换
            int num = Integer.parseInt(s3);
            arr[i] = num;
        }
        System.out.println("排序前的数组 : "+Arrays.toString(arr));
        Arrays.sort(arr);
        System.out.println("排序后的数组 : "+Arrays.toString(arr));

        //将排序后的数组存入到源文件中
        BufferedWriter bw =
                new BufferedWriter(new FileWriter("Day12\\b.txt"));
        for (int i : arr) {
            bw.write(i+" ");
            bw.flush();
        }
        bw.close();
        br.close();
    }
}


package com.llb.字符流;

import java.io.*;

public class BufferedDemo {
    public static void main(String[] args) throws Exception {
//        reader();
//        writer();
        /**
         * 字符缓冲流特有功能
         * newLine()  回车换行
         *
         * redaLine()  读一行
         */
        /*BufferedWriter bw =
                new BufferedWriter(new FileWriter("Day12\\a.txt"));
        bw.write("云想衣裳花想容");
        bw.newLine();
        bw.write("春风拂槛露华浓");
        bw.newLine();
        bw.flush();
        bw.close();*/

        BufferedReader br =
                new BufferedReader(new FileReader("Day12\\a.txt"));
        //读一行   如果读不到数据会返回null值
        String line;
        //一直读，读到换行为止，但是不会读到回车换行符
        while ((line=br.readLine())!=null){
            System.out.println(line);
        }
//        String s1 = br.readLine();
//        String s2 = br.readLine();
//        System.out.println(s1);
//        System.out.println(s2);
        br.close();


    }
    private static void reader() throws Exception {
        //字符缓冲输入流
        BufferedReader br =
                new BufferedReader(new FileReader("Day12\\a.txt"));
        //读取数据
        char[] chars = new char[1024];
        int len;
        while ((len=br.read(chars))!=-1){
            System.out.println(new String(chars,0,len));
        }
        br.close();
    }
    private static void writer() throws Exception{
        BufferedWriter bw =
                new BufferedWriter(new FileWriter("Day12\\b.txt"));
        bw.write(97);
        char[] chars = {98,99,100,101,102,103};
        bw.write(chars);
        bw.write(chars,0,chars.length);
        bw.close();
    }
}

在这里插入图片描述

package com.llb.properties;

import java.util.Map;
import java.util.Properties;
import java.util.Set;

/**
 * Properties
 *   Map集合的一个类
 */
public class Demo {
    public static void main(String[] args) {
        Properties prop = new Properties();
        //增
        prop.put("1003","hinata3");
        prop.put("1001","hinata1");
        prop.put("1002","hinata2");
        prop.setProperty("中国","北京");
        System.out.println(prop);
        //删
        prop.remove("1001");
        //改
        prop.put("1002","naruto");
        System.out.println(prop);
        //获取所有键的集合
        Set<String> set = prop.stringPropertyNames();
        for (String s : set) {
            System.out.print("key's set "+s+"\t");
        }
        System.out.println();
        //通过entrySet()方法获取全部key value对象
        Set<Map.Entry<Object, Object>> entries = prop.entrySet();
        for (Map.Entry<Object, Object> entry : entries) {
            Object key = entry.getKey();//获取key
            Object value = entry.getValue();//获取value
            System.out.print(key);
            System.out.println(value);
        }
    }
}
兔子没钱
关注
Java IO流之序列化流【六】
会者定离，一期一祈
03-14 2008
1.概述 Java语言 提供了一种对象序列化的机制。用一个字节序列表示一个对象，该字节序列包含该对象的数据、对象的类型和对象中存储的属性等信息。 字节序列写出到文件之后，相当于文件中持久保存了一个对象的信息。 反之，该字节序列还可以从文件中读取回来，重构对象，对它进行反序列化。 对象的数据、类型和存储的数据信息，都可以用来在内存中创建对象。 2.ObjectOutputStream类 java.io.ObjectOutputStream 类是对象的序列化流，可以将 Java 对象的基本数据类型和图形写入 O
IO流与序列化
05-09
Java中的IO流分为字节流和字符流两大类，每类又分为输入流和输出流。字节流处理的是8位的字节数据，如InputStream和OutputStream家族；字符流处理的是16位的Unicode字符，如Reader和Writer家族。此外，还有缓冲流...
IO流（字符流，对象的序列化和反序列化）
z3447643805的博客
02-06 205
二、字符流
【Java基础-3】吃透Java IO：字节流、字符流、缓冲流
热门推荐
云深不知处
09-23 15万+
什么是Java-IO？字符流和字节流的区别与适用场景是什么？缓冲流到底实现了什么？如何高效地读写文件？ 本文用大量的示例图和实例，带你吃透Java IO。
IO流：字节流、字符流、缓冲流、转换流、数据流、序列化流 --Java学习笔记
m0_71386740的博客
04-04 1215
在try-catch-finally中无论代码是否报错，它都会在结束之前执行finally里面的语句，除非在其它地方使用System.exit()关闭了jvm，所以使用try-catch-finally方式是肯定会释放资源执行close的。即使每次读取三个字节，依旧无法避免乱码的可能，因为若读取的字符串排列为前面俩个英文接一个中文，就会读取到前面俩个英文的（英文数字在utf-8中占一个字节）字节和中文的其中一个字节。自带8K(8192)的字符缓冲池，可以提高字符输入流读取字符数据的性能。
【Java编程进阶之路 07】深入探索：Java序列化的深层秘密 & 字节流
weixin_40736233的博客
03-03 991
Java序列化是将Java对象的状态转换为字节流的过程，以便在网络中传输、保存到文件中或进行持久化存储。序列化后的字节流可重建为原始对象，即反序列化。序列化常用于远程方法调用、对象持久化、深拷贝及数据传输等场景。但需注意，反序列化可能带来安全风险，且类版本变化可能影响兼容性。因此，使用序列化时需谨慎考虑安全性和版本控制。
java IO 字节流、字符流操作总结三之字符流、序列化和反序列化
XXiaoLEI的专栏
03-30 2993
8.0 java IO输入输出流 1.gbk 编码中文占用2个字节，英文占用1个字节。 2、utf-8编码中文占用3个字节，英文占用1个字节。   Java是双字节编码，utf-16be编码。即char占用2个字节。 注意：当你的字节序列是某种编码时，这个时候想把字节序列变成字符串，也需要用这种编码方式。否则会出现乱码。   文本文件就是字节序列，可以是任意编码的字节序列。但是如果我
Java-IO流、序列化与反序列化
悟兰因的博客
01-12 735
Java——IO流
Java 入门指南：Java IO流 —— 序列化与反序列化
Zachyy的博客
08-27 1373
序列化是指将对象转换为字节流的过程，以便能够将其存储到文件、内存、网络传输等介质中，或者在不同的进程、网络或机器之间进行数据交换。 序列化的逆过程称为反序列化，即将字节流转换为对象。过反序列化，可以从存储介质或网络传输中读取数据，并重新构建对象。
Java IO篇：序列化与反序列化
张维鹏的博客
01-12 1万+
两个服务之间要传输一个数据对象，就需要将对象转换成二进制流，通过网络传输到对方服务，再转换成对象，供服务方法调用。这个编码和解码的过程称之为序列化和反序列化。所以序列化就是把 Java 对象变成二进制形式，本质上就是一个byte[]数组。将对象序列化之后，就可以写入磁盘进行保存或者通过网络中输出给远程服务了。反之，反序列化可以从网络或者磁盘中读取的字节数组，反序列化成对象，在程序中使用。
Java Object字节流及序列化和反序列化
qq_57570052的博客
07-24 1193
Serialization(序列化)：将java对象以一连串的字节保存在磁盘文件中的过程，也可以说是保存java对象状态的过程。序列化可以将数据永久保存在磁盘上(通常保存在文件中)。deserialization(反序列化)：将保存在磁盘文件中的java字节码重新转换成java对象称为反序列化。实现了数据的持久化，通过序列化可以把数据持久地保存在硬盘上(磁盘文件)。利用序列化实现远程通信，在网络上传输字节序列。
day21_缓冲流、转换流、序列化流、Commons IO.pdf
11-02
缓冲流分为字节缓冲流和字符缓冲流两大类，分别是`BufferedInputStream`和`BufferedOutputStream`（处理字节流）以及`BufferedReader`和`BufferedWriter`（处理字符流）。缓冲流的主要作用在于减少对系统I/O操作的...
Java的IO流讲解代码: File 类、RandomAccessFile 类、字节流（文件字节流、缓冲字节流、基本数据类型
06-20
File 类、RandomAccessFile 类、字节流（文件字节流、缓冲字节流、基本数据类型字节流、打印流、对象序列化流、字节数组流）、字符流（缓冲字符流、文件字符流、转换流、格式化输出流、字符数组流） 这份代码源码...
JavaScript ArrayBuffer的读写与类型转换
最新发布
白瑕 的博客
10-01 414
所有视图的基本单位是ArrayBuffer, ArrayBuffer中只存储二进制格式的数据.ArrayBuffer不可直接读写, 必须通过视图(比如DataView)暴露的API.
Spring Cloud全解析：服务调用之OpenFeign集成OkHttp
Lxn2zh的博客
09-30 765
HTTP连接需要进行TCP三次握手，是一个比较耗时的操作，一般我们不直接使用HttpURLConnection，而是使用HttpClient/okHttp等支持连接池的客户端工具，以Feign集成OkHttp为例。OpenFeign本质是HTTP来进行服务调用的，也就是需要集成一个Http客户端。默认是HttpURLConnection方式，也就是jdk中提供的最原始的那个。要开启OkHttp ,还需要在YML 中添加开启配置项，默认是关闭的。使用的是Client接口来进行请求的。
「Java开发指南」如何用MyEclipse为iPhone搭建Spring应用程序？
需要界面开发、IDE工具研发中文教程资料的小伙伴，记得私信我~
09-30 693
本教程将介绍如何用MyEclipse为iPhone搭建Spring应用程序，欢迎下载最新版IDE体验！
spring-boot 整合 mybatis
m0_72168501的博客
09-29 522
spring boot 整合 mybatis
Java内存布局
阿呆的专栏
10-01 790
64位 JVM 不启用指针压缩时：Object Header 大小是16字节。64位 JVM 启用指针压缩时（默认）：Object Header 大小是12字节。32位 JVM：Object Header 大小是8字节。JVM在默认情况下启用指针压缩，但如果堆内存超过32GB，就会禁用指针压缩。32GB是压缩指针的最大寻址范围。超过32GB的堆内存中，压缩指针带来的性能提升并不显著，而且需要解压指针反而可能增加开销。
Java IO流详解：操作文件、序列化与实践
Java学习笔记深入探讨了IO流在Java编程中的关键作用，它涉及文件和目录操作、数据读写、以及序列化和反序列化的概念。首先，让我们从基础的IO流概念开始： 1. 文件和目录操作：`File` 类是Java中处理文件和目录的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值