一，File类

File类位于java.io包下，用来表示文件（目录）。

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

1，File的基本操作

 

package com.amazing.jdk.learn2IO_0821.FileAPI;import java.io.File;import java.io.IOException;/** * Created by yaming on 17-8-21. */public class FileDemo {    public static void main(String[] args) {        //window,linux系统文件分割符不同，可以使用File.separator设置分隔符。适用window和linux        File fileSeparator=new File("e:"+File.separator+"javaio"+File.separator+"test");        /**         * 1,操作目录         */        File file=new File("/home/yaming/Desktop/filedemo");        //查看目录是否存在,不存在就创建        System.out.println(file.exists());        if(!file.exists())            file.mkdir();        else            file.delete();        //判断是否是一个目录,如果是目录返回true.如果不是目录或目录不存在，返回false        boolean flag1 = file.isDirectory();        //判断是否是一个文件        boolean flag2 = file.isFile();        /**         * 操作文件         */        //判断文件是否存在        File file2=new File("/home/yaming/Desktop/日记.txt");        //不存在就创建文件        if (!file2.exists()){            try {                file2.createNewFile();            } catch (IOException e) {                e.printStackTrace();            }        }else {            file2.delete();        }        /**         * 常用File对象的API         */        //打印file，打印的是file.toString()的内容        System.out.println(file);        //目录绝对路径        System.out.println(file.getAbsoluteFile());        //打印目录最后一级的名字        System.out.println(file.getName());        //打印文件名字        System.out.println(file2.getName());        //访问父目录,目录路径        String parentPath = file.getParent();    }}

2，File类常用操作

遍历目录：

package com.amazing.jdk.learn2IO_0821.FileAPI;import java.io.File;import java.io.IOException;/** * Created by yaming on 19-5-4. */public class FileUtils {    /**     * 列出指定目录下（包括子目录）的所有文件     * @param dir     * @throws IOException     */    public static void listDirectory(File dir)throws IOException{        if(!dir.exists()){            throw new IllegalArgumentException("目录不存在");        }        if (!dir.isDirectory()){            throw new IllegalArgumentException(dir+"不是目录");        }        File[] files = dir.listFiles();//返回的是直接子目录（文件）的抽象        if (files != null && files.length >0){            for (File file : files){                if (file.isDirectory()){                    //递归                    listDirectory(file);                }else {                    System.out.println(file);                }            }        }    }}

 

二，RandomAccessFile类的使用

java提供的对文件内容的访问，既可以读文件，也可以写文件。

RandomAccessFile支持随机访问文件，可以访问文件的任意位置

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() ----> 读一个字节

5，文件读写完成后一定要关闭

6，代码：

package com.amazing.jdk.learn2IO_0821.FileAPI;import java.io.File;import java.io.IOException;import java.io.RandomAccessFile;import java.util.Arrays;/** * Created by yaming on 19-5-4. */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");        //指针的位置        System.out.println(raf.getFilePointer());                raf.write('A');//只写了一个字节        System.out.println(raf.getFilePointer());                raf.write('B');                        int i = 0x7fffffff;//这是最大的整数        //写一个Int值，用write方法每次只能写一个字节，如果要把i写进去就得写4次        raf.write(i >>> 24);//高8位        raf.write(i >>> 14);//高8位        raf.write(i >>> 8);//高8位        raf.write(i);//最低8位        System.out.println(raf.getFilePointer()); //打印：6                        //可以直接写一个int        raf.writeInt(i);                        //写中文        String s = "中";        byte[] gbk = s.getBytes("gbk");        //转成gbk，一个汉字两个字节        raf.write(gbk);        System.out.println(raf.length());//打印：12        /**         * 读文件         *          */        //1,必须把指针移动到头部        raf.seek(0);        //一次性读取，把文件中的内容都读取到字节数组中        byte[] buf = new byte[(int) raf.length()];        raf.read(buf);        System.out.println(Arrays.toString(buf));            }}

 三，字节流

1，文件输入流

1.1，InputStream,OutputStream

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

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

1.2，EOF = end 读到-1就读到结尾

1.3，输入流基本方法

我们把键盘作为一个文件，键盘是输入，比如往记事本里写数据。实际上是从键盘文件读取了数据，然后写入到了txt文件。

所以键盘是一个输入文件，是用来读的。我们从键盘上读的东西，写到了文本文件里。所以输入流的基本方法是读

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

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

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

1.4,输出流基本方法

out.write(int b);写出一个byte到流，b的低8位。

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

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

1.5，FileInputStream --->具体实现了在文件上读取数据

代码：

 

package com.amazing.jdk.learn2IO_0821.stream;import java.io.*;/** * Created by yaming on 17-8-21. * 工具类 */public class IOUtils {    /**     *需求：读取指定文件内容,按照16进制输出到控制台     * 并且每输出10个byte换行。读到最后一个     */    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){                //单位的数补零                System.out.print("0");            }            //将整形b转换成16进制表示的字符串            System.out.print(Integer.toHexString(b)+" ");            if(i++%10==0){                //换行                System.out.println();            }        }        //IO操作后必须关闭        in.close();    }}

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

 拷贝文件代码：

package com.amazing.jdk.learn2IO_0821.stream;import java.io.*;/** * Created by yaming on 17-8-21. * 工具类 */public class IOUtils {    /**     * 文件拷贝,字节批量读取     * 拷贝速度最快     * 复制文件功能，一个是读操作，另一个是写操作     * @param srcFile     * @param destFile     */    public static void copyFile(File srcFile,File destFile)throws IOException{        //文件不存在        if(!srcFile.exists()){            throw new IllegalArgumentException("文件"+srcFile+"不存在");        }        if(!destFile.exists()){            throw new IllegalArgumentException(destFile+"不是文件");        }        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();    }       /**     * 文件拷贝,单字节不带缓冲     * 拷贝速度最慢     * @param srcFile     * @param destFile     */    public static void copyFileByByte(File srcFile,File destFile)throws IOException{        //文件不存在        if(!srcFile.exists()){            throw new IllegalArgumentException("文件"+srcFile+"不存在");        }        if(!destFile.exists()){            throw new IllegalArgumentException(destFile+"不是文件");        }        FileInputStream fis=new FileInputStream(srcFile);        FileOutputStream fos=new FileOutputStream(destFile);        int d;        while ((d=fis.read())!=-1){            fos.write(d);            fos.flush();//也可以不刷新        }        fis.close();        fos.close();    }}

 

1.7，DataOutputStream / DataInputStream

对 流 功能的扩展，可以更加方便的读取int ,long,字符等类型数据

比如：writeInt() / writeDouble / writeUTF()

示例代码：

 

package com.amazing.jdk.learn2IO_0821.stream;import java.io.*;/** * Created by yaming on 17-8-22. */public class DataStream {    public static void main(String[] args)throws IOException {        String file="/home/yaming/Desktop/test";        DataOutputStream dos=new DataOutputStream(new FileOutputStream(file));        dos.writeInt(10);        dos.writeInt(-10);//对write方法进行了包装        dos.writeDouble(1.7);        //采用utf-8编码写出        dos.writeUTF("中国");        //utf-16be编码        dos.writeChars("中国");        dos.close();        IOUtils.printHex(file);        System.out.println();        DataInputStream dis=new DataInputStream(new FileInputStream(file));        int i=dis.readInt();//对read方法进行了包装        System.out.println(i);        i=dis.readInt();        System.out.println(i);        double d=dis.readDouble();        System.out.println(d);        String s=dis.readUTF();        System.out.println(s);        dis.close();    }}

 

 

 

 1.7，BufferedInputStream / BufferedOutputStream

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

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

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

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

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

代码：

package com.amazing.jdk.learn2IO_0821.stream;import java.io.*;/** * Created by yaming on 17-8-21. * 工具类 */public class IOUtils {    /**     * 文件拷贝,利用带缓冲的字节流     * 复制文件功能,使用buffer缓冲区     * @param srcFile     * @param destFile     */    public static void copyFileByBuffer(File srcFile,File destFile)throws IOException{        //文件不存在        if(!srcFile.exists()){            throw new IllegalArgumentException("文件"+srcFile+"不存在");        }        if(!destFile.exists()){            throw new IllegalArgumentException(destFile+"不是文件");        }        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();    }}

 四，字符流

1，认知文本和文本文件

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

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

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

2，字符流（Reader, Writer）

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

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

3，字符流的基本实现

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

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

package com.amazing.jdk.learn2IO_0821.stream;import java.io.FileInputStream;import java.io.IOException;import java.io.InputStreamReader;/** * Created by yaming on 17-8-23. */public class IsrAndOswDemo {    public static void main(String[] args)throws IOException {        FileInputStream fis=new FileInputStream("/home/yaming/Desktop/今天");        //操作文本文件，操作一个mp3文件就没有意义了        InputStreamReader isr=new InputStreamReader(fis);//默认使用项目的编码.操作的时候要写文件默认的编码，这样读出来才不会乱码        //一次读一个字符        /*        int c;        while ((c=isr.readme())!=-1){            System.out.print((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.print(s);        }    }}

 4，FileReader / FileWriter

package com.amazing.jdk.learn2IO_0821.stream;import java.io.FileReader;import java.io.FileWriter;import java.io.IOException;/** * Created by yaming on 17-8-24. */public class ReaderWriter {    public static void main(String[] args)throws IOException {        /**         * 字符流         */        Long time1=System.currentTimeMillis();        FileReader fr=new FileReader("/home/yaming/Desktop/txt1");        FileWriter fw=new FileWriter("/home/yaming/Desktop/txt2");        /*char[] buffer=new char[1024];        int c;        while ((c=fr.readme(buffer,0,buffer.length))!=-1){            fw.write(buffer,0,c);            fw.flush();        }        //8毫秒        */        int a;        while ((a=fr.read())!=-1){            System.out.print(a);            fw.write(a);            fw.flush();        }        //93毫秒                fr.close();        fw.close();        Long time2=System.currentTimeMillis();        System.out.println("readme()时长:"+(time2-time1));    }}

5,字符流的过滤器

BufferedReader  ---->readLine  一次读一行

BufferedWriter/PrintWriter   ----->一次写一行

package com.amazing.jdk.learn2IO_0821.stream;import java.io.*;/** * Created by yaming on 17-8-24. */public class BufferedReaderWriter {    public static void main(String[] args)throws IOException {        /**         * 字符缓冲流         */        BufferedReader br=new BufferedReader(                new InputStreamReader(                        new FileInputStream("/home/yaming/Desktop/test")));        /*BufferedWriter bw=new BufferedWriter(                new OutputStreamWriter(                        new FileOutputStream("/home/yaming/Desktop/test2")                )        );*/        PrintWriter pw=new PrintWriter("/home/yaming/Desktop/test2");//可以用来替换BufferedWriter,比较简单        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();    }}