I/O流

java.io.File

构造方法

比如File f=new File("C:\Users\Administrator\Desktop\readme.txt");new一个file对象，只是说存在这个路径名，但是名字存在文件存不存在就不知道了，就像自己随便想一个人名，他存不存在还不知道，反正名字只是代表几个汉字而已。

方法

boolean createNewFile()

创建文件，这个就是实实在在的根据自己定义的文件路径名创建一个文件，能在计算机中找到的，在世界上存在的文件。

boolean mkdir()

创建文件夹，也就是经过这个方法，你new的名字是为了文件夹而准备的，上面的是为了文件而准备的。

boolean  mkdirs()

如果要想创建的文件夹里面还有一个文件夹，那么在你的文件路径名正确的前提下（即你new的file符合规则)会为你创建多级文件夹

boolean renameTo(File dest)

将一个file对象重命名为另一个file对象（重命名的操作具体是怎么进行的）

boolean delete()

删除文件或者文件夹（文件夹里面必须是空的[没什么用]）

boolean isDirectory()

判断file对象是否是一个文件夹

boolean isFile()

判断是否是一个文件

boolean canRead()

是否可读

boolean setReadable(boolean readable)

设置是否可读

boolean canWrite()

是否可写

boolean setWritable(boolean writable)

设置是否可写

String getAbsolutePath()

获取绝对路径

String getName()

获取最后一个后面的文件名

String getPath()

获取你new的时候构造方法里面的字符串

long length()

获取文件内容的长度

String[]  list()

获取指定目录下的文件名

File[] listFiles()

获取指定目录下的文件对象

String[] list(FilenameFilter filter)

将指定目录下的文件名进行过滤后显示

IO流

输出流的清空重写问题

import java.io.File;

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

public class Test2 {

    public static void main(String[] args) throws IOException {
        // TODO Auto-generated method stub
        File f=new File("readme1.txt");
        FileOutputStream fos=new FileOutputStream(f);
        fos.write(98);
        fos.write(98);
        fos.close();

    }

}

对一个文件写入一个内容，当我们重复按运行按钮时，会发现文件内容并没有增加，像只是运行过一次一样。原因是我们new出输出流时，它会对我们的文件进行清空处理。

如果我们不想对它进行清空，则new另外的构造方法

import java.io.File;

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

public class Test2 {

    public static void main(String[] args) throws IOException {
        // TODO Auto-generated method stub
        File f=new File("readme1.txt");
        FileOutputStream fos=new FileOutputStream(f,true);
        fos.write(98);
        fos.write(98);
        fos.close();

    }

}

 拷贝问题

拷贝文件我们首先想到的是我们要建立一个文件，然后往里面输内容

FileOutputStream fos=new FileOutputStream("a.jpg");

当写时，我们会发现我们需要输入写的内容（int类型），我们想输入另一个文件的内容，即copy，手动copy不是一个很好的办法（而且你也不知道输入什么）

fos.write(b);

所以我们先将我们想要的copy的文件读入我们的内存，转换成int类型

FileInputStream fis=new FileInputStream("C:\Users\Administrator\Pictures\电脑桌面1.jpg");

fis.read();

这样我们就可以处理copy的内容写入我们创建的新文件中

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

public class Copy {
    public static void main(String [] agrs) throws IOException{
        FileInputStream fis=new FileInputStream("C:\Users\Administrator\Pictures\电脑桌面1.jpg");
        
        FileOutputStream fos=new FileOutputStream("a.jpg");
        
        int b;
        while((b=fis.read())!=-1)
        fos.write(b);
        fis.close();
        fos.close();
    }

}

读写的效率问题

一次性读，一次性写

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

public class Copy {
    public static void main(String [] agrs) throws IOException{
        FileInputStream fis=new FileInputStream("C:\Users\Administrator\Pictures\电脑桌面1.jpg");
        
        FileOutputStream fos=new FileOutputStream("a.jpg");
        
        //int b;
        //while((b=fis.read())!=-1)
        //fos.write(b);
        byte a[]=new byte[fis.available()];
        fis.read(a);
        fos.write(a);
        fis.close();
        fos.close();
    }

}

int read(byte[] b)

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

public class Copy {
    public static void main(String [] agrs) throws IOException{

        FileInputStream fis=new FileInputStream("readme1.txt");
        FileOutputStream fos=new FileOutputStream("readme2.txt");
        byte a[]=new byte[2];
        System.out.println(fis.read(a));
        for(byte s:a)
            System.out.print(s+" ");
        
        System.out.println(fis.read(a));
        for(byte s:a)
            System.out.print(s+" ");
        fis.close();
        fos.close();
    }

}
//结果

//2
//97 98 2
//99 100

文件里面的内容是abcd，但是数组的大小是两个byte，你会一次读两个byte，总共读两次，它们共用一个数组，当数组长度不够时，会从索引为0开始，修改数组的值。

当我们进行拷贝时就会因为这个（输入流）出现错误，会多拷贝一些字节。所以我们在写的时候可以按照读的时候读的长度来截取我们所要写的内容

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

public class Copy {
    public static void main(String [] agrs) throws IOException{

    FileInputStream fis=new FileInputStream("readme1.txt");
    FileOutputStream fos=new FileOutputStream("readme2.txt");
    byte a[]=new byte[2];
    int len;
    while((len=fis.read(a))!=-1)
            fos.write(a,0,len);  //核心
        fis.close();
        fos.close();
    }

}

BufferedInputStream和BufferedOutputStream

用的时候跟FileInputStream和FileOutputStream一样，但是就是要快。操作一样，但是相同的东西味道却变了。

FileInputStream fis=new FileInputStream("readme1.txt");
BufferedInputStream bi=new  BufferedInputStream(fis);
//当我们new缓冲输入流时，文件已经被读到内存中的数组a中

FileOutputStream fos=new FileOutputStream("readme2.txt");
        BufferedOutputStream  bo=new BufferedOutputStream(fos);
//当我们new缓冲输出流时，内存已经准备好了存储数据的数组b

在内存中这两个数组之间的数据传递可以用变量m来一个一个地赋值，于是这个变量的环境就跟FileInputStream和FileOutputStream上的变量环境不一样了。缓冲的变量m是连接两个内存，而FileInputStream和FileOutputStream中的变量是连接两个硬盘。通过缓冲流，我们面对的就是内存与内存之间的数据转换了。

中文问题

字节流读中文的问题

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

public class Test4 {
    public static void main(String[] args) throws IOException{
        FileInputStream fis=new FileInputStream("readme1.txt");
        byte a[]=new byte[2];
        int len;
        while((len=fis.read(a))!=-1)
            
            System.out.print(new String(a,0,len));
        

    }

}

一个中文等于两个字节，所以我们读取的字节数必须是2的倍数。但是碰到中文中有其他字符，那么这种规律也被打破了。

 字符流

java.io.FileReader

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class Test1 {
    public static void main(String[] agrs) throws IOException {
        FileReader fr=new FileReader("readme1.txt");
        int len;
        while((len=fr.read())!=-1)
            System.out.print((char)len);
        
    }

}

java.io.FileWriter

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

public class Test2 {
    public static void main(String[] agrs) throws IOException{
        FileWriter fw=new FileWriter("readme1.txt");
        fw.write("我的名字");
        fw.close();
        
        
    }
    

}

拷贝

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

public class Test3 {
    public static void main(String[] agrs) throws IOException{
        FileReader fr=new FileReader("readme1.txt");
        FileWriter fw=new FileWriter("readme2.txt");
        int c;
        while((c=fr.read())!=-1)
            fw.write(c);
        fr.close();
        fw.close();
    }

}

自定义数组

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

public class Test3 {
    public static void main(String[] agrs) throws IOException{

    FileReader fr=new FileReader("readme1.txt");
    FileWriter fw=new FileWriter("readme3.txt");
        char[] a =new char[1024];
        int len;
        while((len=fr.read(a))!=-1)
        fw.write(a,0,len);
    fr.close();
    fw.close();
    }

}

缓冲流

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

public class Test4 {
    public static void main(String[] agrs) throws IOException{
        BufferedReader br=new BufferedReader(new FileReader("readme1.txt"));
        BufferedWriter bw=new BufferedWriter(new FileWriter("readme4.txt"));
        int c;
        while((c=br.read())!=-1)
            bw.write(c);
        br.close();
        bw.close();
    }

}

String readLine()

与缓冲流read方法的区别就是它的效率更高，它是一行一行地读。能将每行的格式显示出来。

void newLine()

将有行格式的字符写入文件，能换行。

 将文本反转拷贝

我们自己尝试一下，发现我们根本没有办法读的时候从最后一行读起。换种思想，怎么让开始读的数据，最后写入文件，这就用到我们程序员的工具（栈）或者让数据先存储在集合中，然后写的时候反方向遍历。这就是我们数据结构的事情了，跟读和写的功能无关。

java.io.LineNumberReader

看它具有代表性的方法，int getLineNumber()；void setLineNumber。它的父类是BufferedReader

java.io.InputStreamReader

构造方法  InputStreamReader(InputStream in, String charsetName) ，将字节流按照某个码表读取字符，防止出现读中文的时候出现乱码。写也是一样的，看API即可

获取文本上字符出现的次数

我们使用的io流只能读和写，这些统计功能需要让程序员用自己的工具去判断，那么程序员的工具是什么呢？数据结构（集合）