Java拾遗2：文件传输基础——Java IO流

一.文件的编码

常用编码：

GBK编码：中文2个字节，英文1个字节
UTF-8编码：中文3个字节，英文1个字节
UTF-16BE编码：中文2个字节，英文2个字节，Java是使用的双字节编码就是UTF-16BE编码
Java文件模型

在硬盘上的文件是以byte byte byte存储的,是数据的集合。

示例代码如下：

package com.imooc.io;
/*
 * 文件的编码
 * gbk编码：中文占2个字节，英文占1个字节
 * utf-8编码：中文占3个字节，英文占1个字节
 * utf-16be编码：中文占2个字节，英文占2个字节；java是双字节编码：utf-16be编码
 */
public class EncodeDemo {
public static void main(String[] args) throws Exception {
        String s = "学习JavaIO之编码";

byte[] bytes1 = s.getBytes();//字符串转换成字节序列，用的是项目默认的编码
for(byte b:bytes1){
//把字节转换成int以16进制的方式显示
//byte类型8位，int类型32位，为了避免数据转换错误，通过&0xff将高24位清0，得到低8位
            System.out.print(Integer.toHexString(b & 0xff) + " ");
        }

        System.out.println();

//utf-8编码：中文占3个字节，英文占1个字节
byte[] bytes2 = s.getBytes("utf-8");//字符串转换成字节序列，用的是指定的utf-8编码
for (byte b : bytes2) {
            System.out.print(Integer.toHexString(b & 0xff) + " ");
        }

        System.out.println();

//gbk编码：中文占2个字节，英文占1个字节
byte[] bytes3 = s.getBytes("gbk");
for (byte b : bytes3) {
            System.out.print(Integer.toHexString(b & 0xff) + " ");
        }

        System.out.println();

//utf-16be编码：中文占2个字节，英文占2个字节
//java是双字节编码：utf-16be编码
byte[] bytes4 = s.getBytes("utf-16be");
for (byte b : bytes4) {
            System.out.print(Integer.toHexString(b & 0xff) + " ");
        }

        System.out.println();

/*
 * 当你的字节序列是某种编码时，这个时候想把字节序列变成字符串，
 * 也需要用统一的编码方式，否则会出现乱码
 */
        String str1 = new String(bytes4);//用项目默认编码
        System.out.println(str1);

        String str2 = new String(bytes4,"utf-16be");//用户指定编码
        System.out.println(str2);

/*
 * 文本文件就是字节序列
 * 可以是任意编码的字节序列
 * 如果我们在中文机器上直接创建文本文件，则该文本文件只认识ANSI编码
 */
    }

}

二.File类

File类
java.io.File类用于表示文件（或者目录）
File类只用于表示文件（或者目录）的信息（名称、大小等），不能用于文件内容的访问
创建File对象：
File file = new File(filepath)
常用方法

file.exists() //是否存在
file.mkdir()  //创建目录
file.createNewFile() //创建新文件
file.mkdirs() //创建多级目录
file.delete()  //删除文件（或者目录）
file.isDirectory() //判断是否是个目录
file.isFile() //判断是否是个文件

示例程序如下：

package com.imooc.io;

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

public class FileDemo {
    public static void main(String[] args) {
        File file = new File("C:\\Users\\kai\\Desktop\\imooc");
        //是否存在
        //System.out.println(file.exists());
        if(!file.exists()){
            file.mkdir();//file.mkdirs()创建多级目录
        } else {
            file.delete();
        }
        System.out.println(file.isDirectory());//是否是一个目录
        System.out.println(file.isFile()); //是否是一个文件

        //File file2 = new File("C:\\Users\\kai\\Desktop\\imooc\\日记1.txt");
        File file2 = new File("C:\\Users\\kai\\Desktop\\imooc","日记1.txt");
        if(!file2.exists()){
            try {
                file2.createNewFile();
            } catch (IOException e) {
                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.getPath());
    }
}

package com.imooc.io;

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

/*
 * 列出File类的一些常用操作，比如过滤，遍历等操作
 */
public class FileUtils {
/*
 * 列出指定目录下(包含其子目录)的所有文件
 */
public static  void listDirectory(File dir) throws IOException{
if(!dir.exists()){
throw new IllegalArgumentException("目录："+dir+"不存在");
        }
if(!dir.isDirectory()){
throw new IllegalArgumentException(dir+"不是目录");
        }

/*String[] filenames = dir.list();
 //list()方法用于列出当前目录下的子目录和文件，返回字符串数组，只是名称，不包含子目录下一级子目录的内容
 for(String string:filenames){
 System.out.println(dir+"\\"+string);
 }*/

//如果要遍历子目录下的的内容就需要构造成File对象，做递归操作，直到得到所有子目录下的文件。
//File提供了直接返回File对象的API:file.listFiles()
        File[] files = dir.listFiles();//返回的是当前目录下的所有文件或者目录下的文件
if(files!=null && files.length > 0){
for (File file : files) {
if(file.isDirectory()){
                    listDirectory(file);
                } else {
                    System.out.println(file);
                }
            }
        }
    }
}

三.RandomAcessFile类

RandomAcessFile类
File类只能用于表示文件（或者目录）的信息（名称、大小等），不能用于文件内容的访问，但是RandomAcessFile类则是Java提供的可以对文件内容的访问的类，既可以读文件，也可以写文件，而且支持随机访问文件，可以访问文件的任意位置。
RandomAcessFile类应用
(1)Java文件模型
在硬盘上的文件是byte byte byte存储的,是数据的集合
(2)打开文件
有两种模式”rw”(读写) “r”（只读)
RandomAccessFile raf = new RandomAccessFile(file,"rw");
文件指针，打开文件时指针在开头 pointer = 0;
(3)写方法
raf.write(int)—>只写一个字节（后8位),同时指针指向下一个位置，准备再次写入
(4)读方法
int b = raf.read()—>读一个字节
raf.read(byte[] buf)—>也可以直接读入一个字节数组buf中
(5)文件读写完成以后一定要关闭（Oracle官方说明）
raf.close()

示例程序如下：

package com.imooc.io;

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

public class RafDemo {

    public static void main(String[] args) throws IOException{
        File demo = new File("demo");//创建一个子目录：相对路径,项目下；
        if(!demo.exists()){
            demo.mkdir();
        }

        File file = new File(demo,"raf.dat");//子目录下创建一个文件
        if(!file.exists()){
            file.createNewFile();
        }

        RandomAccessFile raf = new RandomAccessFile(file, "rw");//以读写的方式随机访问文件file
        System.out.println(raf.getFilePointer());//指针的位置

/*
 * 写入：以字节方式写入
 */
        raf.write('A');//只写了一个字节，char的后8位
        System.out.println(raf.getFilePointer());
        raf.write('B');

        int i = 0x7fffffff; //用writ()方法每次只能写一个字节，如果要把i写进去，就需要4次
        raf.write(i>>>24); //高8位
        raf.write(i>>>16);
        raf.write(i>>>8);
        raf.write(i>>>0);
        System.out.println(raf.getFilePointer());

        raf.writeInt(i); //可以直接写一个int

        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.print(Integer.toHexString(b & 0xff) + " "); //字节（8位）转换成int（32位），为了避免数据转换错误，通过&0xff将高24位清0，取低8位
        }
/*String s1 = new String(buf,"gbk");
 System.out.println(s1);*/
        raf.close(); //注意：一定要关闭
    }
}

四.IO流

IO主要分为字节流和字符流

字节流

(1)InputStream、OutputStream
- InputStream 抽象了应用程序读取数据的方式
- OutputStream抽象了应用程序写出数据的方式
(2)EOF = End 读到-1就读文件结尾(EOF = -1)

(3)输入流基本方法
- int b = in.read();读取一个字节无符号填充到int低八位
- in.read(byte[] buf);读取数据到字节数组中
- in.read(byte[] buf,int start,int size)
(4)输出流基本方法
- out.write(int b); 写出一个byte到流：b的低8位
- out.write(byte[] buf)将buf字节数组都写入到流
- out.write(byte[] buf,int start,int size)
(5)FileOutputStream/FileInputStream
- FileInputStream—->实现了在文件中读取数据到流
- FileOutputStream–>实现了向文件中写出byte数据的方法
(6)DataOutputStream/DataInputStream
- 对”流”功能的扩展，可以更加方面的读取int,long，字符等类型数据
  如：DataOutputStream的writeInt()/writeDouble()/writeUTF()
(7)BufferedInputStream/BufferedOutputStream
- 这两个流类为IO提供了带缓冲区的操作，一般打开文件进行写入或读取操作时，都会加上缓冲，这种流模式提高了IO的性能
- 从应用程序中把输入放入文件，相当于将一缸水倒入到另一个缸中
(8)对比
- FileOutputStream—>write()方法相当于一滴一滴地把水“转移”过去
- DataOutputStream–>writeXxx()方法会方便一些，相当于一瓢一瓢把水“转移”过去
- BufferedOutputStream—>write方法更方便，相当于一飘一瓢先放入桶中，再从桶中倒入到另一个缸中，性能提高了
字符流

(1)认识文本和文本文件
- java的文本(char)是16位无符号整数，是字符的unicode编码（双字节编码)
- 文件是byte byte byte …的数据序列
- 文本文件是文本(char)序列按照某种编码方案(utf-8,utf-16be,gbk)序列化为byte的存储结果
(2)字符流(Reader Writer)
- 操作的是文本文本文件
- 字符的处理，一次处理一个字符
- 字符的底层任然是基本的字节序列
(3)字符流的基本实现
- InputStreamReader/OutputStreamWriter
  InputStreamReader 完成byte流解析为char流,按照编码解析
  OutputStreamWriter 提供char流到byte流，按照编码处理
- FileReader/FileWriter
- BufferedReader/ BufferedWriter/PrintWriter:字符流的过滤器
  BufferedReader —->readLine 一次读一行
  BufferedWriter/PrintWriter —->写一行

字节流示例程序如下：

package com.imooc.io;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class IOUtil {
/*
 * 读取指定文件的内容，按照16进制输出到控制台
 * 每输出10byte换行
 */
public static void printHex(String fileName) throws IOException{
//把文件作为字节流进行读操作
        FileInputStream in = new FileInputStream(fileName);
int b;
int i = 1;
while((b = in.read()) != -1){
if(b <= 0xf){
//单位数前面补0
                System.out.print("0");
            }
            System.out.print(Integer.toHexString(b)+" "); //这个不需要&0xff是因为没有转换
if(i++%10 == 0){
                System.out.println();
            }
        }
in.close();
    }

public static void printHexByByteArray(String fileName) throws IOException {
/*
 * 从in中批量读取字节，放入字节数组buf中，
 * 从第0个位置开始放，最多放buf.length个
 * 返回的是读到的字节的个数（可能放不满）
 */
/*
 FileInputStream in = new FileInputStream(fileName);
 byte[] buf = new byte[20 * 1024];
 int bytes = in.read(buf, 0, buf.length);//一次性读完，说明字节数组足够大
 int j = 1;
 for(int i = 0; i < bytes; i++){
 System.out.print(Integer.toHexString(buf[i] & 0xff)+" ");
 if(j++%10==0){
 System.out.println();
 }
 }
 */

        FileInputStream in = new FileInputStream(fileName);
byte[] buf = new byte[20 * 1024];

int bytes = 0;
int j = 1;
while((bytes = in.read(buf, 0, buf.length)) != -1){
for(int i = 0; i < bytes; i++){
                System.out.print(Integer.toHexString(buf[i] & 0xff) + " ");//byte类型8位，int类型32位，为了避免数据转换错误，通过&0xff将高24位清0，得到低8位
if(j++%10==0){
                    System.out.println();
                }
            }
        }
    }

//批量读取：copyFile(File srcFile, File destFile)最快
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, buf.length);
out.flush();//最好加上
        }
in.close();
out.close();//一定要记得关闭

    }

public static void copyFileByBuffer(File srcFile, File destFile) throws IOException{
if(!srcFile.exists()){
throw new IllegalArgumentException("文件："+srcFile+"不存在");
        }
if(!srcFile.isFile()){
throw new IllegalArgumentException(srcFile+"不是文件");
        }

        BufferedInputStream bis = new BufferedInputStream(
new FileInputStream(srcFile));
        BufferedOutputStream bos = new BufferedOutputStream(
new FileOutputStream(destFile));
int c;
while((c = bis.read())!=-1){
            bos.write(c);
            bos.flush();//刷新缓冲区。必须加上
        }
        bis.close();
        bos.close();

    }

public static void copyFileByByte(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);
int c;
while((c = in.read())!=-1){
out.write(c);
out.flush();
        }
in.close();
out.close();
    }


}

package com.imooc.io;

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

public class DisDemo {

    public static void main(String[] args) throws IOException{
        String file = "demo/dos.dat";
        IOUtil.printHex(file);
        DataInputStream dis = new DataInputStream(
                new FileInputStream(file));

        int i = dis.readInt();
        System.out.println(i);
        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();

    }

}

package com.imooc.io;

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

public class DosDemo {

public static void main(String[] args) throws IOException {
        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);
        dos.writeUTF("中国");//utf-8
        dos.writeChars("中国");//utf-16be
        dos.close();
        IOUtil.printHex(file);

    }

}

字符流示例程序如下：

package com.imooc.io;

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

public class IsrAndOswDemo {

public static void main(String[] args) throws IOException {
        FileInputStream in = new FileInputStream("C:\\Users\\kai\\Desktop\\JavaIO\\coreJava\\bin\\file.txt");
        InputStreamReader isr = new InputStreamReader(in,"gbk");//默认项目的编码，操作的时候，要补充文件的编码方式

        FileOutputStream out = new FileOutputStream("C:\\Users\\kai\\Desktop\\JavaIO\\coreJava\\bin\\fileutf8.txt");
        OutputStreamWriter osw = new OutputStreamWriter(out,"utf-8");
/*
 int c;
 while((c = isr.read())!= -1){
 System.out.print((char)c);
 }*/

/*
 * 批量读取，放入buffer这个字符数组，从第0个开始，最多放buffer.length个字符
 * 返回的是读到的字节的个数
 */
char[] buffer = new char[8*1024];
int c;
while((c = isr.read(buffer, 0, buffer.length))!=-1){
            String s = new String(buffer,0,c);//字符数组构造成字符串
            System.out.print(s);
            osw.write(buffer,0,c);
            osw.flush();
        }

        isr.close();
        osw.close();    
    }

}

package com.imooc.io;

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

public class FrAndFwDemo {

public static void main(String[] args) throws IOException{
        FileReader fr = new FileReader("C:\\Users\\kai\\Desktop\\JavaIO\\coreJava\\bin\\file.txt");//file.txt为gbk编码方式
        FileWriter fw = new FileWriter("C:\\Users\\kai\\Desktop\\JavaIO\\coreJava\\bin\\file1.0.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();

    }

}

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.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;

public class BrAndBwOrPwDemo {

public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(
new InputStreamReader(
new FileInputStream("C:\\Users\\kai\\Desktop\\JavaIO\\coreJava\\bin\\fileutf8.txt")));

        BufferedWriter bw = new BufferedWriter(
new OutputStreamWriter(
new FileOutputStream("C:\\Users\\kai\\Desktop\\JavaIO\\coreJava\\bin\\filebw.txt")));

        PrintWriter pw = new PrintWriter("C:\\Users\\kai\\Desktop\\JavaIO\\coreJava\\bin\\filepw.txt");
        String line;
while((line = br.readLine())!=null){
            System.out.println(line);//一次读一行，并不能识别换行
            bw.write(line);
            bw.newLine();//单独写出换行操作
            bw.flush();
            pw.println(line);
            pw.flush();
        }

        br.close();
        bw.close();
        pw.close();
    }

}

五.对象的序列化和反序列化

对象序列化，就是将Object转换成byte序列，反之叫对象的反序列化
序列化流(ObjectOutputStream),是过滤流—-writeObject
反序列化流(ObjectInputStream) —-readObject
序列化接口(Serializable)
对象必须实现序列化接口，才能进行序列化，否则将出现异常
这个接口，没有任何方法，只是一个标准
transient关键字
private void writeObject(java.io.ObjectOutputStream s)
throws java.io.IOException
private void readObject(java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException
序列化中子类和父类构造函数的调用问题

示例程序如下：


package com.imooc.io;

import java.io.Serializable;

/*
 * Student类
 * 将Student的对象序列化
 */
public class Student implements Serializable{
private String stuno;
private String stuname;
private transient int stuage;//该元素不会进行jvm默认的序列化,但是可以自己进行序列化

public Student() {

    }

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);
        }

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

}

package com.imooc.io;

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

public class ObjectSeriaDemo1 {

public static void main(String[] args) throws IOException, ClassNotFoundException{
        String file = "demo/obj.dat";
/*
 * 1.对象的序列化
 */
/*ObjectOutputStream oos = new ObjectOutputStream(
 new FileOutputStream(file));
 Student stu = new Student("10001","张三",20);
 oos.writeObject(stu);
 oos.flush();
 oos.close();*/

/*
 * 2.反序列化
 */
        ObjectInputStream ois = new ObjectInputStream(
new FileInputStream(file));
        Student stu = (Student)ois.readObject();
        System.out.println(stu);
        ois.close();
    }

}

package com.imooc.io;

import java.io.FileInputStream;
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 IOException, ClassNotFoundException {
/*ObjectOutputStream oos = new ObjectOutputStream(
 new FileOutputStream("demo/obj1.dat"));
 Foo2 foo2 = new Foo2();
 oos.writeObject(foo2);
 oos.flush();
 oos.close();*/

//反序列化是否递归调用父类的构造函数
/*ObjectInputStream ois = new ObjectInputStream( 
 new FileInputStream("demo/obj1.dat"));
 Foo2 foo2 = (Foo2) ois.readObject();
 System.out.println(foo2);
 ois.close();*/

/*ObjectOutputStream oos = new ObjectOutputStream(
 new FileOutputStream("demo/obj1.dat"));
 Bar2 bar2 = new Bar2();
 oos.writeObject(bar2);
 oos.flush();
 oos.close();*/

        ObjectInputStream ois = new ObjectInputStream(
new FileInputStream("demo/obj1.dat"));
        Bar2 bar2 = (Bar2)ois.readObject();
        System.out.println(bar2);
        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...");
    }
}

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

参考资料

1.Cedar,文件传输基础——Java IO流

水平有限，错误和不妥之处请指出，谢谢~

秒客网

Java拾遗2：文件传输基础——Java IO流

一.文件的编码

二.File类

三.RandomAcessFile类

四.IO流

五.对象的序列化和反序列化

相关文章