文件读写

作者: luoqiang108 | 来源:发表于2018-07-06 13:40 被阅读0次

计算机的硬盘在保存数据时都是byte by byte的字节挨着字节。

RandomAccessFile

作用：可以方便的读写文件内容。
打开文件模式：
rw：打开文件后可进行读写操作
r：打开文件后只读
write(int data):写一个字节，写这个int值的低八位
write(byte[] data):将一组字节写入
read():读一个字节，若已经读取到文件末尾，返回-1
int read(byte[] buf):尝试读取buf.length个字节。并将读取的字节存入buf数组。返回值：实际读取的字节数。
RandomAccessFile是基于指针进行读写操作的，指针在哪里就从哪里读/写
writeInt(111):将int值111转换为字节并写入磁盘
基本类型序列化：将基本类型数据转换为字节数组（序列）的过程
持久化：将数据写入磁盘的过程

import java.io.File;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.util.Arrays;
/**
 * RandomAccessFile读写文件。
 */
public class RandomAccessFileTest {
    public static void main(String[] args) {
        try {
            /**
             * 向文件.\data.dat中写数据
             * 步骤：
             * 1、创建一个File对象用于描述该文件
             * 2、不存在则创建该文件
             * 3、创建RandomAccessFile，并将File传入。
             * 使RandomAccessFile对File表示的文件进行
             * 读写操作
             * 4、向文件中写入内容
             */
            //1
            File file = new File("data.dat");
            //2、不存在则创建该文件
            if (!file.exists()) {
                file.createNewFile();
            }
            //3、对file文件可以进行读写操作
            RandomAccessFile raf =new RandomAccessFile(file,"rw");
            //4、写一个int最大值
            /**
             * 2位16进制代表一个字节（8位2进制）
             * 1位16进制代表4位2进制 f==1111
             * 4字节代表32位2进制
             *
             * write(int)写一个字节
             *    7f       ff       ff       ff
             * 01111111 11111111 11111111 11111111
             *
             * 00000000 00000000 00000000 01111111 00 00 00 7f
             * 00000000 00000000 01111111 11111111 00 00 7f ff
             * 00000000 01111111 11111111 11111111 00 7f ff ff
             * 01111111 11111111 11111111 11111111 7f ff ff ff
             */
            int i = 0x7fffffff;//int最大值
            //写int值最高的8位
            raf.write(i>>>24);//00 00 00 7f
            raf.write(i>>>16);//00 00 7f ff
            raf.write(i>>>8);//00 7f ff ff
            raf.write(i);    //7f ff ff ff
            //定义一个10字节数组
            byte[] data = new byte[]{0,1,2,3,4,5,6,7,8,9};
            //将这10个字节全部写入文件
            raf.write(data);
            //写到这里，当前文件应该有14（前面int的4字节加后面数字的10字节）个字节了
            /**
             * 写字节数组的重载方法
             *write(byte[] data,int offset,int length)
             * 从data数组的offset位置开始写，连续写length个字节到文件中。
             */
            raf.write(data,2,5);//{2,3,4,5,6}
            System.out.println("当前指针位置："+raf.getFilePointer());//19
            raf.seek(0);//将指针移动到文件开始的位置
            System.out.println("当前指针位置："+raf.getFilePointer());//0
            /**
             * num:00000000 00000000 00000000 00000000
             */
            int num = 0;//准备读取的int值
            int b = raf.read();//读取第一个字节 7f
            System.out.println("当前指针位置："+raf.getFilePointer());//1
            num = num|(b<<24);//01111111 00000000 00000000 00000000
            b = raf.read();//读取第二个字节 ff
            num = num|(b<<16);//01111111 11111111 00000000 00000000
            b = raf.read();//读取第三个字节 ff
            num = num|(b<<8);//01111111 11111111 11111111 00000000
            b = raf.read();//读取第四个字节 ff
            num = num|b;//01111111 11111111 11111111 11111111
            System.out.println("int最大值"+num);//int最大值2147483647
            raf.seek(0);
            byte[] buf = new byte[1024];//1k的容量
            int sum = raf.read(buf);//尝试读取1k的数据
            System.out.println("总共读取了"+sum+"个字节");
            System.out.println(Arrays.toString(buf));
            /*RandomAccessFile的其他读写*/
            raf.seek(0);
            //写int最大值
            raf.writeInt(Integer.MAX_VALUE);//一次写4个字节，写int值
            //写long最大值
            raf.writeLong(Long.MAX_VALUE);
            //写字符串
            raf.writeUTF("hello!");
            raf.seek(0);
            int intMax = raf.readInt();//连续读取4字节返回该int值
            long longMax = raf.readLong();
            String string = raf.readUTF();
            raf.close();//写完了不再写了就关了
        }catch(IOException e){
            e.printStackTrace();
        }
    }
}

java I/O 输入/输出

流：根据方向流分为输入流和输出流，方向的定论是基于我们的程序。流向我们的程序的流叫做输入流，从程序向外流的叫做输出流。我们可以把流想象为管道。管道里流动的是水，而java中的流，流动的是字节。输入流是用于获取数据的。输出流是用于向外输出数据的。输入流是用于读取的，输出流是用于写出的。
java中
InputStream：该接口定义了输入流的特性，
OutputStream：该接口定义了输出流的特征。
流根据源头分为：
基本流（低级流，节点流）：有来源。
处理流（高级流，过滤流）：没有数据来源。不能独立存在。它的存在是用于处理基本流的。
流根据处理的数据单位不同划分为：字节流（Stream结尾）和字符流（Reader/Writer结尾）
用于读写文件的字节流FIS/FOS
FileInputStream：文件输入流
FileOutputStream：文件输出流
FileOutputStream用于向文件写入数据。构造其实例可以使用FileOutputStream(File file)：向file文件写入数据。若该文件不存在会自动创建该文件。
BufferedInputStream：缓冲字节输入流
BufferedOutputStream：缓冲字节输出流
缓冲字节流内部维护着一个缓冲区（字节数组）。可以提高读写效率。缓冲字节流是处理流（高级流，过滤流）。
辨别高级流的简单方法：
看构造方法，若构造方法要求传入另一个流，那么这个流就是高级流。
DataInputStream：可以直接读取基本类型数据的流。
简化了对基本类型数据的读写操作。
DIS：
int readInt()：连续读取4个字节，返回该int值；
double readDouble():连续读取8个字节，返回double值；
String readUTF():读取字符串，返回String值；
DataOutputStream：可以直接写基本数据的流。
DIS：
int writeInt(int i);
double writeLong(long l);
String writeUTF(String s);

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Arrays;

public class FISFOSTest {
    public static void main(String[] args) throws IOException {
        File file = new File("data.dat");
        /**
         * 根据文件创建用于读取其数据的文件输入流
         */
        FileInputStream fis = new FileInputStream(file);
        int b = -1;
        while ((b=fis.read())!=-1){
            //输出这个字节的16进制形式
            System.out.print(Integer.toHexString(b));
        }
        fis.close();//切记，流用完了要关闭！
        /*
        * 文件输入流FileOutputStream
        * write(int d):写int值的低八位
        * write(byte[] d):将d数组中所以字节写出
        * write(byte[] d,int offset,int length):将d数组中offset位置开始
        * 写length个字节
        * */
        File outFile =new File("out.txt");
        if (!outFile.exists()){
            file.createNewFile();
        }
        //FileOutputStream fos = new FileOutputStream(outFile);
        /*
        * FileOutputStream(File file,boolean append)
        * append为true：会在当前文件末尾进行写操作
        * FileOutputStream(String filePath,boolean append)
        * 传文件路径进行写入
        * */
        FileOutputStream fos = new FileOutputStream(outFile,true);
        String info = "你好！输出流！";
        byte[] outData = info.getBytes("UTF-8");
        fos.write(outData);//将字符串转换的字节写出
        fos.close();



        //测试IO工具类方法
        byte[] data =IOUtils.loadBytes(new File("data.dat"));
        System.out.print("\n"+Arrays.toString(data));
        File des = new File("abc.dat");//该文件在磁盘上不存在
        IOUtils.saveBytes(des,data);
        File srcCopy = new File("Eclipse.zip");
        File desCopy = new File("EclipseCopy.zip");
        //IOUtils.copyFile(srcCopy,desCopy);
        //IOUtils.copyFile2(srcCopy,desCopy);
        //测试DataOutputStream
        FileOutputStream out = new FileOutputStream("o.txt");
        IOUtils.saveString("大家好才是真的好！",out);
        out.close();
        FileInputStream in = new FileInputStream("o.txt");
        System.out.println("\n"+IOUtils.loadString(in));
    }
}

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

/**
 * IO工具类
 */

public class IOUtils {
    /**
     * 读取给定的文件，并将数据以字节数组的形式返回
     * @param src
     * @return
     */
    public static byte[] loadBytes(File src) throws IOException{
        if (src==null){
            throw new IllegalArgumentException("文件为空!");
        }
        if (!src.exists()){
            throw new IllegalArgumentException(src+"不存在!");
        }
        FileInputStream fis = null;//创建文件输入流
        try{
            fis = new FileInputStream(src);
            /*FileInputStream的available()方法：
            * 返回当前字节输入流可读取的总字节数
            * */
            byte[] data = new byte[fis.available()];
            fis.read(data);
            return data;
        }catch (IOException e){
            throw e;//读取出现错误将异常抛给调用者解决
        }finally {
            if (fis!=null){
                fis.close();
            }
        }
    }

    /**
     * 数据源 DataSource
     * 将给定数组写入给定文件中
     * @param src
     * @param data
     * @throws IOException
     */
    public static void saveBytes(File src ,byte[] data) throws IOException{
        if (src==null){
            throw new IllegalArgumentException("文件为空!");
        }
        //FileOutputStream(File file),若file文件不存在FileOutputStream(File file)构造方法会自动创建该文件
        /*if (!src.exists()){
            src.createNewFile();
        }*/
        FileOutputStream fos = null;
        try {
            fos = new FileOutputStream(src);
            fos.write(data);
        }catch (IOException e){
            throw e;
        }finally {
            if (fos!=null){
                fos.close();
            }
        }
    }

    /**
     * 将文件复制保存到des文件
     * @param src
     * @param des
     * @throws IOException
     */
    public static void copyFile(File src,File des) throws IOException{
        if (src==null){
            throw new IllegalArgumentException("源文件为空!");
        }
        if (!src.exists()){
            throw new IllegalArgumentException("源文件不存在!");
        }
        if (des==null){
            throw new IllegalArgumentException("目标文件为空!");
        }
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try {
            fis = new FileInputStream(src);
            fos = new FileOutputStream(des);
            int data = -1;
            while ((data=fis.read())!=-1){
                fos.write(data);
            }
            /*byte[] srcData = new byte[fis.available()];
            fis.read(srcData);
            fos.write(srcData);*/
        }catch (IOException e){
            throw e;
        }finally {
            if (fis!=null){
                fis.close();
            }
            if (fos!=null){
                fos.close();
            }
        }
    }

    /**
     * 使用缓冲流进行文件拷贝
     * @param src
     * @param des
     */
    public static void copyFile2(File src,File des) throws IOException{
        if (src==null){
            throw new IllegalArgumentException("源文件为空");
        }
        if (!src.exists()){
            throw new IllegalArgumentException("源文件不存在");
        }
        //创建缓冲流
        BufferedInputStream bis = null;
        BufferedOutputStream bos = null;
        try {
            bis = new BufferedInputStream(new FileInputStream(src));
            bos = new BufferedOutputStream(new FileOutputStream(des));
            int data = -1;
            while ((data=bis.read())!=-1){
                bos.write(data);
            }
            /*flush的作用是将缓冲区中未写出的数据一次性写出*/
            bos.flush();//数据都写完后应该flush
        }catch (IOException e){
            throw e;
        }finally {
            if (bis!=null){
                /*通常情况下，我们只需要关闭最外层的流，里层的流会自动关闭*/
                bis.close();
            }
            if (bos!=null){
                bos.close();
            }
        }
    }

    /**
     * 向给定的输出流中写字符串
     * @param info
     * @param out
     * @throws IOException
     */
    public static void saveString(String info, OutputStream out)throws IOException{
        /*
        * 步骤：
        * 1：创建DataOutputStream并处理参数out这个输出流
        * 2：通过DOS直接将一个字符串写出
        * 3：清空DOS的缓冲区，确保所有字符都写出。
        * */
        //1
        DataOutputStream dos = new DataOutputStream(out);
        //2
        dos.writeUTF(info);//将字符串写出
        //3
        dos.flush();//将缓冲区中的数据写出
        //这里应该将dos关掉么？
        /*不需要关，因为关闭会连带自动的把传递进来的out低级流关闭，
        而这个低级流传参处很可能还需要用，这里dos在方法里用完后，
        其它地方没有对它的应用，GC会自动把它回收*/
    }

    /**
     * 从输入流中读取字符串
     * @param in
     * @return
     * @throws IOException
     */
    public static String loadString(InputStream in)throws IOException{
        DataInputStream dis = new DataInputStream(in);
        String data = dis.readUTF();
        return data;
    }
}

字符流：

以字符为单位读写数据，一次处理一个字符（unicode）。字符流底层还是基于字节形式读写的。所有字符流都是高级流。

InputStreamReader：字符输入流
OutputStreamWriter：字符输出流
InputStreamReader与OutputStreamWriter是字符输入流和字符输出流，它们是高级流。作用是可以以字节为单位读写数据。
BufferedReader（缓冲字符输入流）和BufferedWriter（缓冲字符输出流），特点是以行为单位读写数据。
打印流，PrintStream（打印字节流），PrintWriter（打印字符流）

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintStream;
import java.io.PrintWriter;

/**
 * Created by 罗强 on 2018/7/9.
 */

public class CharacterStreamTest {
    public static void main(String[] args) throws IOException {
        /*字符输出流
        * Writer：字符输出流
        * OutputStreamWriter：高级流，可以以字符为单位写数据
        * */
        /*向文件中写入字符
        * 步骤
        * 1：创建文件输出流（字节流）
        * 2：创建字符输出流（高级流），处理文件输出流
        * 目的是我们可以以字节为单位写数据
        * 3：写入字符
        * 4写完后关闭流*/
        OutputStreamWriter writer = null;
        try {
            //1
            FileOutputStream fos =new FileOutputStream("writer.txt");
            //2
            //writer = new OutputStreamWriter(fos);//使用系统默认编码集输出字符串
            //使用UTF-8作为编码集输出字符串
            writer = new OutputStreamWriter(fos,"UTF-8");
            //3
            writer.write("你好！");
            writer.flush();//将缓冲区数据一次性写出
        }catch (IOException e){
            throw e;
        }finally {
            //4
            if (writer!=null){
                writer.close();
            }
        }
        /**
         * 字符输入流
         */
        InputStreamReader reader = null;
        try {
            //创建用于读取文件的字节输入流
            FileInputStream fis = new FileInputStream("writer.txt");
            //创建用于以字符为单位的读取数据的高级流
            reader = new InputStreamReader(fis);
            //读取数据
            int c = -1;
            while ((c=reader.read())!=-1){
                System.out.println((char)c);
            }
        }catch (IOException e){
            throw e;
        }finally {
            if (reader!=null){
                reader.close();
            }
        }

        /*缓冲字符输出流
        * 高级流
        * 可以以行为单位写字符
        * */
        //创建用于写文件的输出流
        FileOutputStream fos = new FileOutputStream("buffered.txt");
        //创建一个字符输出流
        OutputStreamWriter osw = new OutputStreamWriter(fos,"UTF-8");
        /*
        BufferedWriter的构造方法中不支持给定一个字节输出流
        只能给定一个字符输出流Writer的子类
        Writer：字符输出流的父类
         */
        BufferedWriter bw = new BufferedWriter(osw);
        bw.write("你好呀！");
        bw.newLine();//输出一个换行
        bw.write("我是第二行");
        bw.newLine();
        bw.write("我是第三行");
        //输出流关闭后，不能再通过其写数据
        bw.close();
        /*
        * 缓冲字符输入流
        * 读取src/day02/DemoBufferedReader.java
        * readLine()
        * */
        FileInputStream fis = new FileInputStream("src"+ File.separator+
                "day02"+File.separator+"DemoBufferedReader.java");
        InputStreamReader isr = new InputStreamReader(fis);
        BufferedReader br = new BufferedReader(isr);
        String str =null;
        /**
         * readLine()读取一行字符并以字符串形式返回
         * 返回值中不带换行符。
         * 若返回null，说明读取到了文件末尾
         * EOF:end of file 文件末尾
         */
        while ((str=br.readLine())!=null){
            System.out.println(str);
        }
        reader.close();

        //打印字节流
        System.out.println("你好！");
        PrintStream out = System.out;
        PrintStream fileOut =
                new PrintStream(new FileOutputStream("SystemOUT.TXT"));
        //将我们指定的输出流赋值到System.out上
        System.setOut(fileOut);
        System.out.println("你好！我是输出到控制台的！");
        System.setOut(out);
        System.out.println("我是输出到控制台的！");
        fileOut.close();
    }
}

FileReader与FileWriter用于读写文件的字符输入流和输出流。

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

/**
 * Created by 罗强 on 2018/7/11.
 */

public class FileWriterAndFileReaderTest {
    public static void main(String[] args) throws IOException{
        //文件字符输出流
        /*常用的两个构造方法
        * FileWriter(File file)
        * FileWriter(String filePath)
        * 意思和FileOutputStream的两个同类型参数的构造方法一致
        *
        * FileWriter的效果等同于
        * FileOuputStream + OutputStreamWriter
        * */
        FileWriter writer = new FileWriter("filewriter.txt");
        //File file = new File("filewriter.txt");
        //writer = new FileWriter(file);
        writer.write("hello!FileWriter!");
        writer.close();
        //文件字符输入流
        FileReader reader = new FileReader("filewriter.txt");
        int c = -1;
        //以字符为单位读取文件
        while ((c=reader.read())!=-1){
            System.out.print((char)c);
        }
        // 文件字符输入流转换为缓冲字符输入流便可以以行为单位读取
        BufferedReader br = new BufferedReader(reader);
        String info = null;
        while ((info=br.readLine())!=null){
            System.out.println(info);
        }
        reader.close();
    }
}

PrintWriter
另一种缓冲字符输出流。
Servlet：运行在服务器端的小程序。给客户端发送相应的输出流就是PrintWriter。
写方法：println(String data):带换行符输出一个字符串。
构造方式：PrintWriter(File file)：以行为单位向文件写数据。
PrintWriter(OutputStream out):以行为单位向字节输出流写数据。
PrintWriter(Writer writer):以行为单位向字符输出流写数据。
PrintWriter(String fileName):以行为单位向指定路径的文件写数据。

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;

public class PrintWriterTest {
    public static void main(String[] args) throws IOException{
        PrintWriter writer =new PrintWriter("printwriter.txt");
        //向文件写入一个字符串
        writer.println("你好！PrintWriter");//自动加换行符;
        /*
        * 我们要在确定做写操作的时候调用flush()方法
        * 否则数据可能会在输出流的缓冲区中，没有做真实的写操作！
        * */
        writer.flush();
        writer.close();
        /*使用缓冲字符输入流读取键盘输入信息*/
        /*
        * 将键盘的输入流转换为字符输入流在转换为缓冲字符输入流
        * */
        //1、将键盘的字节输入流转换为字符输入流
        InputStreamReader isr = new InputStreamReader(System.in);
        //2、将字符输入流转换为缓冲字符输入流。按行读取信息
        BufferedReader br = new BufferedReader(isr);
        //循环读取用户输入信息并输出到控制台
        while (true){
            String info = br.readLine();
            if ("exit".equals(info)){
                break;
            }
            /*
            * 若我们不是输出到控制台，而是通过对文件的输出流
            * 进行写操作，可以将控制台的信息写到文本文件中了。
            * */
            System.out.print(info);
        }
        br.close();
    }
}

断点续传

import java.io.Serializable;

/**
 * 保存一个下载任务所需要的信息
 * VO:Value Object 值对象
 * 作用：保存一组数据。
 * 若这组数据表示的是数据库中的一条数据的话
 * 那么这个对象就叫做：Entity实体
 */

public class DownloadInfo implements Serializable {
    private String url;//下载文件的地址
    private long pos;//已经下载的字节数
    private long fileSize;//文件总大小
    private String fileName;//保存在本地的文件名

    public DownloadInfo(String url, String fileName) {
        this.url = url;
        this.fileName = fileName;
    }

    public String getUrl() {
        return url;
    }
    public void setUrl(String url) {
        this.url = url;
    }

    public long getPos() {
        return pos;
    }
    public void setPos(long pos) {
        this.pos = pos;
    }

    public long getFileSize() {
        return fileSize;
    }
    public void setFileSize(long fileSize) {
        this.fileSize = fileSize;
    }

    public String getFileName() {
        return fileName;
    }
    public void setFileName(String fileName) {
        this.fileName = fileName;
    }
}

import java.io.InputStream;
import java.io.RandomAccessFile;
import java.net.HttpURLConnection;
import java.net.URL;

/**
 * 断点续传测试
 */

public class TestHttpDownload {
    public static void main(String[] args){
        /*
        * 1:创建下载任务DownLoadInfo实例
        * 2：根据任务中的下载地址打开网络连接，获取对应输入流
        * 3：创建任务中保存在本地的文件的输出流
        * 4：进行读写操作（下载）
        * 5：关闭流
        * */
        try {
            //1
            DownloadInfo info = new DownloadInfo("http://www.baidu.com/download/java_1_7.zip",
                    "java_1_7.zip");
            //2
            URL url = new URL(info.getUrl());//给定网络地址
            HttpURLConnection conn = (HttpURLConnection) url.openConnection();//通过地址打开网络连接
            //获取要下载的文件的大小
            info.setFileSize(Long.parseLong(conn.getHeaderField("CONTENT-LENGTH")));
            conn.disconnect(); //与服务器断开，准备下一次请求（一次请求，一次响应）
            //再次连接、请求
            conn = (HttpURLConnection) url.openConnection();
            /*要想实现续传。我们必须告诉服务器我们当次读取
            *文件的开始位置。相当于我们本地调用seek()
            *因为我们不可能直接调用服务器的对象的方法
            *所以我们只能通过某种方式告诉服务器我们要干什么。
            *让它自行调用自己流对象的seek()到我们想读取的位置。
            *
            * bytes=0-   的意思是告诉服务器从第一个字节开始读
            *            seek(0)
            * bytes=128- 的意思是告诉服务器从第129个字节开始读
            *            seek(128)
            * */
            String prop = "bytes="+info.getPos()+"-";
            //通过连接设置参数，通知服务器从什么地方开始读
            conn.setRequestProperty("RANGE",prop);
            //打开输入流开始读取文件
            InputStream in = conn.getInputStream();
            //将任务中记录的本地文件作为写出的目标文件
            RandomAccessFile raf = new RandomAccessFile(info.getFileName(),"rw");
            //服务器seek的位置就是我们写的位置
            raf.seek(info.getPos());
            //创建一个缓冲区
            byte[] buffer = new byte[1024*10];//10K缓冲区
            int sum = -1;//记录读取的字节数
            /*
            * 进行下载操作
            * 从输入流（来自网络的文件）读取数据
            * 通过输出流（下载的文件）写数据
            * */
            while ((sum=in.read(buffer))>0){
                raf.write(buffer,0,sum);
                //记录当前下载总字节数
                info.setPos(info.getFileSize()+sum);
            }
            raf.close();
            in.close();
            conn.disconnect();//关闭和服务器的连接
        }catch (Exception e){

        }
    }
}

对象序列化

将一个对象转换为字节形式的过程就叫做序列化。
对象的序列化使用的类ObjectOutputStream：
writeObject(Object obj):将给定对象序列化后写出
对象的反序列化使用的类ObjectInputStream：
Object readObject():将读取的字节序列还原为对象
集合类没有实现Serializable接口，不能用于序列化和反序列化
被transient关键字修饰的属性不会被序列化
序列化还有个叫法叫串行化。

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

/**
 * Created by 罗强 on 2018/7/12.
 */

public class SerializeObject {
    public static void main(String[] args){
        try {
            //DownloadInfo需实现Serializable接口，否则无法写入文件
            DownloadInfo info = new DownloadInfo(
                    "http://www.baidu.com/download.xxx.zip",
                    "xxx.zip");
            info.setPos(12587);
            info.setFileSize(5566987);
            //将info对象序列化后写入到文件中
            File file = new File("obj.tmp");
            FileOutputStream fos = new FileOutputStream(file);
            //通过oos可以将对象序列化后写入obj.tmp文件中
            ObjectOutputStream oos = new ObjectOutputStream(fos);
            //将info序列化后写出
            oos.writeObject(info);
            oos.close();
            /*反序列化操作*/
            FileInputStream fis = new FileInputStream(file);
            ObjectInputStream ois = new ObjectInputStream(fis);
            //反序列化
            DownloadInfo obj = (DownloadInfo) ois.readObject();
            System.out.println(obj.getUrl());
            System.out.println(obj.getFileName());
            System.out.println(obj.getFileSize());
            System.out.println(obj.getPos());//false
            System.out.println(info==obj);
            ois.close();
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

文件读写

RandomAccessFile

java I/O 输入/输出

字符流：

断点续传

对象序列化

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读