io流和序列化

1.使用File操作文件
public class IoTest {

    public static void main(String[] args) throws IOException {
    /*     01.删除或者创建文件
     * File file=new File("e:/io.txt");
       addOrDel(file);   */

        File file=new File("e:/java/hello");
        //file.mkdir();   只能创建一层目录
        file.mkdirs();   //同时创建多层目录
    }

    /**
     * 删除或者创建文件
     */
    public static void addOrDel(File file) throws IOException {
        if (!file.exists()) { //判断文件是否存在
             if (file.createNewFile()) {//创建成功
                System.out.println("创建成功!");
                System.out.println("是否是文件:"+file.isFile());
                System.out.println("文件名称:"+file.getName());
                System.out.println("文件大小:"+file.length());
                System.out.println("文件的绝对路径:"+file.getAbsolutePath());
            }else {
                System.out.println("创建失败");
            }
        }else {
            System.out.println("文件已经存在!");
            if (file.delete()) {//删除文件
                System.out.println("删除成功!");
            }
        }
    }

}

2.使用FileInputStream读取文件内容(字节流)

public class FileInputStreamTest01 {
    public static void main(String[] args) throws Exception {
        /*
         * 创建输入流对象  从电脑中的源文件 获取 数据到 内存中
         * 如果没有指定的文件  会报错    FileNotFoundExecption
         */
        FileInputStream stream=new FileInputStream("e:/hello.txt");
        //输出字节数
        System.out.println("可读取的字节数:"+stream.available());
        /*
         * 读取内容
         * 循环读取数据,会从输入流中读取一个8位的字节!把它转换成了0-255之间的整数返回了!
         * 我们要想拿到具体的值!必须把整数转成字符  char (0-65535)
         * read()当读取文件的结尾处  返回-1
         * UTF-8 :中的  中文字符以及中文 占据 3个 字节, 数字和字母占1个字节
         * GBK,gb2312: 编码中  中文和符号都占2个字节!
         */
        int num;
        while((num=stream.read())!=-1){
            System.out.print(num);
        }
        //关闭输入流
        stream.close();
    }

}

3.使用FileOutputStream写入文件内容(字节流)

public class FileOutputStreamTest02 {
    public static void main(String[] args) throws Exception {
        /*
         * 01.java项目的编码格式 要和输出文件的编码一致 都是UTF-8
         * 02.如果系统中没有指定的文件,会默认创建
         * 03.如果重复输出,则上次的内容会被覆盖
         *   如果不想覆盖!使用重载!在第二个参数的位置输入true
         */
        FileOutputStream stream=new FileOutputStream("e:/hello.txt",true);
        String  str="真的好棒!";
        //参数传递需要一个Byte类型的数组
        stream.write(str.getBytes());
        //关闭输出流
        stream.close();
    }
}

4.使用FileReader读取文件内容(字符流)

public class FileReaderTest03 {
    public static void main(String[] args) throws Exception {
        //获取当前的编码格式
        System.out.println("使用的编码为:"+System.getProperty("file.encoding"));
        //创建输入流 Reader
        Reader reader=new FileReader("e:/hello.txt");
        //因为读取的字符  创建数据的中转站  会有多余的空格产生
        char [] words=new char[1024];
        int  num;
        //需要字符串的 拼接
        StringBuilder sb=new StringBuilder();
        while((num=reader.read(words))!=-1){
            sb.append(words);
        }
        System.out.println(sb.toString());
        //关闭输入流
        reader.close();
    }
}

5.使用BufferedReader读取文件内容(字符流)

public class BufferedReaderTest04 {
    public static void main(String[] args) {
        /*
         * 创建输入流 Reader
         * BufferedReader和FileReader联合使用
         * 效率高   底层有默认的缓冲区 还可以逐行读取
         */

        //创建BufferedReader对象  传递Reader的对象
        BufferedReader br=null;
        Reader reader=null;
        try {
            reader = new FileReader("e:/hello.txt");
            br=new BufferedReader(reader);
            //一行一行的读取
            String  line=null;
            while((line=br.readLine())!=null){
                System.out.println(line);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            //关闭流   先开的后关
            try {
                br.close();
                reader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}
6.使用FileWriter读取文件内容(字符流)
public class FileWriterTest05 {
    public static void main(String[] args) {
        try {
            /*
             * 输出流  默认的会给我们创建新的文件
             * 不使用第二个参数!  那么默认会覆盖之前的内容
             * ctrl +shift +t   选中需要查询的类或者接口
             */
            Writer writer=new FileWriter("e:/hello.txt",true);
            writer.write("我爱北京天安门!");
            writer.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

7.使用BufferedWriter写入文件(字符流)

public class BufferedWriterTest06 {
    public static void main(String[] args) {
        try {
            //创建输出流对象
            Writer writer=new FileWriter("e:/hello.txt",true);
            //创建BufferedWriter对象
            BufferedWriter bw=new BufferedWriter(writer);
            //换行
            bw.newLine();
            bw.write("北京也爱你!");
            bw.newLine();
            bw.write("北京也爱你!");
            bw.close();
            writer.close();

            //获取输入流
            Reader reader=new  FileReader("e:/hello.txt");
            BufferedReader br=new BufferedReader(reader);
            String  line=null;
            while((line=br.readLine())!=null){
                System.out.println(line);
            }
            br.close();
            reader.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

8.使用InputStreamReader解决中文乱码问题

public class InputStreamReaderTest07 {
    public static void main(String[] args) {

        BufferedReader br=null;
        InputStreamReader isr=null;
        InputStream stream=null;
        try {
            //创建输入流对象
            stream=new FileInputStream("e:/hello.txt");
            System.out.println("文件的大小:"+stream.available());
            //使用InputStreamReader来解决乱码
            isr=new InputStreamReader(stream, "utf-8");
            //读取
             br=new BufferedReader(isr);
            String  line=null;
            while((line=br.readLine())!=null){
                System.out.println(line);
            }

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            try {
                br.close();
                isr.close();
                stream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}




9.读取2进制文件

public class DataInputStreamTest08 {
    public static void main(String[] args) throws Exception {
        //创建输入流
       InputStream fis=new FileInputStream("e:/mm.mp3");
        //读取2进制文件
       DataInputStream dis=new DataInputStream(fis);

       //复制文件到另一个目录
       OutputStream fos=new FileOutputStream("e:/U1/慢慢.mp3");
       //以2进制的方式输出到指定的目录
       DataOutputStream dos=new DataOutputStream(fos);

       //开始读取
       int  data;
       while((data=dis.read())!=-1){
           //写入
           dos.write(data);
       }
       dos.close();
       fos.close();
       dis.close();
       fis.close();
    }

10.序列化和反序列化

/**
 * 序列化:将内存中对象的状态或者信息  转换成 持久化的过程!
 * 反序列化:把持久化的对象 变成 内存中的一个对象的过程!
 *    目的:
 *      01.使自定义的对象  持久化!对象本身是在内存中的!我们想把它持久化!
 *      02.把对象从一个地方传递到另一个地方!
 *      03.使程序具有维护性!
 *
 *  怎么才能实现对象的序列化??
 *  1.让对象所属的类  实现Serializable 接口   之后, 这个类 就可以序列化了!
 *   Serializable:只是一个能否被序列化的标记!
 */
public class Student implements Serializable{  //实体类

    private  Integer  id;
    private  Integer  age;
    private  String  name;

    @Override
    public String toString() {
        return "Student [id=" + id + ", age=" + age + ", name=" + name + "]";
    }
    public Student() {
        super();
    }
    public Student(Integer id, Integer age, String name) {
        super();
        this.id = id;
        this.age = age;
        this.name = name;
    }
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public Integer getAge() {
        return age;
    }
    public void setAge(Integer age) {
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }

}

用于序列化的Student类

public class SerializableTest {
    public static void main(String[] args) throws Exception { //序列化操作
        //首先实例化一个对象
        Student student=new Student(1, 500, "小白2");
        //想序列化?从内存中  放入 持久化的介质中  输出流
        FileOutputStream  fos=new FileOutputStream("e:/student.txt");
        ObjectOutputStream oos=new ObjectOutputStream(fos);
        //开始持久化
        oos.writeObject(student);
        oos.close();
        fos.close();
    }
}

序列化

/**
 * 反序列化
 * 需要和 序列化时候的包名  一致   不然 没法反序列化
 */
public class StudentTest {
    public static void main(String[] args) throws Exception {
        // 从文件中把对象 拿到 内存中 输入流
        FileInputStream fis = new FileInputStream("e:/student.txt");
        ObjectInputStream ois = new ObjectInputStream(fis);
        // 读取文件中的对象
        Student student = (Student) ois.readObject();
        System.out.println(student.getId());
        System.out.println(student.getAge());
        System.out.println(student.getName());
        ois.close();
        fis.close();
    }
}
时间: 2024-09-30 10:46:41

io流和序列化的相关文章

java 21 - 13 IO流之序列化和反序列化

序列化流:把对象按照流一样的方式存入文本文件或者在网络中传输.对象 -- 流数据(ObjectOutputStream) 构造方法:ObjectInputStream(InputStream in)  创建从指定 InputStream 读取的 ObjectInputStream 反序列化流:把文本文件中的流对象数据或者网络中的流对象数据还原成对象.流数据 -- 对象(ObjectInputStream) 构造方法:ObjectInputStream(InputStream in)  创建从指定

java ->IO流_序列化流与反序列化流

序列化流与反序列化流 用于从流中读取对象的操作流 ObjectInputStream    称为 反序列化流 用于向流中写入对象的操作流 ObjectOutputStream   称为 序列化流(对象保存到文件中) l  特点:用于操作对象.可以将对象写入到文件中,也可以从文件中读取对象. 对象序列化流ObjectOutputStream ObjectOutputStream 将 Java 对象的基本数据类型和图形写入 OutputStream.可以使用 ObjectInputStream 读取

java io流与序列化反序列化

java的io是实现输入和输出的基础,可以方便的实现数据的输入和输出操作. 序列化 (Serialization)是将对象的状态信息转换为可以存储或传输的形式的过程.在序列化期间,对象将其当前状态写入到临时或持久性存储区.以后,可以通过从存储区中读取或反序列化对象的状态,重新创建该对象. 下面是一个实例,通过例子来将以上来简化学习: 1.先创建一个学生类来实现serialization: 1 package com.etc; 2 3 import java.io.Serializable; 4

阶段1 语言基础+高级_1-3-Java语言高级_06-File类与IO流_09 序列化流_3_对象的反序列化流_ObjectInputStream

声明了IO异常,这里还是红色的 转换为Person对象 原文地址:https://www.cnblogs.com/wangjunwei/p/11273536.html

阶段1 语言基础+高级_1-3-Java语言高级_06-File类与IO流_09 序列化流_2_对象的序列化流_ObjectOutputStream

创建person对象.生成构造方法全参和无参.getter和setter 抛出异常:没有序列化异常 接口的源码 啥都没有.就起到一个标记的作用 用二进制存的 原文地址:https://www.cnblogs.com/wangjunwei/p/11273498.html

阶段1 语言基础+高级_1-3-Java语言高级_06-File类与IO流_09 序列化流_4_transient关键字_瞬态关键字

不想被序列化的成员变量用 transient修饰 age加上static关键字 反序列化age就读取不到正确的值了 原文地址:https://www.cnblogs.com/wangjunwei/p/11273552.html

阶段1 语言基础+高级_1-3-Java语言高级_06-File类与IO流_09 序列化流_1_序列化和反序列化的概述

原文地址:https://www.cnblogs.com/wangjunwei/p/11273482.html

Java API —— IO流(数据操作流 & 内存操作流 & 打印流 & 标准输入输出流 & 随机访问流 & 合并流 & 序列化流 & Properties & NIO)

1.操作基本数据类型的流 1) 操作基本数据类型 · DataInputStream:数据输入流允许应用程序以与机器无关方式从底层输入流中读取基本 Java 数据类型.应用程序可以使用数据输出流写入稍后由数据输入流读取的数据. · DataOutputStream:数据输出流允许应用程序以适当方式将基本 Java 数据类型写入输出流中.然后,应用程序可以使用数据输入流将数据读入. package datastreamdemos; import java.io.*; /** * Created b

Java基础知识强化之IO流笔记65:序列化流 和 反序列化流

1. 什么是 序列化 和 反序列化 ?     序列化 (Serialization):将对象的状态信息转换为可以存储或传输的形式的过程.在序列化期间,对象将其当前状态写入到临时或持久性存储区.以后,可以通过从存储区中读取或反序列化对象的状态,重新创建该对象.一般的格式是与平台无关的二进制流,可以将这种二进制流持久保存在磁盘上,也可以通过网络将这种二进制流传输到另一个网络结点.  反序列化(Anti Serialization ):是指把这种二进制流数据还原成对象. 2. 序列化流 和 反序列化