码迷，mamicode.com
首页 > 编程语言 > 详细

文件传输基础——Java IO流

时间：2017-03-14 19:06:39      阅读：315      评论：0      收藏：0      [点我收藏+]

标签：tin   reader   bis   rand   dos   函数   output   file类   ima   

  • 第一章 文件的编码

技术分享

package com.imooc.io;

public class EncodeDemo {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        String s="欢迎你ABC";
        byte[] byte1=s.getBytes();
        for (byte b : byte1) {
            //把字节转换成16进制的方式显示
            System.out.println(Integer.toHexString(b));
        }
    }

}

运行结果为：

技术分享

 

package com.imooc.io;

public class EncodeDemo {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        String s="欢迎你ABC";
        byte[] byte1=s.getBytes();
        for (byte b : byte1) {
            //把字节转换成16进制的方式显示
            System.out.println(Integer.toHexString(b & 0xff));
        }
    }

}

 运行结果为：

技术分享

  • 第二章  File类常用API介绍

java.io.File类用于表示文件（目录）

File类只用于表示文件（目录）的信息（名称，大小等），不能用于文件内容的访问

package com.imooc.io;

import java.io.File;
import java.io.IOException;

public class FileDemo {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        //了解构造函数的情况，查帮助
        File file=new File("E:\\javaio\\ime");
        //System.out.println(file.exists());
        if (!file.exists()) {
            file.mkdir();//file.mkdirs()
        }else{
            file.delete();
        }
        //是否是一个目录   如果是目录返回true,如果不是目录or目录不存在返回的是false
        System.out.println(file.isDirectory());
        //是否是个文件
        System.out.println(file.isFile());
        
        
        //File file2=new File("e:\\javaio\\日记1.txt");
        File file2=new File("e:\\javaio","日记1.txt");
        if (file2.exists()) {
            try {
                file2.createNewFile();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        } else {
            file2.delete();
            //常用的File对象的API
            System.out.println(file);//file.toString()的内容
            System.out.println(file.getAbsolutePath());
            System.out.println(file.getName());
            System.out.println(file2.getName());
            System.out.println(file.getParent());
            System.out.println(file2.getParent());
            System.out.println(file.getParentFile().getAbsolutePath());
        }
    }

}

 运行结果为：

技术分享

 遍历目录

 

package com.imooc.io;

import java.io.File;
import java.io.IOException;

public class FileUtils {
    //列出File的一些常用操作比如过滤，遍历等操作
    /**
     * @param dir
     * @ throws IOException
     */
    public static void listDirectory(File dir) throws IOException{
        //exists()方法用于判断文件或目录是否存在
        if (!dir.exists()) {
            throw new IllegalArgumentException("目录："+dir+"不存在");
        }
        //isDirectory()方法用于判断File类的对象是否是目录
        if (!dir.isDirectory()) {
            throw new IllegalArgumentException(dir+"不是目录");
        }
        
        //list()方法用于列出当前目录下的子目录和文件
        /*String[] filenames=dir.list();//返回的字符串数组    直接子的名称，不包含子目录下的内容
        for (String string : filenames) {
            System.out.println(string);
        }*/
        
        //如果要遍历子目录下的内容就需要构造成File对象做递归操作，File提供了直接返回File对象的dir
        File[] files=dir.listFiles();//返回的是直接子目（文件）的抽象
        /*for (File file : files) {
            System.out.println(file);
        }*/
        if (files!=null && files.length>0) {
            for (File file : files) {
                if (file.isDirectory()) {
                    //递归
                    listDirectory(file);
                }else{
                    System.out.println(file);
                }
                
            }
        }
    }
    
}

 

package com.imooc.io;

import java.io.File;
import java.io.IOException;

public class FileUtilTest1 {

    /**
     * @param args
     */
    public static void main(String[] args) throws Exception{
        // TODO Auto-generated method stub
        FileUtils.listDirectory(new File("E:\\example"));
    }

}
  •  第三章  RandomAccessFile类的使用

RandomAccessFile基本操作

  1. java.io.File类用于表示文件（目录）
  2. File类只用于表示文件（目录）的信息（名称，大小等），不能用于文件内容的访问RandomAccessFile java提供的对文件内容的访问，即可以读文件，也可以写文件
  3. RandeomAccessFile支持随机访问文件，可以访问文件的任意位置
  4. java文件模型

　　　　java文件模型    在硬盘上的文件是byte  byte byte存储的，是数据的集合

      5. 打开文件    

　　　（1）有两种模式“rw”（读写）“r”（只读）   

　　   （2） RandomAccessFile  raf=new RandomAccessFile("file","rw");

　　　（3）文件指针，打开文件时指针在开头pointer=0;

      6.写方法

　　　　raf.write(int)--->只写一个字节（后8位），同时指针指向下一个位置，准备再次写入

　　7.读方法

　　　　int b=raf.read()--->读一个字节

　　8.文件读写完成以后一定要关闭（oracle官方说明）

package com.imooc.io;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.util.Arrays;

public class RafDemo {

    /**
     * @param args
     */
    public static void main(String[] args) {
        File demo=new File("demo");
        if (!demo.exists()) {
            demo.mkdir();
        }
        File file=new File("raf.dat");
        if (!demo.exists()) {
            try {
                file.createNewFile();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        
        
        try {
            RandomAccessFile raf=new RandomAccessFile(file,"rw");
            //指针的位置
            System.out.println(raf.getFilePointer());
            raf.write(‘A‘);//只写了一个字节
            System.out.println(raf.getFilePointer());
            raf.write(‘B‘);
            
            int i=0x7fffffff;
            //用write方法每次只能写一个字节，如果要把i写进去就得写4次
            raf.write(i>>>24);
            raf.write(i>>>16);
            raf.write(i>>>8);
            raf.write(i);
            System.out.println(raf.getFilePointer());
            
            //可以直接写一个int
            raf.writeInt(i);
            String s="中";
            byte[] gbk=s.getBytes("gbk");
            raf.write(gbk);
            System.out.println(raf.length());
            
            //读文件，必须把指针移到头部
            raf.seek(0);
            //一次性读取，把文件中的内容都读到字节数组中
            byte[] buf=new byte[(int)raf.length()];
            raf.read(buf);
            System.out.println(Arrays.toString(buf));
            for (byte b : buf) {
                System.out.println(Integer.toHexString(b & 0xff));
            }
            raf.close();
            /*String s1=new String(buf,"gbk");
            System.out.println(s1);*/
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        
        
    }

}

运行结果：

技术分享      技术分享

 

  • 第四章  字节流

字节流之文件输入流FileInputStream-1

IO流（输入流和输出流）

字节流  字符流

1.字节流

（1）InputStream、outputSream

　　InputStream抽象了应用程序读取数据的方式

　　outputStream抽象了应用程写出数据的方式

（2）EOF=End读到-1就读到结尾

（3）输入流基本方式

　　int b=in.read();读取一个字节无符号填充到int低八位，-1是EOF

　　in.read(byte[] buf)读取数据填充到字节数组buf

　　in.read(byte[] buf,int start,int size)读取数据到字节数组buf   从buf 的 start位置开始存放size长度的数据

（4）输出流基本方法

　　out.write(int b)写出一个byte到流，b的第八位

　　out.write(byte[] buf)将buf字节数组都写入到流

　　out.write(byte[] buf,int start,int size)//字节数组buf从start位置，开始写size长度的字节到流

（5）FileInputStream--->具体实现了在文件上读取数据

 

 先计算机——文档（E）创建一个javaio文件夹——FileUtils.java文本文档

技术分享

 

package com.imooc.io;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class IOUtil {
    /**
     * @param args
     */
    /**
     * 读取指定文件内容，按照16进制输出到控制台
     * 并且每输出10个byte换行
     * @param fileName
     */
    public static void printHex(String fileName){
        try {
            //把文件作为字节流进行读操作
            FileInputStream in=new FileInputStream(fileName);
            int b;
            int i=1;
            try {
                while ((b=in.read())!=-1) {
                    if (b<=0xf) {
                        //单位数前面补0
                        System.out.println("0");
                    }
                    //将整型b转换为16进制表示的字符串
                    System.out.println(Integer.toHexString(b));
                    if (i++%10==0) {
                        System.out.println();
                    }
                }
                in.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }    
    }
}

 

package com.imooc.io;

public class IOUtilTest1 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        try {
            IOUtil.printHex("e:\\javaio\\FileUtils.java");
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }

}

字节流之文件输入流FileInputStream-2

package com.imooc.io;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.Iterator;

public class IOUtil {
    /**
     * @param args
     */
    /**
     * 读取指定文件内容，按照16进制输出到控制台
     * 并且每输出10个byte换行
     * @param fileName
     */
/*    public static void printHex(String fileName){
        try {
            //把文件作为字节流进行读操作
            FileInputStream in=new FileInputStream(fileName);
            int b;
            int i=1;
            try {
                while ((b=in.read())!=-1) {
                    if (b<=0xf) {
                        //单位数前面补0
                        System.out.println("0");
                    }
                    //将整型b转换为16进制表示的字符串
                    System.out.println(Integer.toHexString(b));
                    if (i++%10==0) {
                        System.out.println();
                    }
                }
                in.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }    
    }
    */
    
    
    
    
    
    public static void printHexByByteArray(String fileName){
        try {
            FileInputStream in=new FileInputStream(fileName);
            byte[] buf=new byte[8*1024];
            try {
                /**
                 * @从in中批量读取字节，放入到buf这个字节数组中，
                 * 从第0个位置开始放,最多放buf.length个
                 * 返回的是读到的字节的个数
                 */
                
                /*int bytes=in.read(buf,0,buf.length);//一次性读完，说明字节数组足够大
                int j=1;
                for (int i = 0; i < bytes; i++) {
                    if (buf[i]<=0xf) {
                        System.out.println("0");
                    }
                    System.out.println(Integer.toString(buf[i])+" ");
                    if (j++%10==0) {
                        System.out.println();
                    }
                }*/
                int bytes=0;
                int j=0;
                while ((bytes=in.read(buf,0,buf.length))!=-1) {
                    for (int i = 0; i < buf.length; i++) {
                        //byte类型8位，int类型32位，为了避免数据转换错误，通过&0xff将高24位清零
                        System.out.println(Integer.toHexString(buf[i] & 0xff));
                        if (j++%10==0) {
                            System.out.println();
                        }
                    }
                }
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        
    }
    
    
    
}

 

package com.imooc.io;

public class IOUtilTest2 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        try {
            IOUtil.printHexByByteArray("e:\\javaio\\FileUtils.java");
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

}

 

字节流之文件输出流FileOutputStream

FileOutputStream实现了向文件中写出byte数据的方法

 

package com.imooc.io;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Iterator;

public class IOUtil {
    public static void printHex(String fileName) {
        // TODO Auto-generated method stub
        try {
            FileInputStream in=new FileInputStream(fileName);
            byte[] buf=new byte[8*1024];
            int bytes=0;
            int j=0;
            try {
                while ((bytes=in.read(buf,0,buf.length))!=-1) {
                    for (int i = 0; i < buf.length; i++) {
                        //byte类型8位，int类型32位，为了避免数据转换错误，通过&0xff将高24位清零
                        System.out.println(Integer.toHexString(buf[i] & 0xff));
                        if (j++%10==0) {
                            System.out.println();
                        }
                    }
                    
                }
                in.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }    
    }

    
    public static void copyFile(File srcFile,File destFile)throws IOException{
        
        if (!srcFile.exists()) {
            throw new IllegalArgumentException("文件："+srcFile+"不存在");
        }
        if (!srcFile.isFile()) {
            throw new IllegalArgumentException(srcFile+"不是文件");
        }
        FileInputStream in=new FileInputStream(srcFile);
        FileOutputStream out=new FileOutputStream(destFile);
        byte[] buf=new byte[8*1024];
        int b;
        while ((b=in.read(buf,0,buf.length))!=-1) {
            out.write(buf,0,b);
            out.flush();//最好加上
        }
        in.close();
        out.close();
    }
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
}

 

package com.imooc.io;

import java.io.FileOutputStream;

public class FileOutDemo1 {
    /**
     * @param args
     */
    public static void main(String[] args) throws Exception{
        //如果该文件不存在，则直接创建，如果存在，删除后创建
        FileOutputStream out=new FileOutputStream("demo/out.dat");
        out.write(‘A‘);//写出了‘A’的低八位
        out.write(‘B‘);//写出了‘B’的低八位
        int a=10;//write只能写八位，那么写一个int需要些4次每次8位
        out.write(a>>>24);
        out.write(a>>>16);
        out.write(a>>>8);
        out.write(a);
        byte[] gbk="中国".getBytes("gbk");
        out.write(gbk);
        out.close();
        
        IOUtil.printHex("demo/out.dat");
    }

}

运行结果为：

技术分享

 

package com.imooc.io;

import java.io.File;
import java.io.IOException;

public class IOUtilTest3 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        try {
            IOUtil.copyFile(new File("e:\\javaio\\imooc.txt"),new File("e:\\javaio\\imooc1.txt"));
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

}

 运行结果为：

技术分享

 

字节流之数据输入输出流

 DataOutputStream/DataInputStream  对“流”功能的扩展，可以更加方面的读取int，long,字符等类型数据DataOutputStream

writeInt()/writeDouble()/writeUTF()

package com.imooc.io;

import java.io.DataOutputStream;
import java.io.FileOutputStream;

public class DosDemo {

    /**
     * @param args
     */
    public static void main(String[] args) throws Exception{
        String file="demo/dos.dat";
        DataOutputStream dos=new DataOutputStream(new FileOutputStream(file));
        dos.writeInt(10);
        dos.writeInt(-10);
        dos.writeLong(10l);
        dos.writeDouble(10.5);
        //采用utf-8编码写出
        dos.writeUTF("中国");
        //采用    utf-16be编码写出
        dos.writeChars("中国");
        dos.close();
        IOUtil.printHex(file);

    }

}

 运行结果为：

技术分享

 

 

package com.imooc.io;

import java.io.DataInput;
import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;

public class DisDemo {

    /**
     * @param args
     * @throws Exception 
     */
    public static void main(String[] args) throws Exception {
        String file="demo/dos.dat";
        IOUtil.printHex(file);
        
            DataInputStream dis=new DataInputStream(new FileInputStream(file));
            int i=dis.readInt();
            System.out.println(i);
            long l=dis.readLong();
            System.out.println(l);
            double d=dis.readDouble();
            System.out.println(d);
            String s=dis.readUTF();
            System.out.println(s);
            dis.close();

    }

}

 

运行结果为：略

 

 字节缓冲流

BufferedInputStream & BufferedOutputStream 这两个流类位IO提供了带缓冲区的操作，一般打开文件进行写入或读取操作时，都会加上缓冲，这种流模式提高了IO的性能

从应用程序中把输入放入文件，相当于将一缸水倒入到另一个缸中：

FileOutputStream---->write()方法相当于一滴一滴地把水“转移”过去

DataOutputStream--->writeXxx()方法会方便一些，相当于一瓢一瓢把水“转移”过去

BufferedOutputStream--->write方法更方便，相当于一瓢一瓢先放入桶中，再从桶中倒入到另一个缸中，性能提高了

package com.imooc.io;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Iterator;

public class IOUtil {
    public static void printHex(String fileName) {
        // TODO Auto-generated method stub
        try {
            FileInputStream in=new FileInputStream(fileName);
            byte[] buf=new byte[8*1024];
            int bytes=0;
            int j=0;
            try {
                while ((bytes=in.read(buf,0,buf.length))!=-1) {
                    for (int i = 0; i < buf.length; i++) {
                        //byte类型8位，int类型32位，为了避免数据转换错误，通过&0xff将高24位清零
                        System.out.println(Integer.toHexString(buf[i] & 0xff));
                        if (j++%10==0) {
                            System.out.println();
                        }
                    }
                    
                }
                in.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }    
    }

    
    public static void copyFile(File srcFile,File destFile)throws IOException{
        
        if (!srcFile.exists()) {
            throw new IllegalArgumentException("文件："+srcFile+"不存在");
        }
        if (!srcFile.isFile()) {
            throw new IllegalArgumentException(srcFile+"不是文件");
        }
        FileInputStream in=new FileInputStream(srcFile);
        FileOutputStream out=new FileOutputStream(destFile);
        byte[] buf=new byte[8*1024];
        int b;
        while ((b=in.read(buf,0,buf.length))!=-1) {
            out.write(buf,0,b);
            out.flush();//最好加上
        }
        in.close();
        out.close();    
    }
    
    
    
    /*进行文件的拷贝，利用带缓冲的字节流
     * 
     * 
     * */
    public static void copyFileByBuffer(File srcFile,File desFile) throws Exception{
        if (!srcFile.exists()) {
            throw new IllegalArgumentException("文件"+srcFile+"不存在");
        }
        if (!srcFile.exists()) {
            throw new IllegalArgumentException("不是文件");
            
        }
        BufferedInputStream bis=new BufferedInputStream(new FileInputStream(srcFile));
        BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream(desFile));
        int c;
        while ((c=bis.read())!=1) {
            bos.write(c);
            bos.flush();//刷新缓冲区
        }
        bis.close();
        bos.close();
    }    
}

 

package com.imooc.io;

import java.io.File;
import java.io.IOException;

public class IOUtilTest4 {

    /**
     * @param args
     * @throws IOException 
     */
    public static void main(String[] args) throws IOException {
        IOUtil.copyFile(new File("E:\\javaio\\FileUtils.java"), new File("E:\\javaio\\aa.txt"));
    }

}
package com.imooc.io;

import java.io.File;
import java.io.IOException;

public class IOUtilTest4 {

    /**
     * @param args
     * @throws IOException 
     */
    public static void main(String[] args) throws IOException {
        IOUtil.copyFile(new File("E:\\javaio\\FileUtils.java"), new File("E:\\javaio\\aa.txt"));
    }

}

 运行结果为：

技术分享

 

  • 第五章 字符流

字节字符转换流

 1.编码问题

 2.认识文本和文本文件

Java的文本（char）是16位无符号整数，是字符的unicode编码（双字节编码）

文件是byte byte byte......的数据序列

文本文件是文本（char）序列按照某种编码方案（utf-8,utf-16be,gbk）序列化为byte的存储结果

3.字符流（Reader writer）--->操作的是文本文件

字符的处理，一次处理一个字符

字符的底层任然是基本的字节序列

字符流的基本实现

InputStreamReader  完成byte流解析为char流，按照编码解析

OutputStreamWriter 提供char流到byte流，按照编码处理

package com.imooc.io;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStreamReader;

public class Test11 {

    /**
     * @param args
     * @throws Exception 
     */
    public static void main(String[] args) throws Exception {
        FileInputStream in=new FileInputStream("e:\\javaio\\imooc.txt");
        InputStreamReader isr=new InputStreamReader(in);//默认项目的编码
        /*int c;
        while ((c=isr.read())!=-1) {
            System.out.println((char)c);
        }*/
        char[] buffer=new char[8*1024];
        int c;
        //批量读取，放入buffer这个字符数组，从第0个位置开始放置，最多放buffer.length个
        //放回的是读到的字符的个数
        while ((c=isr.read(buffer,0,buffer.length))!=-1) {
            String s=new String(buffer,0,c);
            System.out.println(s);
        }
    }

}

 运行结果：

技术分享

 

 提醒：imooc.txt必须是 utf-8 不然复制出来的文本文档会出现乱码

技术分享

package com.imooc.io;

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

public class IsrAndOswDemo {

    /**
     * @param args
     */
    public static void main(String[] args) throws Exception{
        FileInputStream in=new FileInputStream("e:\\javaio\\imooc.txt");
        InputStreamReader isr=new InputStreamReader(in,"utf-8");//默认项目的编码
        
        FileOutputStream out=new FileOutputStream("e:\\javaio\\imoocutf81.txt");
        OutputStreamWriter osw=new OutputStreamWriter(out,"utf-8");
        /*int c;
        while ((c=isr.read())!=-1) {
            System.out.println((char)c);
        }*/
        char[] buffer=new char[8*1024];
        int c;
        //批量读取，放入buffer这个字符数组，从第0个位置开始放置，最多放buffer.length个
        //放回的是读到的字符的个数
        while ((c=isr.read(buffer,0,buffer.length))!=-1) {
            String s=new String(buffer,0,c);
            System.out.println(s);
            osw.write(buffer,0,c);
            osw.flush();
        }
        isr.close();
        osw.close();
    }
    
}

 运行结果：

技术分享

 

字符流之文件读写流

FileReader/FileWriter读写文本文件

 

package com.imooc.io;

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;

public class FrAndFwDemo {

    /**
     * @param args
     * @throws FileNotFoundException 
     */
    public static void main(String[] args) throws Exception {
        // TODO Auto-generated method stub
        FileReader fr=new FileReader("e:\\javaio\\imooc.txt");
        FileWriter fw=new FileWriter("e:\\javaio\\imooc2.txt",true);//文件追加内容
        char[] buffer=new char[2056];
        int c;
        while ((c=fr.read(buffer,0,buffer.length))!=-1) {
            fw.write(buffer,0,c);
            fw.flush();
        }
        fr.close();
        fw.close();
    }

}

 运行结果： 复制前的文本文件

技术分享

 

复制后的文本文件

技术分享

 

字符流的过滤器

字符流的过滤器 bufferedReader --->readLine一次读一行

bufferedWriter/PrintWriter--->写一行

 

package com.imooc.io;

import java.io.BufferedReader;
import java.io.BufferedWriter;
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.PrintWriter;

public class BrAndBwOrPwDemo {
    public static void main(String[] args) throws Exception{
        //对文件进行读写操作
        BufferedReader bReader=new BufferedReader(
                new InputStreamReader(
                        new FileInputStream( "e:\\javaio\\imooc.txt")));
        
        BufferedWriter bufferedWriter=new BufferedWriter(
                new OutputStreamWriter(
                        new FileOutputStream("e:\\javaio\\imooc3.txt")));    
        
        PrintWriter printWriter=new PrintWriter("e:\\javaio\\imooc4.txt");
        String line;
            while ((line=bReader.readLine())!=null) {
                /*System.out.println(line);//一次读一行，并不能识别换行    
                bufferedWriter.write(line);//换行操作
                //单独写出换行操作
                bufferedWriter.flush();*/
                printWriter.print(line);
                printWriter.flush();
        }    
                
        bReader.close();
        //bufferedWriter.close();
        printWriter.close();
    }
}

运行结果为：

技术分享

 

  • 第六章 对象的序列化和反序列化

序列化基本操作

1.对象的序列化，反序列化

（1）对象序列化，就是将Object转换成byte序列，反之叫对象的反序列化

（2）序列化流（ObjectOutputStream），是过滤流----writeObject

反序列化流（ObjectInputStream）----readObject

(3)序列化接口（Serializable）

　　对象必须实现实例化接口，才能进行序列化，否则将出现异常

　　这个接口，没有任何方法，只是一个标准

定义Student类：

package com.imooc.io;

import java.io.Serializable;
public class Student implements Serializable{
    private String  stuno;
    private String  stuname;
    private int stuage;
    
    public Student(String stuno, String stuname, int stuage) {
        super();
        this.stuno = stuno;
        this.stuname = stuname;
        this.stuage = stuage;
    }
    
    public String getStuno() {
        return stuno;
    }
    public void setStuno(String stuno) {
        this.stuno = stuno;
    }
    public String getStuname() {
        return stuname;
    }
    public void setStuname(String stuname) {
        this.stuname = stuname;
    }
    public int getStuage() {
        return stuage;
    }
    public void setStuage(int stuage) {
        this.stuage = stuage;
    }
    
    @Override
    public String toString() {
        return "Student [stuno=" + stuno + ", stuname=" + stuname + ", stuage="
                + stuage + "]";
    }
    
    



    

}

 测试：

package com.imooc.io;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class ObjectSeriaDemo1 {
    public static void main(String[] args) throws Exception {
        //对象的序列化
        ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("e:\\javaio\\imooc.txt"));
        Student student=new Student("10001", "小明", 21);
        oos.writeObject(student);
        oos.flush();
        oos.close();
        
        
        
    }

}

 运行结果为：

技术分享

 

package com.imooc.io;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class ObjectSeriaDemo1 {
    public static void main(String[] args) throws Exception {
        //对象的序列化
        /*ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("e:\\javaio\\imooc.txt"));
        Student student=new Student("10001", "小明", 21);
        oos.writeObject(student);
        oos.flush();
        oos.close();*/
        
        ObjectInputStream ois=new ObjectInputStream(new FileInputStream("e:\\javaio\\imooc.txt"));
        Student student=(Student) ois.readObject();
        System.out.println(student);

    
        
    }

}

 运行结果为：

技术分享

 

transient及ArrayList源码分析

transient关键字

private void writeObject(java.io.ObjectOutputStream s) throws java.io.IOException

private void readObject(java.io.ObjectInputStream s) throws java.io.IOException, ClassNotFoundException

分析ArrayList源码中序列化和反序列化的问题

package com.imooc.io;

import java.io.Serializable;
import java.util.jar.JarException;
public class Student implements Serializable{
    private String  stuno;
    private String  stuname;
    private transient int stuage;//该元素不会进行jvm默认的序列化，也可以自己完成这个元素的序列化
    
    public Student(String stuno, String stuname, int stuage) {
        super();
        this.stuno = stuno;
        this.stuname = stuname;
        this.stuage = stuage;
    }
    
    public String getStuno() {
        return stuno;
    }
    public void setStuno(String stuno) {
        this.stuno = stuno;
    }
    public String getStuname() {
        return stuname;
    }
    public void setStuname(String stuname) {
        this.stuname = stuname;
    }
    public int getStuage() {
        return stuage;
    }
    public void setStuage(int stuage) {
        this.stuage = stuage;
    }
    
    @Override
    public String toString() {
        return "Student [stuno=" + stuno + ", stuname=" + stuname + ", stuage="
                + stuage + "]";
    }

private void writeObject(java.io.ObjectOutputStream s) throws java.io.IOException{
    s.defaultWriteObject();//把jvm能默认序列化的元素进行序列化操作
    s.writeInt(stuage);//自己完成stuage的序列化
}

private void readObject(java.io.ObjectInputStream s) throws java.io.IOException, ClassNotFoundException{
    s.defaultReadObject();//把jvm能默认反序列化的元素进行反序列化操作
    this.stuage=s.readInt();
}
    

}
package com.imooc.io;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class ObjectSeriaDemo1 {
    public static void main(String[] args) throws Exception {
        //对象的序列化
        /*ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("e:\\javaio\\imooc.txt"));
        Student student=new Student("10001", "小明", 21);
        oos.writeObject(student);
        oos.flush();
        oos.close();*/
        
        ObjectInputStream ois=new ObjectInputStream(new FileInputStream("e:\\javaio\\imooc.txt"));
        Student student=(Student) ois.readObject();
        System.out.println(student);

    
        
    }

}

 序列化运行结果为：

技术分享

  反序列化运行结果为： 

技术分享

 

 序列化中子父类构造数问题

序列化中子类和父类构造函数的调用问题

package com.imooc.io;

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

public class ObjectSeriaDemo2 {
    public static void main(String[] args) throws Exception {
        ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("e:\\javaio\\imooc.txt"));
        Foo2 foo2=new Foo2();
        oos.writeObject(foo2);
        oos.flush();
        oos.close();
        
        
    }

}

/*一个类实现了序列化接口，那么其子类都可以进行序列化*/
class Foo implements Serializable{
    public Foo(){
        System.out.println("foo........");
    }
}
class Foo1 extends Foo{
    public Foo1(){
        System.out.println("foo1........");
    }
}
class Foo2 extends Foo1{
    public Foo2(){
        System.out.println("foo2........");
    }
}

 运行结果为：

技术分享

 

package com.imooc.io;

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

public class ObjectSeriaDemo2 {
    public static void main(String[] args) throws Exception {
        /*ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("e:\\javaio\\imooc.txt"));
        Foo2 foo2=new Foo2();
        oos.writeObject(foo2);
        oos.flush();
        oos.close();*/
        
        //反序列化是否递归调用父类的构造函数
                ObjectInputStream ois=new ObjectInputStream(new FileInputStream("e:\\javaio\\imooc.txt"));
                Foo2 foo2=(Foo2) ois.readObject();
                System.out.println(foo2);
                ois.close();
    
    }

}

/*一个类实现了序列化接口，那么其子类都可以进行序列化*/
class Foo implements Serializable{
    public Foo(){
        System.out.println("foo........");
    }
}
class Foo1 extends Foo{
    public Foo1(){
        System.out.println("foo1........");
    }
}
class Foo2 extends Foo1{
    public Foo2(){
        System.out.println("foo2........");
    }
}

 运行结果为：

技术分享

 

package com.imooc.io;

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

public class ObjectSeriaDemo2 {
    public static void main(String[] args) throws Exception {
            /*ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("e:\\javaio\\imooc.txt"));
            Foo2 foo2=new Foo2();
            oos.writeObject(foo2);
            oos.flush();
            oos.close();*/
        
        //反序列化是否递归调用父类的构造函数
                /*ObjectInputStream ois=new ObjectInputStream(new FileInputStream("e:\\javaio\\imooc.txt"));
                Foo2 foo2=(Foo2) ois.readObject();
                System.out.println(foo2);
                ois.close();*/
    
        ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("e:\\javaio\\imooc.txt"));
        Bar2 bar2=new Bar2();
        oos.writeObject(bar2);
        oos.flush();
        oos.close();
    }

}

class Bar {
    public Bar() {
        System.out.println("bar");
    }
}
class Bar1 extends Bar implements Serializable{
    public Bar1(){
        System.out.println("bar1.........");
    }
}
class Bar2 extends Bar1{
    public Bar2(){
        System.out.println("bar2.........");
    }
}

/*一个类实现了序列化接口，那么其子类都可以进行序列化*/
/*class Foo implements Serializable{
    public Foo(){
        System.out.println("foo........");
    }
}
class Foo1 extends Foo{
    public Foo1(){
        System.out.println("foo1........");
    }
}
class Foo2 extends Foo1{
    public Foo2(){
        System.out.println("foo2........");
    }
}*/

 运行结果为：

技术分享

 

package com.imooc.io;

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

public class ObjectSeriaDemo2 {
    public static void main(String[] args) throws Exception {
            /*ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("e:\\javaio\\imooc.txt"));
            Foo2 foo2=new Foo2();
            oos.writeObject(foo2);
            oos.flush();
            oos.close();*/
        
        //反序列化是否递归调用父类的构造函数
                /*ObjectInputStream ois=new ObjectInputStream(new FileInputStream("e:\\javaio\\imooc.txt"));
                Foo2 foo2=(Foo2) ois.readObject();
                System.out.println(foo2);
                ois.close();*/
    
        /*ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("e:\\javaio\\imooc.txt"));
        Bar2 bar2=new Bar2();
        oos.writeObject(bar2);
        oos.flush();
        oos.close();*/
        
        ObjectInputStream ois=new ObjectInputStream(new FileInputStream("e:\\javaio\\imooc.txt"));
        Bar2 bar2=(Bar2) ois.readObject();
        System.out.println(bar2);
        ois.close();
    }

}
 /*对子类对象进行反序列化操作时，  *如果其父类没有实现序列化接口  *那么其父类的构造函数会被调用 */

class Bar {
    public Bar() {
        System.out.println("bar");
    }
}
class Bar1 extends Bar implements Serializable{
    public Bar1(){
        System.out.println("bar1.........");
    }
}
class Bar2 extends Bar1{
    public Bar2(){
        System.out.println("bar2.........");
    }
}

/*一个类实现了序列化接口，那么其子类都可以进行序列化*/
/*class Foo implements Serializable{
    public Foo(){
        System.out.println("foo........");
    }
}
class Foo1 extends Foo{
    public Foo1(){
        System.out.println("foo1........");
    }
}
class Foo2 extends Foo1{
    public Foo2(){
        System.out.println("foo2........");
    }
}*/

 运行结果为：

技术分享

 

文件传输基础——Java IO流

标签：tin   reader   bis   rand   dos   函数   output   file类   ima   

原文地址：http://www.cnblogs.com/mashuangying2016/p/6549973.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！