《Java从入门到精通》第十二章学习笔记

第12章  输入和输出

一、流概述

流是指一组有序的数据序列，数据源和输出目标可以是文件，网络，压缩包或其他。

二、输入/输出流

所有输入流都是抽象类InputStream(字节输入流）或抽象类Reader(字符输入流）的子类；所有输出流都是抽象类OutputStream（字节输出流）和抽象类Writer（字符输出流）的子类。

1、输入流

InputStream是所有字节输入流的父类，该类主要方法如下，方法出现错误时候会引发IOException异常。

（1）read():从输入流中读取数据的下一个字节，返回0~255之间的int字节值，如果已到末尾，返回-1.

（2）read(byte[] b)：从输入流中读入一定长度的字节，并以整数形式返回字节数。

（3）close()：关闭此输入流并释放与该数据流关联的所有系统资源。

Java中的字符是Unicode编码，为双字节，而InputStream类处理的是字节流，一般在Java中用Reader类处理字符文本。

2、输出流

OutputStream是所有字节输出流的父类，主要方法如下：

（1）write(int b):将指定的字节写入此输出流。

（2）write(byte[] b):将b.length个字节从指定的byte数组写入流

（3）close()：关闭输出流。

三、File类

1、文件的创建与删除

（1）File(String pathname):参数作为路径名创建一个新File实例。

（2）File(String parent,String child):参数分别作为父路径和子路径，创建一个新File实例。

（3）File(File f,String child):f作为父路径对象，child作为子路径字符串。

//项目中创建FileTest类，判断D盘的mywork文件夹是否存在work.txt
//如果存在则删除，如果不存在则创建
import java.io.File;
public class FileTest {

    public static void main(String[] args) {
        File file=new File("D:/myword","test.txt");//创建文件对象
        if(file.exists()){
            file.delete();
            System.out.println("文件已删除");
        }else{
            try{
                file.createNewFile();
                System.out.println("文件已创建");
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }
}

2、获取文件信息

File类获取文件本身信息的方法主要包括：

（1）getName():获取文件的名称。

（2）canRead():判断文件是否可读

（3）canWrite():判断文件是否可写入

（4）exists():判断文件是否存在

（5）length():获取文件以字节为单位的长度

（6）getAbsolutePath():获取文件的绝对路径

（7）getParent():获取文件的父路径

（8）isFile():判断文件是否存在（判断对象是否是一个文件？）

（9）isDirectory():判断对象是否是一个目录

（10）isHidden():判断对象是否是隐藏文件

（11）lastMOdified():获取文件最后修改时间

import java.io.File;
public class FileTest {

    public static void main(String[] args) {
        File file=new File("D:/myword","test.txt");//创建文件对象
        if(file.exists()){
            String name=file.getName();  //获取文件名称
            long length=file.length();    //获取文件长度
            boolean hidden=file.isHidden();  //判断文件是否隐藏
            System.out.println("文件名称为："+name);
            System.out.println("文件长度为："+length);
            System.out.println("文件是隐藏文件吗？"+hidden);
        }else{
            System.out.println("文件不存在！");
        }
 　　}
}

//通过renameTo()重命名文件
import java.io.File;
public class FileTest {

    public static void main(String[] args) {
        File file=new File("D:/myword","test.txt");//创建文件对象
        
        if(file.exists()){
            System.out.println("文件名称为："+file.getName());//获取文件名称
            System.out.println("文件长度为："+file.length());//获取文件长度
            System.out.println("文件是隐藏文件吗？"+file.isHidden());//判断文件是否隐藏
        }else{
            System.out.println("文件不存在！");
        }
        File file1=new File("D:/myword","testhaha.txt");
        if(file1.exists()){
            System.out.println("已存在"+file1.getName()+"文件，无法重命名！！");
        }else{
            file.renameTo(file1);
            System.out.println(file.getName()+"文件名称已修改为"+file1.getName());
        }
    }
}

四、文件输入、输出流

1、如果需要将数据永久保存，可使用FileInputStream和FileOutputStream类与文件建立连接，将需要的数据永久保存到文件里。

FileInputStream是InputStream抽象类的实现类，FileOutputStream是OutputStream抽象类的实现类。

 

//使用FileOutputStream类向文件work写入信息
//然后通过FileinputStream类将work文件中的数据读取到控制台中
import java.io.*;
public class FileTest {
    public static void main(String[] args){
        File file=new File("F:\\...\\STUDY\\lab\\java","work.txt");        //创建文件对象
        try{
            FileOutputStream out=new FileOutputStream(file);  //创建FileOutputStream对象
            byte bx[]=" tslvcj ".getBytes();            //创建字节型数组
            out.write(bx);                //将数组中信息写入文件
            out.close();                //关闭输出流
        }catch(Exception e){
            e.printStackTrace();
        }
        try{
            FileInputStream in=new FileInputStream(file);
            byte by[]=new byte[1024];
            int len=in.read(by);    //将文件中字节流数据读取入数组
            System.out.println("文件中信息是："+new String(by,0,len));
            in.close();
        }catch(Exception e){
            e.printStackTrace();
        }
            
    }

}

2、FileInputStream和FileOutputStream是针对字节流文件的类，如果对于非单字节编码的文件，可能会出现乱码，一般对字符流文件采用FileReader和FileWriter类。

import java.io.*;
public class FileRwTest {

    public static void main(String[] args) {
        File file=new File("F:\\霜\\STUDY\\lab\\java","work.txt");
        try{
            FileWriter fwr=new FileWriter(file);
            fwr.write("ilc！");
            fwr.close();
        }catch(Exception e){
            e.printStackTrace();
        }
        try{
            FileReader fr=new FileReader(file);
            char mystr[]=new char[1024];
            int len=fr.read(mystr);
            System.out.println("文件中信息为："+new String(mystr,0,len));
            fr.close();
        }catch(Exception e){
            e.printStackTrace();
        }
        System.out.println("文件名称为："+file.getName());
        System.out.println("文件长度为："+file.length()+"Bytes");
        System.out.println("文件是否隐藏："+file.isHidden());
    }
}

 

import java.io.*;
public class FileTest {
    //显示某一文件类下所有文件的名称
    public void showFileName(File file){
        if(!file.exists()){
            System.out.println("文件不存在！");
        }else{
            if(file.isFile()){
                System.out.println(file.getName());
            }else{
                File[] fd=file.listFiles();
                for(File fx:fd){
                    showFileName(fx);
                }
            }
        }
    }
    public static void main(String[] args){
        FileTest ft=new FileTest();
        File file=new File("E:\\lab");
        ft.showFileName(file);
    }
}

//删除指定文件或文件夹
import java.io.*;
public class DelFile {
    public void delF(File file){
        if(!file.exists()){
            System.out.println("文件不存在！");
        }else{
            if(file.isFile()){
                System.out.println("文件"+file.getName()+"已删除！");
                file.delete();
            }else{
                File[] fa=file.listFiles();
                for(File fx:fa){
                    delF(fx);
                }
                
            }
        }
    }
    public static void main(String[] args){
        DelFile delTest=new DelFile();
        File file=new File("E:\\lab");
        delTest.delF(file);
    }
}

五、带缓存的输入、输出流
1、BufferedInputStream类可以对任意InputStream类进行带缓存区的包装以达到性能优化，有两种构造函数：

（1）BufferedInputStream(InputStream in):创建了32个字节的缓存流；

（2）BufferedInputStream(InputStream in,int size):按指定大小创建缓存流。

2、BufferedOutputStream类输出信息和向OutputStream类输入信息完全一样，只不过BufferedOutputStream通过flush()方法强制将缓存区的数据输出结束。其有两种构造方法：

（1）BufferedOutputStream(OutputStream in):创建一个32个字节的缓存区；

（2）BufferedOutputStream(OutputStream in,int size):按指定大小创建缓存流。

3、BufferedReader类与BufferedWriter类分别继承Reader类和Writer类

*BufferedReader类常用方法如下：

（1）read():读取单个字符；

（2）readLine():读取一个文本行，并将其返回为字符串；若无数据，返回null；

（3）writ(String s,int off,int len):写入字符串的某一部分；

（4）flush():刷新该流的缓存。

补充：

一、RandomAccessFile

是java提供的对内容的访问类，可读写操作，顾名思义也可以随机访问文件（即访问文件的任意位置）。

1、Java文件模型：对于Java而言，在硬盘上的文件是byte-byte-byte存储的，是字节数据的集合

2、访问有两种模式："rw"（读写）、"r"（只读）

RandomAccessFile raf=new RandomAccessFile(file,"rw");

因为随机访问，所以RandomAccessFile类内部含有一个文件指针，第一次打开文件时候指针指向文件开头即pointer=0;随着操作指针会后移。

3、写方法

raf.write(int):只写一个字节（int的后8位），同时指针指向下一个字节位置

4、读取文件

int b=raf.read():读取指针所指的一个字节

5、文件操作完成后一定要关闭

raf.close();

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


public class RafDemo {
    public static void main(String[] args) throws Exception{
        //创建文件所在目录对应的文件对象
        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");
        //看一下指针的位置
        System.out.println(raf.getFilePointer());
        
        raf.write('A');//只写一个字节，A的后8位（低8位）
        System.out.println(raf.getFilePointer());
        raf.write('B');
        
        //定义一个整数，写入文件
        //但每次只能写一个字节
        //只能通过移位，分别写4词
        int i=0x7fffffff;
        raf.write(i>>>24);//先写高8位，因为write写的是低8位，所以先右移24位，
        raf.write(i>>>16);
        raf.write(i>>>8);
        raf.write(i);
        //前面写了6个字节，此时指针指向6
        System.out.println(raf.getFilePointer());
        
        //可以直接写int型数据
        raf.writeInt(i);
        
        System.out.println(raf.getFilePointer());
        
        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)+" ");
        }
        //字符数组构造成字符串
        String s1=new String(buf);
        System.out.println(s1);
        raf.close();
    }

}

二、IO流

分为字节流和字符流

1、字节流

（1）InputStream\OutputStream

InputStream抽象了应用程序读取数据的方式；OutputStream抽象了应用程序写出数据的方式；

（2）达到文件结尾，即EOF=End  读到-1就是读到结尾

（3）输入流基本方法（一般即读出的操作）

int b=in.read();读取一个字节无符号填充到整型b的低8位.读到-1即结尾

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

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

(4)输出流基本方法（一般即写入的操作）

out.write(int b):只写一个byte（b的低八位）到out流

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

out.write(byte[] buf,int start,int size)

(5)InputStream\OutputStream的子类：FileInputStream和FileOutputStream

FileInputStream具体实现了在文件上读取数据

FileOutputStream具体实现了在文件上写数据

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


public class IOUtil {
/*
 * 读取指定文件内容，按照16进制输出到控制台
 * 并且每输出10个byte换行
 */

    public static void printHex(String fileName) throws Exception{
        //把文件作为字节流进行读操作
        FileInputStream in=new FileInputStream(fileName);
        int b;
        int i=1;
        while((b=in.read())!=-1){
            if(b<=0xf){
                System.out.print("0");
            }
            System.out.print(Integer.toHexString(b)+"  ");
            if(i++%10==0){
                System.out.println();
            }
        }
        System.out.println();
        System.out.println("文件一共有"+i+"个字节！");
        in.close();
    }

}

public class IOUtilTest1 {

    public static void main(String[] args) {
        try {
            IOUtil.printHex("F:\\IOUtil.java");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}

 上面程序中用in.read()通过单字节读取文件，对于较大的文件，一般用in.read(byte[] buf,int start,int size)进行批量读取以节约时间。

针对上面的程序，优化如下：

public static void printHexByByteArray(String fileName)throws Exception{
        FileInputStream in=new FileInputStream(fileName);
        byte[] buf=new byte[20*1024];
        //从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.print("0");
            }
            System.out.print(Integer.toHexString(buf[i])+" ");
            if(j++%10==0){
                System.out.println();
            }
        }
        in.close();
        
    }

利用FileOutputStream写文件，并完成文件的复制功能。

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.File;
public class FileOutDemo1 {
    public static void copyFile(File srcFile,File destFile)throws IOException{
        if(!srcFile.exists()){
            throw new IllegalArgumentException("文件不存在！");
        }
        if(!srcFile.isFile()){
            throw new IllegalAccessError(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 main(String[] args)throws IOException{
        File demo=new File("demo");
        if(!demo.exists()){
            demo.mkdir();
        }
        //如果该文件不存在，则直接创建，如果存在删除后创建
        FileOutputStream out=new FileOutputStream("demo/out.txt");
        out.write('a');
        out.write('b');
        byte[] buf="中国".getBytes("gbk");
        out.write(buf);
        File srcFile=new File("demo/out.txt");
        File outCopy=new File("demo/outCopy.txt");
        copyFile(srcFile,outCopy);
        
    
    }

}

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

import java.io.*;
public class DosDemo {
    public static void main(String[] args)throws Exception{
        String file="demo/dos.txt";
        File demo=new File("demo");
        if(!demo.exists()){
            demo.mkdir();
        }
        //DataOutputStream类的构造函数的参数是FileOutputStream类对象
        DataOutputStream dos=new DataOutputStream(
                new FileOutputStream(file));
        dos.writeInt(10);
        dos.writeInt(-10);
        dos.writeLong(10);
        dos.writeDouble(10.5);
        dos.writeUTF("中国");
        dos.writeChars("中国");
        dos.close();
        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();
    }
}

4、BufferedInputStream/BufferedOutputStream：为IO提供了带缓冲区的操作，一般打开文件进行写入或读取操作时，都会加上缓冲，这种流模式提高了IO的性能。
比喻：从应用程序中把数据输出到文件，相当于把一缸水倒入外面的一个水箱

那么：

FileOutputStream类的write()方法相当于一滴一滴倒入；

DataOutputStream类的writeXxx()方法（包括writeInt,writeLong,writeUTF等）相当于一瓢一瓢地倒入；

而BufferOutputStream类的write()方法相当于先一瓢一瓢倒入桶中，再从桶中倒入水箱。

下面是通过不同IO流类的复制文件方法所耗时的对比：

/*利用带缓冲的字节流类
 * 进行文件的复制
 */
import java.io.*;
public class CopyFile {
    //Buffered流操作
    public static void  copyFileByBuffer(File srcFile,File destFile)throws Exception{
        if(!srcFile.exists()){
            throw new IllegalArgumentException("文件不存在！");
        }
        if(!srcFile.isFile()){
            throw new IllegalAccessError(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 Exception{
            if(!srcFile.exists()){
                throw new IllegalArgumentException("文件不存在！");
            }
            if(!srcFile.isFile()){
                throw new IllegalAccessError(srcFile+"不是文件");
            }
            FileInputStream bis=new FileInputStream(srcFile);
            FileOutputStream bos=new FileOutputStream(destFile);
            int c;
            while((c=bis.read())!=-1){
                bos.write(c);
            }
            bis.close();
            bos.close();
        }
        //字节批量操作
                public static void  copyFileByArray(File srcFile,File destFile)throws Exception{
                    if(!srcFile.exists()){
                        throw new IllegalArgumentException("文件不存在！");
                    }
                    if(!srcFile.isFile()){
                        throw new IllegalAccessError(srcFile+"不是文件");
                    }
                    FileInputStream bis=new FileInputStream(srcFile);
                    FileOutputStream bos=new FileOutputStream(destFile);
                    int c;
                    byte[] ba=new byte[2024*1024];
                    while((c=bis.read(ba,0,ba.length))!=-1){
                        bos.write(ba,0,ba.length);
                    }
                    bis.close();
                    bos.close();
                }
        //字节流操作
        public static void  copyFileByData(File srcFile,File destFile)throws Exception{
            if(!srcFile.exists()){
                throw new IllegalArgumentException("文件不存在！");
            }
            if(!srcFile.isFile()){
                throw new IllegalAccessError(srcFile+"不是文件");
            }
            DataInputStream bis=new DataInputStream(
                    new FileInputStream(srcFile));
            DataOutputStream bos=new DataOutputStream(
                    new FileOutputStream(destFile));
            int c;
            while(bis.available()>0&&(c=bis.read())!=-1){
                bos.write(c);
            }
            bis.close();
            bos.close();
        }
}
import java.io.File;


public class copyTest {
    public static void main(String[] args)throws Exception {
        File demo=new File("demo");
        if(!demo.exists()){
            demo.mkdir();
        }
        
        File srcFile=new File("demo/but.wma");
        File destFile=new File("demo/c1.wma");
        File destFile1=new File("demo/c2.wma");
        File destFile2=new File("demo/c3.wma");
        File destFile3=new File("demo/c4.wma");
        long start=System.currentTimeMillis();
        CopyFile.copyFileByBuffer(srcFile, destFile);
        long end=System.currentTimeMillis();
        System.out.println("BufferedCopy用了"+(double)(end-start)/1000+"秒！");
        
        start=System.currentTimeMillis();
        CopyFile.copyFileByData(srcFile, destFile1);
        end=System.currentTimeMillis();
        System.out.println("DataCopy用了"+(double)(end-start)/1000+"秒！");
        
        start=System.currentTimeMillis();
        CopyFile.copyFileByByte(srcFile, destFile2);
        end=System.currentTimeMillis();
        System.out.println("ByteCopy用了"+(double)(end-start)/1000+"秒！");
        
        start=System.currentTimeMillis();
        CopyFile.copyFileByArray(srcFile, destFile3);
        end=System.currentTimeMillis();
        System.out.println("ArrayCopy用了"+(double)(end-start)/1000+"秒！");

    }

}
/*可以看出批量操作的复制时间最短
 * 其次是带缓冲流
 * Data流包装类和单字节读取时间最慢
 * 但也可以看出批量操作的时间比带缓冲流节约时间效果非常明显
 */

 5、字符流：一次处理一个字符，字符的底层仍然是基本的字节序列。一般操作的都是文本和文本文件。

1、InputStreamRead:完成byte流解析为char流，按照编码解析。

OutputStreamWriter：提供char流到byte流，按照编码解析。

import java.io.*;


public class IsrAndOswDemo {
    public static void main(String[] args)throws IOException {
        //先创建FileInputStream对象in，用做创建InputStreamReader类对象的构造函数的参数
        FileInputStream in=new FileInputStream("H:\\javalab\\1.txt");
        InputStreamReader isr=new InputStreamReader(in);//参数不加编码类型则采用项目默认的编码
        
        FileOutputStream out=new FileOutputStream("H:\\javalab\\2.txt");
        OutputStreamWriter osw=new OutputStreamWriter(out);
        //单字符读取写入
        int c;
        while((c=isr.read())!=-1){
            System.out.print((char)c);
            osw.write((char)c);
            osw.flush();
        }
        //批量读取，放入buff字符数组，从0开始放，最多放buff.length个字符，返回的是读到的字符个数
        /*char[] buff=new char[8*1024];
        int c;
        while((c=isr.read(buff,0,buff.length))!=-1){
            String s=new String(buff,0,c);
            System.out.println(s);
            osw.write(buff,0,c);
            osw.flush();
        }*/
        in.close();
        isr.close();
    }
}

2、FileReader/FileWriter：比InputStreamReader/OutputStreamWriter操作要方便；

可以直接对文件进行字符流构造

import java.io.*;
public class FrAndFwDemo {

    public static void main(String[] args)throws IOException {
        FileReader fr=new FileReader("H:\\javalab\\3.txt");
        FileWriter fw=new FileWriter("H:\\javalab\\4.txt",true);
        char[] buff=new char[2*1024];
        int c;
        while((c=fr.read(buff,0,buff.length))!=-1){
            String s=new String(buff,0,c);
            System.out.println(s);
            fw.write(buff,0,c);
            fw.flush();
        }
        fr.close();
        fw.close();
    }
}

3、字符流的过滤器：BufferedReader最强大的功能是readLine方法，一次读一行；

BufferedWriter/PrintWriter:写操作。

import java.io.*;
public class BrAndBwAndPwDemo {
    public static void main(String[] args)throws IOException{
        //对文件进行读写操作
        //Buffered过滤文件流构造比较方法
        BufferedReader br=new BufferedReader(
                new InputStreamReader(
                        new FileInputStream("H:\\javalab\\4.txt")));
        /*BufferedWriter bw=new BufferedWriter(
                new OutputStreamWriter(
                        new FileOutputStream("H:\\javalab\\5.txt")));
        String line;
        while((line=br.readLine())!=null){
            System.out.println(line);//一次读一行并不能识别换行
            bw.write(line);//没法单独写一行
            bw.newLine();//单独写换行操作
            bw.flush();
        }
        */
        //PrintWriter的构造比较简单
        PrintWriter pw=new PrintWriter("H:\\javalab\\5.txt");
        //PrintWriter pw1=new PrintWriter("H:\\javalab\\5.txt",true);//自动带清空缓冲区功能
        String line;
        while((line=br.readLine())!=null){
            //pw.print(line);
            pw.println(line);//换行用println()
            pw.flush();
        }
        br.close();
        pw.close();
        
        
        
    }

}