前言

在这个动不动就让你cmd，让你%temp%的时代里面，你还在用你的鼠标和cv吗？还要一个一个的去打开文件夹，cv文件吗？你low爆了，来看看不一样的我们咋搞得。

文件的传输

在我们得认知中，有多少和以前得我一样，觉得cv嗯真香，没有什么cv不了得，可是有没有想过cv鼠标难得点，尤其是，笔记本没有鼠标，用触摸板得我，很难受鸭！

  那么我们今天一起看看没有鼠标得cv文件叭。

File类一、 File类的定义

① File类主要是Java为文件这一块的操作(删除，复制，粘贴，新增)而设计的相关类。

② File类的包名是java.io，用的时候需要导包，它实现了Serializable，Comparable两大接口便于可序列化和比较。

概述

它是文件和目录路径名的抽象表示

文件和目录是可以通过File封装成对象的

对于File而言，其封装的并不是一个真正存在的文件，仅仅是一个路径名而已。它可以是存在的，也可以是不存在的。将来是要通过具体的操作把这个路径的内容转换为具体存在的

底层源码定义

public class File implements Serializable, Comparable<File>{}

1、File类的使用

上面表格中的实例不太好看，可以看看下面的代码，因为在表格中换行不太行，就直接连在一起的格式不好看。

public class FileDemo01 {    public static void main(String[] args) {        //File(String pathname)：通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例。        File f1 = new File("E:\\pier\\java.txt");        System.out.println(f1);        //File(String parent, String child)：从父路径名字符串和子路径名字符串创建新的 File实例。        File f2 = new File("E:\\pier","java.txt");        System.out.println(f2);        //File(File parent, String child)：从父抽象路径名和子路径名字符串创建新的 File实例。        File f3 = new File("E:\\pier");        File f4 = new File(f3,"java.txt");        System.out.println(f4);    }}

注意输出的是你的 File路径，不确定你的路径是否拥有。

结果

E:\pier\java.txtE:\pier\java.txtE:\pier\java.txt

这里由于上面的表格的教训我就不在后面写实例了，需要实例的自己去看后面的带代码

创建文件

创建文件代码实例

注：如果有人想要偷懒只想要一根斜线的话，可以使用 /

使用两根\的主要目的是为了防止出现和\n这类符号出现歧义的情况所采取的

 public static void main(String[] args) throws IOException {        //需求1：我要在E:\\pier目录下创建一个文件java.txt        File f1 = new File("E:\\pier\\java.txt");        System.out.println(f1.createNewFile());        System.out.println("--------");        //需求2：我要在E:\\pier目录下创建一个目录JavaSE        File f2 = new File("E:\\pier\\JavaSE");        System.out.println(f2.mkdir());        System.out.println("--------");        //需求3：我要在E:\\pier目录下创建一个多级目录JavaWEB\\HTML        File f3 = new File("E:\\pier\\JavaWEB\\HTML");//        System.out.println(f3.mkdir());        System.out.println(f3.mkdirs());        System.out.println("--------");        //需求4：我要在E:\\pier目录下创建一个文件javase.txt        File f4 = new File("E:\\pier\\javase.txt");//        System.out.println(f4.mkdir());        System.out.println(f4.createNewFile());    }

判断功能

获取功能

判断和获取代码实例

public static void main(String[] args) {        //创建一个File对象        File f = new File("myFile\\java.txt");//        public boolean isDirectory()：测试此抽象路径名表示的File是否为目录//        public boolean isFile()：测试此抽象路径名表示的File是否为文件//        public boolean exists()：测试此抽象路径名表示的File是否存在        System.out.println(f.isDirectory());        System.out.println(f.isFile());        System.out.println(f.exists());//        public String getAbsolutePath()：返回此抽象路径名的绝对路径名字符串//        public String getPath()：将此抽象路径名转换为路径名字符串//        public String getName()：返回由此抽象路径名表示的文件或目录的名称        System.out.println(f.getAbsolutePath());        System.out.println(f.getPath());        System.out.println(f.getName());        System.out.println("--------");//        public String[] list()：返回此抽象路径名表示的目录中的文件和目录的名称字符串数组//        public File[] listFiles()：返回此抽象路径名表示的目录中的文件和目录的File对象数组        File f2 = new File("E:\\pier");        String[] strArray = f2.list();        for(String str : strArray) {            System.out.println(str);        }        System.out.println("--------");        File[] fileArray = f2.listFiles();        for(File file : fileArray) {//            System.out.println(file);//            System.out.println(file.getName());            if(file.isFile()) {                System.out.println(file.getName());            }        }    }

删除

public static void main(String[] args) throws IOException {//        File f1 = new File("E:\\pier\\java.txt");        //需求1：在当前模块目录下创建java.txt文件        File f1 = new File("myFile\\java.txt");//        System.out.println(f1.createNewFile());        //需求2：删除当前模块目录下的java.txt文件        System.out.println(f1.delete());        System.out.println("--------");        //需求3：在当前模块目录下创建pier目录        File f2 = new File("myFile\\pier");//        System.out.println(f2.mkdir());        //需求4：删除当前模块目录下的pier目录        System.out.println(f2.delete());        System.out.println("--------");        //需求5：在当前模块下创建一个目录pier,然后在该目录下创建一个文件java.txt        File f3 = new File("myFile\\pier");//        System.out.println(f3.mkdir());        File f4 = new File("myFile\\pier\\java.txt");//        System.out.println(f4.createNewFile());        //需求6：删除当前模块下的目录pier        System.out.println(f4.delete());        System.out.println(f3.delete());    }

曾几何时，我们就听过IO流的大名，在各种各样的语言中听闻这个词，俗话说恋恋不忘，必有回响。今天它来了，下面我们嗯看一张图，来使用三遍读书法一探究竟这个所谓的IO流。

上图小结:不管是字符流和字节流，我们都差不多分为Input和Out两种，对应的就是输入输出流嘛，我们对于文件的操作大嘎子也就是这几种方式，一种对文件的读取，一种就是对文件的写入。

首先我们再来看一看什么叫做IO流，百度给的定义:流是一种抽象概念，它代表了数据的无结构化传递。按照流的方式进行输入输出，数据被当成无结构的字节序或字符序列。从流中取得数据的操作称为提取操作，而向流中添加数据的操作称为插入操作。用来进行输入输出操作的流就称为IO流。换句话说，IO流就是以流的方式进行输入输出。

说白了不就是你和文件的的不解之谜不就是IO流吗？

Java之中的IO流不就是Java程序和操作系统之间的通信用的方法吗？

字节流字节流抽象基类

1、InputStream：这个抽象类是表示字节输入流的所有类的超类

2、OutputStream：这个抽象类是表示字节输出流的所有类的超类

3、子类名特点：子类名称都是以其父类名作为子类名的后缀字节输出流

1、FileOutputStream(String name)：创建文件输出流以指定的名称写入文件

使用字节输出流写数据的步骤

1、创建字节输出流对象(调用系统功能创建了文件，创建字节输出流对象，让字节输出流对象指向文件)

2、调用字节输出流对象的写数据方法

3、释放资源(关闭此文件输出流并释放与此流相关联的任何系统资源)

示例代码

public static void main(String[] args) throws IOException {        //创建字节输出流对象        //FileOutputStream(String name)：创建文件输出流以指定的名称写入文件        FileOutputStream fos = new FileOutputStream("myByteStream\\fos.txt");        /*            做了三件事情：                A:调用系统功能创建了文件                B:创建了字节输出流对象                C:让字节输出流对象指向创建好的文件         */        //void write(int b)：将指定的字节写入此文件输出流        fos.write(97);        //最后都要释放资源(一定要记得释放资源)        //void close()：关闭此文件输出流并释放与此流相关联的任何系统资源。        fos.close();    }

字节流写数据的三种方式

代码实例

public static void main(String[] args) throws IOException {        //FileOutputStream(String name)：创建文件输出流以指定的名称写入文件        FileOutputStream fos = new FileOutputStream("myByteStream\\fos.txt");//            void write(int b)：将指定的字节写入此文件输出流//        fos.write(97);//        fos.write(98);//        fos.write(99);//        fos.write(100);//        fos.write(101);//            void write(byte[] b)：将 b.length字节从指定的字节数组写入此文件输出流//        byte[] bys = {97, 98, 99, 100, 101};        //byte[] getBytes()：返回字符串对应的字节数组        byte[] bys = "abcde".getBytes();//        fos.write(bys);        //void write(byte[] b, int off, int len)：将 len字节从指定的字节数组开始，从偏移量off开始写入此文件输出流//        fos.write(bys,0,bys.length);        fos.write(bys,1,3);        //释放资源        fos.close();    }

1、windows:\r\n

2、linux:\n

3、mac:\r

字节流写数据如何实现追加写入

1、public FileOutputStream(String name,boolean append)

2、创建文件输出流以指定的名称写入文件。如果第二个参数为true ，则字节将写入文件的末尾而不是开头

代码实例

    public static void main(String[] args) throws IOException {        //创建字节输出流对象//        FileOutputStream fos = new FileOutputStream("myByteStream\\fos.txt");        FileOutputStream fos = new FileOutputStream("myByteStream\\fos.txt",true);        //写数据        for (int i = 0; i < 10; i++) {            fos.write("hello".getBytes());            fos.write("\r\n".getBytes());        }        //释放资源        fos.close();    }

看完了写数据，小伙伴们有去尝试吗？我们写过数据怎么拿出来呢？

字节流读数据的两种方式

  ①一次一个字节数据

直接上代码

public static void main(String[] args) throws IOException {        //创建字节输入流对象        //FileInputStream(String name)        FileInputStream fis = new FileInputStream("myByteStream\\fos.txt");        int by;        /*            fis.read()：读数据            by=fis.read()：把读取到的数据赋值给by            by != -1：判断读取到的数据是否是-1         */        while ((by=fis.read())!=-1) {            System.out.print((char)by);        }        //释放资源        fis.close();    }

  ①一次一个字节数组

public static void main(String[] args) throws IOException {        //创建字节输入流对象        FileInputStream fis = new FileInputStream("myByteStream\\fos.txt");        /*            hello\r\n            world\r\n            第一次：hello            第二次：\r\nwor            第三次：ld\r\nr         */        byte[] bys = new byte[1024]; //1024及其整数倍        int len;        while ((len=fis.read(bys))!=-1) {            System.out.print(new String(bys,0,len));        }        //释放资源        fis.close();    }

为什么会出现字符流

字符流的介绍

由于字节流操作中文不是特别的方便，所以Java就提供字符流

字符流 = 字节流 + 编码表

中文的字节存储方式

用字节流复制文本文件时，文本文件也会有中文，但是没有问题，原因是最终底层操作会自动进行字节拼接成中文，如何识别是中文的呢？

汉字在存储的时候，无论选择哪种编码存储，第一个字节都是负数

这里提到了编码表，给大家放一个我整理的编码表详解在这里叭

字符串中的编码解码问题

注意字符流的输入输出基本上差不多，但是细微的差距基本上都是在他们所传的参数差异，可以重点注意一下。这里就不写实例了，详情可以参考上面的字节流，基本上差不多。

构造方法

写数据的五种方法

刷新和关闭

读取

文件的复制

上面的字符流和字节流大体的都搞清楚了，那么我们怎么来复制文件呢？

复制文本文件，其实就把文本文件的内容从一个文件中读取出来(数据源)，然后写入到另一个文件中(目的地)

字节流复制

public static void main(String[] args) throws IOException {        //根据数据源创建字节输入流对象        FileInputStream fis = new FileInputStream("E:\\pier\\酒家.txt");        //根据目的地创建字节输出流对象        FileOutputStream fos = new FileOutputStream("Test复制\\酒家.txt");        //两种读取方式均可，但第二种按照字节读取更快        /*//读写数据，复制文本文件(一次读取一个字节，一次写入一个字节)        int by;        while ((by=fis.read())!=-1) {            fos.write(by);        }*/        //读写数据，复制文本文件(一次读取一个字节数组)        byte[] bys = new byte[1024];        int len;        while ((len=fis.read(bys))!=-1) {            fos.write(bys,0,len);        }        //释放资源        fos.close();        fis.close();    }

字符流复制文件

字符流复制Java文件有奇效哟

public static void main(String[] args) throws IOException {        //根据数据源创建字符输入流对象        FileReader fr = new FileReader("myCharStream\\ConversionStreamDemo.java");        //根据目的地创建字符输出流对象        FileWriter fw = new FileWriter("myCharStream\\Copy.java");        //读写数据，复制文件//        int ch;//        while ((ch=fr.read())!=-1) {//            fw.write(ch);//        }        char[] chs = new char[1024];        int len;        while ((len=fr.read(chs))!=-1) {            fw.write(chs,0,len);        }        //释放资源        fw.close();        fr.close();    }

缓冲流

缓冲流又分为两种

  ①字节缓冲流

BufferOutputStream：该类实现缓冲输出流。 通过设置这样的输出流，应用程序可以向底层输出流写入字节，而不必为写入的每个字节导致底层系统的调用BufferedInputStream：创建BufferedInputStream将创建一个内部缓冲区数组。 当从流中读取或跳过字节时，内部缓冲区将根据需要从所包含的输入流中重新填充，一次很多字节

构造方法介绍

代码示例

 public static void main(String[] args) throws IOException {        //字节缓冲输出流：BufferedOutputStream(OutputStream out)         BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("myByteStream\\bos.txt"));        //写数据        bos.write("hello\r\n".getBytes());        bos.write("world\r\n".getBytes());        //释放资源        bos.close();            //字节缓冲输入流：BufferedInputStream(InputStream in)        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("myByteStream\\bos.txt"));        //一次读取一个字节数据//        int by;//        while ((by=bis.read())!=-1) {//            System.out.print((char)by);//        }        //一次读取一个字节数组数据        byte[] bys = new byte[1024];        int len;        while ((len=bis.read(bys))!=-1) {            System.out.print(new String(bys,0,len));        }        //释放资源        bis.close();    }

②字符缓冲流

BufferedWriter：将文本写入字符输出流，缓冲字符，以提供单个字符，数组和字符串的高效写入，可以指定缓冲区大小，或者可以接受默认大小。默认值足够大，可用于大多数用途BufferedReader：从字符输入流读取文本，缓冲字符，以提供字符，数组和行的高效读取，可以指定缓冲区大小，或者可以使用默认大小。 默认值足够大，可用于大多数用途

字符缓冲流构造方法

字符缓冲流特有功能

代码实例

public static void main(String[] args) throws IOException {        //根据数据源创建字符缓冲输入流对象        BufferedReader br = new BufferedReader(new FileReader("myCharStream\\ConversionStreamDemo.java"));        //根据目的地创建字符缓冲输出流对象        BufferedWriter bw = new BufferedWriter(new FileWriter("myCharStream\\Copy.java"));        //读写数据，复制文件        //使用字符缓冲流特有功能实现        String line;        while ((line=br.readLine())!=null) {            bw.write(line);            bw.newLine();            bw.flush();        }        //释放资源        bw.close();        br.close();    }

InputStream类是一个抽象类 ,是所有字节输入流类的父类。

OutputStream类是一个抽象类，是所有字节输出流的父类

InputStream的常见子类有：

FileInputStream:看这个名字就知道用于从文件中读取信息。

ByteArrayInputStream: 字节数组输入流,

ObjectInputStream：序列化时使用 一般和ObjectOutputStream一起使用

FilterInputStream: 过滤输入流,为基础的输入流提供一些额外的操作。

OutputStream的常见子类有：

FileOutPutStream: 文件输出流对文件进行操作

ByteArrayOutputStream: 字节数组输出流

ObjectOutputStream: 序列化时使用 一般和OjbectInputStream一起使用

FilterOutputStream:过滤输出流,为基础的输出流提供一些额外的操作。

看字节流和字符流的输入输出

现在你觉得自己学的怎么样呀，要是觉得自己学的还可以，可以尝试着去自己做个点名器了呀

结果类似这样