java IO流 ObjectStream PipedStream 随机访问文件 字符编码--21

iOS自动化之打包-xcodebuild命令行打包.app并安装到ios模拟器 xcode xcodebuild xcrun ios模拟器 iOS UI自动化测试 ios自动打包安装到ios模拟器 阅读详情

ObjectStream

操作对象
ObjectInputStream和ObjectOutputStream
被操作的对象需要实现Serializable(标记接口)

ObjectOutputStream 将 java 对象的基本数据类型和图形写入OutputStream。可以使用ObjectInputStream读取(重构)对象,通过在流中使用文件可以实现对象的持久存储。

java会根据对象自定义一个UID值将其序列化,随着对象的更改,UID值也会变化,导致前后无法相关联 读不出数据。根据这个情况, 可以自定义UID值,可以保证更改对象后依然能读出数据。

public static final long serialVersionUID = 42L;
另外,静态不能被序列化,因为静态在方法区中先于对象加载
static String country = “CN”;
如果对于非静态成员也不想序列化,可以transient修饰
transient int age;

transient修饰age会打印出age = 0
transient修饰name会打印出name = null

package day21;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class ObjectStreamDemo {


    public static void main(String[] args) throws Exception{
        //writeObj();
        readObj();
    }


    public static void readObj()throws Exception {
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("obj.txt"));

        Person p = (Person)ois.readObject();

        System.out.println(p);

        ois.close();
    }

    public static void writeObj()throws IOException{
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("obj.txt"));
        oos.writeObject(new Person("lisi",39,"kr"));

        oos.close();
    }
}
package day21;

import java.io.Serializable;

public class Person implements Serializable{

//  自定义UID值,可以保证更改对象后依然能读出
    public static final long serialVersionUID = 42L;

    private String name;
    int age;
    static String country = "CN";

    public Person(String name, int age,String country) {
        this.name = name;
        this.age = age;
        this.country = country;
    }

    public String toString(){
        return name+"..."+age+"....."+country;
    }

}

这里写图片描述

管道流

管道流分为管道输入流(PipedInputStream)和管道输出流(PipedOutputStream)
管道输入流应该连接到管道输出流,管道输入流提供要写入管道输出流的所有数据字节。通常,数据由某个从PipedInputStream对象读取,并由其他线程将其写入到相应的PipedOutputStream
不建议对这两个对象尝试单线程,因为这样可能会死锁线程。要分别用一个线程负责一个管道流,当一个处于等待的情况时, 另一个线程可以运行不会死锁

这是涉及了多线程的IO流
(涉及了集合的IO流是Properties)

package day21;

import java.io.IOException;
import java.io.PipedInputStream;
import java.io.PipedOutputStream;

public class PipedStream {


    public static void main(String[] args) throws IOException {

        PipedInputStream pis = new PipedInputStream();
        PipedOutputStream pos = new PipedOutputStream();

        pis.connect(pos);

        Read r = new Read(pis);
        Write w = new Write(pos);

        new Thread(r).start();
        new Thread(w).start();
    }

}

class Read implements Runnable {
    private PipedInputStream pis;

    Read(PipedInputStream pis) {
        this.pis = pis;
    }

    public void run() {
        try {
            byte[] buf = new byte[1024];

            System.out.println("没有数据可以读取,先阻塞");

            int len = pis.read(buf);

            System.out.println("读到数据,阻塞结束");

            String s = new String(buf, 0, len);

            System.out.println(s);

            pis.close();

        } catch (IOException e) {
            throw new RuntimeException("管道读取失败");
        }
    }
}

class Write implements Runnable {
    private PipedOutputStream pos;

    Write(PipedOutputStream pos) {
        this.pos = pos;
    }

    public void run() {
        try {
            System.out.println("等待6s后写入数据");
            Thread.sleep(6000);
            pos.write("piped laile".getBytes());

            pos.close();

        } catch (Exception e) {
            throw new RuntimeException("管道输出失败");
        }
    }
}

这里写图片描述

RandomAccessFile-随机访问文件

该类不是IO中的体系的子类,而是直接继承自Object。但是它是IO包中的成员,因为它具备读和写的功能 内部封装了一个数组,而且通过指针对数组的元素进行操作,可以通过getFilePointer获取指针位置,同时可以通过seek改变指针的位置。

其实完成读写的原理就是内部封装了字节输入流和字节输出流。

通过构造函数,可以看出该类只能操作文件。 而且操作文件还有模式:r或者rw等
如果模式为只读r,不会创建文件,会去读取一个已存在的文件,若该文件不存在,报出异常
如果模式为rw,可以创建文件。该对象的构造函数要操作的文件不存在,会自动创建,如果存在则不会覆盖

应用:多线程的分段下载,每个线程负责不同的区域下载

package day21;

import java.io.IOException;
import java.io.RandomAccessFile;

public class RandomAccessFileDemo {


    public static void main(String[] args) throws IOException {
        //writeFile_2();
        //writeFile();
        readFile();
    }

    public static void readFile() throws IOException {
        RandomAccessFile raf = new RandomAccessFile("ran.txt", "r");

        // 调整指针的位置
        // raf.seek(8);

        // 跳过指定的字节数
        raf.skipBytes(8);

        byte[] buf = new byte[4];

        raf.read(buf);

        String name = new String(buf);

        int age = raf.readInt();

        System.out.println("name=" + name);
        System.out.println("age=" + age);
        System.outprintln(raf.getFilePointer());
        raf.close();
    }

    public static void writeFile_2() throws IOException {
        RandomAccessFile raf = new RandomAccessFile("ran.txt", "rw");
        raf.seek(8 * 0);
//      会覆盖原来起始位置上的数据。李四被赵柳覆盖。
        raf.write("赵柳".getBytes());
        raf.writeInt(101);

        raf.close();
    }

    public static void writeFile() throws IOException {
        RandomAccessFile raf = new RandomAccessFile("ran.txt", "rw");

        raf.write("李四".getBytes());
        raf.writeInt(97);
        raf.write("王五".getBytes());
        raf.writeInt(99);

        raf.close();

    }

}

这里写图片描述

DataStream:操作基本数据类型的流对象

package day21;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class DataStreamDemo {

    /**
     * DataInputStream和DataOutputStream 可以用于操作基本数据类型的数据的流对象
     * 
     * 记住:凡是操作基本数据类型,就用DataStream。
     * 
     */
    public static void main(String[] args) throws IOException {
        // readData();
        // writeData();

        // writeUTFDemo();
        readUTFDemo();
    }

    public static void readUTFDemo() throws IOException {
        DataInputStream dis = new DataInputStream(new FileInputStream(
                "utfdata.txt"));
        // 用writeUTF写的文件必须要用readUTF读取。
        // 也必须用readUTF读writeUTF写出的文件。
        // 否则会报出EOFException - 如果此流在读取所有字节之前到达末尾。
        // 因为以打印“你好”为例,utf-8是6个字节,UTF-8 修改版是8个字节。
        // 所以用readUTF读取utf-8格式的文件会导致8个字节没读完就到达末尾。
        String s = dis.readUTF();

        System.out.println(s);

        dis.close();
    }

    public static void writeUTFDemo() throws IOException {
        DataOutputStream dos = new DataOutputStream(new FileOutputStream(
                "utfdata.txt"));

        dos.writeUTF("你好");
        // 与普通的UTF-8不同,以打印“你好”为例,utf-8是6个字节,gbk是4个字节,UTF-8 修改版是8个字节
        dos.close();
    }

    public static void readData() throws IOException {

        DataInputStream dis = new DataInputStream(new FileInputStream(
                "data.txt"));

        // 读取的顺序与写入的顺序要一致,否则会乱码
        int num = dis.readInt();
        boolean b = dis.readBoolean();
        double d = dis.readDouble();

        System.out.println(num);
        System.out.println(b);
        System.out.println(d);

        dis.close();

    }

    public static void writeData() throws IOException {
        DataOutputStream dos = new DataOutputStream(new FileOutputStream(
                "data.txt"));

        dos.writeInt(2324);
        dos.writeBoolean(true);
        dos.writeDouble(234.65);

        dos.close();
    }

}

这里写图片描述

ByteArrayStream

用于操作字节数组的流对象
ByteArrayInputStream:在构造的时候,需要接受一个数据源,而且数据源是一个字节数组
ByteArrayOutputStream:在构造的时候,不用定义数据目的,因为该对象中已经内部封装了可变长度的字节数组。这就是数据目的。

因为两个流对象都操作数组,没有使用系统资源,不用close关闭
这两个类中的方法在关闭此流后仍可被调用,而不会产生任何 IOException。

在流操作规律讲解时,
源设备:
键盘System.in,硬盘FileStream,内存ArrayStreeam
目的设备:
控制台System.out,硬盘FileStream,内存ArrayStream

package day21;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;

public class ByteArrayStream {

    public static void main(String[] args) {
        // 数据源
        ByteArrayInputStream bis = new ByteArrayInputStream("abcdef".getBytes());

        // 数据目的
        ByteArrayOutputStream bos = new ByteArrayOutputStream();

        int by = 0;

        while ((by = bis.read()) != -1) {
            bos.write(by);
        }

        System.out.println(bos.size());
        // 把byte数组转成字符串,并变成大写格式
        System.out.println(bos.toString().toUpperCase());
    }
}

这里写图片描述

// 另外还有:
// 操作字符数组:
// CharArrayReader:需要抛出IOException,用的是toCharArray()的方法
CharArrayReader car = new CharArrayReader("abcdef".toCharArray());
// CharArrayWrite:关闭无效,不会抛出IOException
 CharArrayWriter caw = new CharArrayWriter();
 int by = 0;
 while ((by = car.read()) != -1) {
     caw.write(by);
}
//需要toString()后才能使用toUpperCase方法
System.out.println(caw.size());
System.out.println(caw.toString().toUpperCase());
car.close();


//操作字符串:
// StringReader:需要抛出IOException。
 StringReader sr = new StringReader("abcdef");
// StringWriter:关闭无效,不会抛出IOException
StringWriter sw = new StringWriter();
int by = 0;
while ((by = sr.read()) != -1) {
    sw.write(by);
}
//需要toString()后才能使用.length方法,toUpperCase方法
System.out.println(sw.toString().length());
System.out.println(sw.toString().toUpperCase());

sr.close();

字符编码

字符流的出现为了方便操作字符。
更重要的是加入了编码转换。
通过子类转换流来完成
InputStreamReader:是字节流通向字符流的桥梁
OutputStreamWriter:是字符流通向字节流的桥梁
在两个对象构造的时候加入了字符集。

package day21;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;

public class EncodeStream {


    public static void main(String[] args) throws IOException{
        //writeText();
        readText();
    }

    public static void readText()throws IOException{
        InputStreamReader isr = new InputStreamReader(new FileInputStream("utf.txt"),"gbk");
        //      用gbk读取utf-8编写的文件,“你好”打印出了“浣犲ソ”
        //      用utf-8读取gbk编写的文件,“你好”打印出了“??”
        char[] buf = new char[10];

        int len = isr.read(buf);

        String s = new String(buf,0,len);

        System.out.println(s);

        isr.close();
    }

    public static void writeText()throws IOException{
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("utf.txt"),"utf-8");

        osw.write("你好");

        osw.close();
    }

}

这里写图片描述
这里写图片描述

编码与解码

编码:字符串变成字节数组

解码:字节数组变成字符串

String——>byte[]: str.getBytes(charsetName);

byte[]——>String: new String(byte[],charsetName);

package day21;

import java.io.IOException;
import java.util.Arrays;

public class EncodeDemo {


    public static void main(String[] args) throws IOException {

        String s = "你好";

        byte[] b1 = s.getBytes("GBK");

        System.out.println("b1=" + Arrays.toString(b1));

        String s1 = new String(b1, "ISO8859-1");

        System.out.println("s1=" + s1);
//若解码时用错误的表解码错误,可以通过解码所用码表转换回原来的字节数组,再通过这个字节数组按照正确的编码表解码
//gbk与utf-8之间不行,因为utf-8也包含汉字,会出现乱码,变不回来
        byte[] b2 = s1.getBytes("ISO8859-1");

        System.out.println("b2=" + Arrays.toString(b2));

        String s2 = new String(b2, "GBK");

        System.out.println("s2=" + s2);

    }

}

这里写图片描述

联通的现象

package day21;

import java.io.IOException;
import java.util.Arrays;

public class EncodeDemo2 {

    public static void main(String[] args) throws IOException{
        String s = "联通";
        byte[] b1 = s.getBytes();

        System.out.println("by="+Arrays.toString(b1));

        String s1 = new String(b1);

        System.out.println("s1="+s1);

    }

}

这里写图片描述

而在记事本中写入“联通”,重新打开却是“��ͨ”。因为“联通”在gbk码中的表现形式与UTF-8编码规律相同。打开时记事本启用了UTF-8码表,造成乱码。
这里写图片描述
这里写图片描述

附:UTF-8表编码格式

这里写图片描述

终极练习:录入学生成绩

有五个学生,每个学生有三门课的成绩,
从键盘输入以上数据(包括姓名,三门课成绩)
输入的格式:张三,30,40,50,计算出总成绩

1,描述学生对象
2,定义一个可操作学生对象的工具类

思想:
1,通过获取键盘录入一行数据,并将该行中的信息取出封装成学生的对象。
2,因为学生有很多,那么就需要存储,使用到集合,因为要对学生的总分排序。 所以可以使用TreeSet
3,将集合信息写入到文件中。

package day21;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Collections;
import java.util.Comparator;
import java.util.Set;
import java.util.TreeSet;

public class StudentInfoTest {

    public static void main(String[] args) throws IOException{

        Comparator<Student> cmp = Collections.reverseOrder();

        Set<Student> stus = StudentInfoTool.getStudent(cmp);

        StudentInfoTool.write2File(stus);



    }

}

class Student implements Comparable<Student>{
    private String name;
    private int Math,Chinese,English;
    private int sum;
    public Student(String name, int Math, int Chinese, int English) {

        this.name = name;
        this.Math = Math;
        this.Chinese = Chinese;
        this.English = English;

        sum = Math+Chinese+English;

    }

    public int compareTo(Student s){
        int num = new Integer(this.sum).compareTo(new Integer(s.sum));
        if(num==0)
            return this.name.compareTo(s.name);
        return num;
    }

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getSum() {
        return sum;
    }
    public void setSum(int sum) {
        this.sum = sum;
    }

    public int hashCode(){
        return name.hashCode()+sum*78;
    }

    public boolean equals(Object obj){
        if(!(obj instanceof Student))
            throw new ClassCastException("输入不是学生");

            Student s = (Student)obj;

            return this.name.equals(s.name)  && this.sum == s.sum;
    }

    public String toString(){
        return "Student["+name+","+Math+","+Chinese+","+English+"]";
    }
}

class StudentInfoTool{

    public static Set<Student> getStudent()throws IOException{
        return getStudent(null);
    }
    public static Set<Student> getStudent(Comparator<Student> cmp)throws IOException{
        BufferedReader bufr  = new BufferedReader(new InputStreamReader(System.in));

        String line = null;

        Set<Student> stus = null;
        if(cmp==null)
            stus = new TreeSet<Student>();
        else
            stus = new TreeSet<Student>(cmp);

        while((line=bufr.readLine())!=null){
            if("over".equals(line))
                break;
            String[] info = line.split(",");

            Student stu = new Student(info[0],Integer.parseInt(info[1]),Integer.parseInt(info[2]),Integer.parseInt(info[3]));

            stus.add(stu);
        }

        bufr.close();

        return stus;
    }

    public static void write2File(Set<Student> stus) throws IOException{
        BufferedWriter bufw = new BufferedWriter(new FileWriter("StudentInfo.txt"));

        for(Student stu:stus){
            bufw.write(stu.toString()+"\t");
            bufw.write(stu.getSum()+"");
            bufw.newLine();
            bufw.flush();
        }

        bufw.close();
    }
}

这里写图片描述

图神经网络实战——总结 | 图神经网络展望 短短数年时间,图神经网络 (Graph Neural Networks, GNN) 已经成为一种重要的深度学习架构,并且已经广泛应用于各个行业。通过本专栏的学习,能够对图学习和 GNN 领域有一个全面的了解,并能为各种应用设计、构建GNN模型。 阅读详情

相关推荐

CTF-Web习题:2019强网杯 UPLOAD

本题涉及知识点:代码审计、文件上传漏洞、反序列化漏洞

LJW123487的博客 1903

Java- 序列化 ObjectOutputStream源码解析

Java-ObjectOutputStream 序列化 源码解析ObjectOutputStreamBlockDataOutputStreamDataOutputStreamHandleTableReplaceTableObjectStreamClass计算字段偏移量一个普通类obj(只实现Serializable接口)的序列化过程 注意序列化的实现有2中方式,一个是实现Serializable接...

u010374412的博客 505

树莓派使用 OLED 屏显示图片及文字

树莓派默认是不带显示屏的,如果想要查看系统的一些信息,需要使用电脑登录到树莓派,或者通过 HDMI 连接外接显示器查看。这样做总是有点麻烦,我们可以通过外接一个 OLED 屏来显示一些关键参数或者图片。本文将详细介绍操作方法。 OLED 模组介绍 OLED 屏主要有两种:128×32 和 128×64 ,主要颜色是白、黄、蓝。OLED 屏的特点是功耗低,价格便宜,使用 I2C 接口与主机连接。本文所使用的是 128×64 尺寸的屏幕,外形如下: [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直

码到成功 3744

day20学习总结

day20学习总结:总点IO流知识点

qq_53884348的博客 246

YooAsset 2.2.12四层加密架构:跨平台资源安全实战指南

AssetBundle加密是Unity热更新安全的核心环节,其本质是通过算法、密钥管理与生命周期协同实现资源全链路防护。传统方案常陷于‘打包后加密’的误区,导致内存开销大、跨平台兼容差、逆向防护弱。YooAsset 2.2.12提出打包层、传输层、加载层、运行层四层防护架构,将加密前置到资源序列化前,并依托BundleHeader实现动态算法协商与密钥分发,显著提升iOS/Android/WebGL三端一致性。该方案兼顾AES-128等通用算法与SM4等国密支持,同时通过IMemoryDecryptor实现

weixin_32428571的博客 416

LIO-SAM编译ubuntu20.04 Noetic

一、下载二、编译&&解决报错报错如下。

Kenneth666888的博客 690

java中的pipe_java中PipedStream管道流通信详细使用(详解)

多线程使用PipedStream 通讯Java 提供了四个相关的管道流,我们可以使用其在多线程进行数据传递,其分别是类名作用备注PipedInputStream字节管道输入流字节流PipedOutputStream字节管道输出流字节流PipedReader字符管道读取字符流PipedWriter字符管道写入字符流其分为两类:字节流和字符流,基本步骤为:线程A写入数据到输出流/写入,线程B读取数据从...

weixin_42514654的博客 664

别急着做AI:FDE教你识别真需求,让AI真正落地

人工智能项目在落地过程中,经常出现业务方高喊“我们要做AI”,却说不清具体应用场景的现象。判断一个需求是否值得用AI实现,不能只看技术流行度,而要从问题出现频率、当前替代方案以及可量化业务价值三个维度展开验证。同时需要冷静比较规则引擎与大模型的边界:不是所有语义任务都要靠生成式模型,稳定、可解释且低成本的传统方案往往更具工程性价比。数据闭环也至关重要,缺乏历史样本与反馈回流路径的项目,很难在真实环境中持续优化。针对智能客服、合同审查或企业知识库等典型场景,可借助人机协同与最小代价的用户验证,逐步筛除伪需求,

weixin_42624889的博客 343

ObjectStream对象流&Properties类常用方法&Thread线程的创建方式和线程常用api

对象流 序列化: Serialiaze 将java对象转换为二进制流ObjectOutputStream .writeObject(java对象) 反序列化: 二进制流还原java对象ObjectInputStream .readObject() --> java对象 java中要支持序列化和反序列化,需要实现接口Serializable(标记接口) seriaVersionUID序列化版本(序列号) 当对class类做修改时,seriaVersionUID就会变动,反序列化时就会报异常,可以把

Menfolk_k的博客 393

宇树机器人G1二次开发:导览、起始点、目的地与完整示例

通过宇树G1 SDK的导航接口,开发者可以高效地实现机器人的自主移动功能。连接 -> 设置目标点 -> 发送命令 -> 监控状态。本文提供的完整示例涵盖了从环境搭建到代码实现的全部步骤,并解释了起始点、目的地等关键概念。开发者可以在此基础上,结合多目标点巡逻、动态避障(需高级配置)等功能,构建更复杂的机器人应用。建议读者先在小范围、熟悉的平坦环境中测试,成功后再逐步扩展到更复杂的场景。

m0_52645558的博客 751

Prometheus+Grafana+alertmanager+PrometheusAlert监控告警 实现飞书告警

以上 是以grafana做的邮件告警,但是感觉邮件很少人看。下面是以webhook 可以接入。启动alertmanager (设置 开机在启动)下载prometheusalter 配置文件。这里的告警是基于grafana上搭建的。我们启动PrometheusAlert。写完之后进行重启Prometheus。prometheus 的告警规则。测试 基于我们生产环境做的文档。然后在grafana上导模板。上导入模板就可以 直接引用。访问 grafana页面。重启一下grafana。

墨痕诉清风的博客 859

Java使用PipedStream管道流通信

多线程使用PipedStream 通讯 Java 提供了四个相关的管道流,我们可以使用其在多线程进行数据传递,其分别是 类名 作用 备注 PipedInputStream 字节管道输入流 字节流 PipedOutputStream 字节管道输出流 字节流 PipedReader 字符管道读取 字符流 PipedWriter 字符管道写入 字符流 其分为两类:字节流和...

weixin_34033624的博客 349

ATT MTU 交换机制:提升 BLE 数据传输效率的关键

在低功耗蓝牙(BLE)技术的面试中,ATT MTU 交换机制始终是高频考点。无论是芯片厂商的固件开发岗,还是物联网设备的协议栈调试岗,面试官都爱通过这个知识点考察候选人对 BLE 数据传输底层逻辑的理解。本文将系统梳理核心考点,结合历年真题详解应答思路,轻松应对这类问题。​

byte轻骑兵的技术小窝 2412

IO流(三)之IO包其他功能流及字符编码详解

-------android培训、java培训、期待与您交流! ---------- 打印流(PrintStream和PrintWriter) 该流提供了打印方法,可以将各种数据类型的数据都原样打印 字节打印流:PrintStream 构造函数可以接受的参数类型 a) File对象 File b) 字符串路径。String c) 字节输出流。Outpu

lsh609912726的专栏 614

SAP B1中文培訓教材_SDK

公司内部培训资料,对开发工具 ,DIAPI, UIAPI,Add-ON有详细解说

复分析 阿尔福斯(Ahlfors) 第三版答案 英文

答案分为十章,有部分习题没有答案,全英文复分析阿尔福斯(Ahlfors) 第三版答案

Java基础_10_IO流总结

_____IO(Input Output)流_____ 概述 IO流就是用来处理设备之间的数据传输的,而Java对数据的的操作时通过流的方式,其操作流的类都在IO包中。 流分类 按照操作的数据分为:字节流和字符流 按流向分为:输入流,输出流 IO流常用基类

SheyChen的专栏 694

Probability and Statistics - 4th edition

Probability and Statistics - 4th edition

Java ObjectInputStream readByte()方法与示例

ObjectInputStream类readByte()方法 (ObjectInputStream Class readByte() method) readByte() method is available in java.io package. readByte()方法在java.io包中可用。 readByte() method is used to read a byte (i.e...

cumt951045的博客 924

ssm框架搭建

这个是一个在idea上成功跑起来的ssm框架项目,保存在这里方便以后使用直接下载

java readobject_java objectinputstream中的readObject如何知道要读取多少字节?

readOject()方法正在使用BlockedInputStream读取字节。如果检查ObjectInputStream的readObject,它正在调用readObject0(false).private Object readObject0(boolean unshared) throws IOException {boolean oldMode = bin.getBlockDataMode...

weixin_39963174的博客 259

ObjectInputStream 和 ObjectOutStream流

1. 简介 对象流:ObjectInputStream 和 ObjectOutStream,DataInputStream/DataOutputStream流只是解决了Java8种基础数据类型的流,而对象流不仅仅有读写Java的8种基础数据类型还可以将一个实例化的对象写入磁盘。 序列化:将一个实例化对象写入磁盘叫做序列化。 反序列化:将一个写入磁盘的的实例化读取出来转化为一个对象叫做反序列化。 需要序列化的对象类一定要实现Serializable接口。 2. 序列化(ObjectOutpu

weixin_43808717的博客 3110

关于ObjectOutputStream对象输出流与ObjectInputStream对象输入流:写入以及读出没有错误,但是写入的文件出现乱码的问题,该现象与UTF-8,GBK等字符集编码格式无关

对象流写入文件本身就是乱码的,对象流中有一个机制是魔数机制,魔数机制,可以把写进去的字符加密,但是idea会识别到编码错误,其实是正确的加密而已。对象流写入文件本身就是乱码的,对象流中有一个机制是魔数机制,魔数机制,可以把写进去的字符加密,但是idea会识别到编码错误,其实是正确的加密而已。2:发现写入与读出的结果一致,但是打开写入的.txt文本发现文本出现乱码,并且idea编译器会报错提示字符编码集错误。(3)打开ObjectOutputStream流写入的文本发现乱码。(2)控制台输出与代码写入一致。

zhzjn的博客 1090

Java ObjectInputStream\ObjectOutputStream序列化与反序列化数据

Java ObjectInputStream\ObjectOutputStream序列化与反序列化数据。 韩顺平JAVA课程学习笔记。

m0_59586434的博客 503

Java进阶—缓冲流、转换流、序列化流、打印流

一、缓冲流 缓冲流也叫高效流,是对四个基本的FileXxx流的增强,所以也是4个流,按照数据类型分为: 字节缓冲流:BufferedInputStream,BufferedOutputStream 字符缓冲流:BufferedReader,BufferedWriter 缓冲流的基本原理: 在创建流对象是,【会创建一个内置的默认大小的缓冲区数组】,通过缓冲区读写,减少系统IO次数,从而提高读写的效率。 1.1、字节缓冲输出流 java.io.BufferedOutputStream extends Out

weixin_42214237的博客 562

IO流区分总结

如何区分输入与输出?这些“输入”“输出”是相对于内存而言的。文件都存放在磁盘上,编译器运行在内存里。即:从文件里读的意思是把数据从磁盘读到内存里,是往内存里输入数据,所以是Input;同样地,往文件里面写数据是把内存中的数据写道磁盘上,是从内存往外输出,所以是Output。字符流和字节流之间的转换转换流只能对流的类型转换,不能对流向转换。

2301_79561226的博客 1253

java基础之IO流中的PipedStream管道流和RandomAcessFile

package com.j2se.io; import java.io.IOException; import java.io.PipedInputStream; import java.io.PipedOutputStream; /** * 学习管道流 * @author Administrator * */ public class PipedStreamDemo { /**

陈楚东的专栏-学编程切记心浮气躁,贵在坚持 852

128-对象的序列化流ObjectOutputStream * 对象的反序列化流ObjectInputStream

1.对象的序列化流ObjectOutputStream

shwjakak的博客 245

java 管道(pipedStream)详解

地址链接:http://www.cnblogs.com/skywang12345/p/io_04.html 上述博客已经写的很详细,管道流的作用:不同线程之间的通信。out.connect(out)等价于in.connect(in)。且缓冲区的默认大小为1024字节。...

weixin_40109343的博客 753

管道流 PipedStream简单例子

package com.lxb.test;import java.io.IOException;import java.io.PipedInputStream;import java.io.PipedOutputStream;public class PipedStream { public static void main(String[] args) throws IOException { ...

qq_32682035的博客 649
上一篇: java IO流 File类,Properties--20
下一篇: java GUI--day22
飞鸿踏雪泥-
博客等级 码龄12年 4粉丝 48原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值