黑马程序员——Java基础--IO流(一)---File类以及其他流对象

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

一、File类

　　File类是将文件系统中的文件和文件夹封装成了对象。提供了更多的属性和行为可以对这些文件和文件夹进行操作。这些是流对象办不到的，因为流只操作数据。File对象可以作为参数传递给流对象的构造函数。File 类的实例是不可变的；也就是说，一旦创建，File 对象表示的抽象路径名将永不改变。 

1、File类中的方法

(1)、File类的构造方法以及字段

new   File(String pathname);//通过给定路径名创建一个File对象
new   File(String parent, String child);//通过父目录和文件名创建File对象
new    File(File parent,Stirng child);//通过把文件目录路径封装对象和文件名创建File对象
String  separator:表示目录分隔符，可以跨平台使用。在 UNIX 系统上，此字段的值为 '/'；在 Microsoft Windows 系统上，它为 '\'。

创建File文件对象的三种方式： 

import java.io.*;
class FileDemo 
{
    public static void main(String[] args) 
    {
        //可以将一个已存在的，或者不存在的文件或者目录封装成file对象
        File file=null;
        try
        {
            ////创建File对象方式一:直接指定字符串路径名
            file=new File("E:\Demo.txt");

            //创建File对象方式二：将目录和文件名封装成字符串，传参进去
            String parent="E:\";
            String child="Demo.txt";
            file=new File(parent,child);

            //创建File对象方式三：将目录封装成文件对象和文件名创建对象。这种方式更加灵活，降低了文件于父目录的关联性
            File parent=new File("D:\");
            String child="Demo.txt";
            file=new File(parent,child);

        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
    }
}

 (2)、File类的成员方法

1.创建

boolean    createNewFile();//在指定位置上创建文件，如果该文件已经存在，则不创建，返回false。该方法和输出流不一样，输出流对象一建立就创建文件，而且文件已经存在会覆盖。
boolean    mkdir();//创建文件夹，只能一级
boolean    mkdirs()//创建多级文件夹文件夹

 2.删除

boolean    delete();//删除文件目录或者文件，如果删除失败返回false。如果文件正字被使用，则删除不了，返回false。
void    deleteOnExit();//在程序退出时删除指定文件

 注意:在删除文件夹时，必须保证这个文件夹中没有任何内容，才可以将该文件夹用delete删除。

　　Window的删除动作是从里往外删的。而java删除文件不走回收站，要谨慎操作。

3.判断

boolean    canExecute();//判断文件是否是可执行文件
boolean    exists();//判断文件是否存在
boolean    isFile();//判断是否是文件
boolean    isDirectory();//判断是否是目录
boolean    isHidden();//判断是否是隐藏文件
boolean    isAbsolute();//判断是否是绝对路径

 注意：在判断文件对象是否是文件或者目录时，必须要先判断该文件对象封装的内容是否存在。通过exists判断。

4.获取信息

String    getName();//获取文件名称
String    getPath();//获取文件相对路径
String    getParent();  //获取文件父目录。返回的是绝对路径中的父目录。如果获取的是相对路径，返回null。如果相对路径中有上一层目录，那么该目录就是返回结果。
String    getAbsolutePath();//获取文件绝对路径
Long    lastModified();//获取最后一次文件修改时间
Long    length();//获取文件大小
File[]    listRoots();//获取全部系统根目录也就是盘符
Stirng[]    list();//获取指定目录下的文件以及文件夹的名称，包含隐藏文件。调用list方法的File对象中封装的必须是目录，否则会产生NullPointerException，如果访问的是系统级目录也会发生空指针异常，如果　　　　　　　　　　　　　目录存在但是没有内容，会返回一个数组，但是长度为0

String[]    list(FilenameFilter filter);//获取指定目录中满足指定过滤器的文件和目录。其中FilenameFilter是个接口，里面有个方法boolean  accept(File dir, String  name)，返回的是：当且仅当该名　　　　　　　　　　　　　　　　　　　　　　　　　　称应该包含在文件列表中时2返回true，否则返回false。

File[]    listFiles()//获取指定目录下的文件以及文件夹的对象，有了对象就可以操作更多的方法，而list方法只能获取当前目录下的文件和文件夹的名称，这是两者最大的不同之处。同时，list()方法返回的是没有完整路径只有文件名(相对路径名)，而listFiles()方法返回的是所有完整路径的的文件名(绝对路径)。System.out.println(File)时，会调用File的toString方法，而File的toString方法会返回getPath()取得的字符串路径。

13 File[]　　listFiles(FilenameFilter filter);//返回抽象路径名数组，这些路径名表示此抽象路径名表示的目录中满足指定过滤器的文件和目录

 5.重命名

boolean    renameTo(File dest);//重命名此文件名

 代码演示：

import java.io.*;
class FileDemo 
{
    public static void main(String[] args) throws Exception
    {
        create();
        is();
        get();
        method();
        method_1();
    }
    public static void create()throws Exception{
        File parent=new File("E:\");
        File file=new File(parent,"黑马.txt");
        if(!file.exists())
            sop("文件是否创建成功："+file.createNewFile());//指定的位置上创建了一个文件
        File dir=new File(parent,"黑马\安卓\JAVA\JVAVAEE\IOS\PHP");
        sop("路径是否创建成功"+dir.mkdirs());//创建多级目录,如果创建一级目录用mkdir就可以
        sop("路径是否被删除"+dir.delete());//多级目录被删除的是最里面的那个目录，PHP文件夹被删除了

    }
    public static void is()throws Exception{
        File file=new File("E:\HelloJava.txt");
        sop("是否存在："+file.exists());
        if(!file.exists())
            file.createNewFile();//指定的位置上创建了一个文件
        sop("是否是可执行："+file.canExecute());        
        sop("是否是文件："+file.isFile());
        sop("是否是路径："+file.isDirectory());
        sop("是否隐藏："+file.isHidden());
        sop("是否是绝对路径:"+file.isAbsolute());
        //上面的判断返回的都是false，因为判断的file对象根本就不存在，
        //所以切记在判断是否是文件还是目录的时候一定要先判断该文件对象封装的内容是否存在。
    }
    public static void get()throws Exception{
        File file=new File("E:\黑马\安卓\java.txt");
        sop("文件大小："+file.length());
        sop("文件名称："+file.getName());
        sop("文件相对路径："+file.getPath());//该方法返回的是绝对路径中的父目录。
        //如果获取的是相对路径，返回null。如果相对路径中有上一层目录那么该目录就是返回结果。
        sop("文件父目录："+file.getParent());
        sop("文件绝对路径："+file.getAbsolutePath());
        sop("文件最后一次修改时间："+file.lastModified());
    }
    public static void method()throws Exception{
        File file=new File("D:\Demo.java");
        File[] dir=file.listRoots();//获取盘符
        for(File f:dir){
            sop(f);
        }
        file=new File("D:\");//必须是路径
        String[] s=file.list();//获取路径下的所有文件名，包括隐藏文件,相对路径文件名
        for(String f:s){
            sop(f);
        }

        File[] f=file.listFiles();//获取路径下的所有文件名，包括隐藏文件,绝对路径文件名
        for(File name:f){
            sop(name);//name.getName()和list获取的信息一样，都是相对路径
        }

    }
    public static void method_1()throws Exception{
        File file=new File("D:\");//获取D盘目录下后缀名为.java的文件。
        String[] dir=file.list(new FilenameFilter(){
            public boolean accept(File dir,String name){//匿名内部类,覆盖了accept方法
                return name.endsWith(".java");
            }
        });
        for(String name:dir){
            sop(name);    
        }
    }
    public static void rename()throws Exception{
        //下面的语句可以重新命名文件名
        File f1 = new File("c:\Test.java");
        File f2 = new File("d:\hahah.java");
        sop("rename:"+f1.renameTo(f2));//这种情况有点像剪切文件一样。把f1的文件剪切到了f2目录下。

    }
    public static void sop(Object obj){
        System.out.println(obj);
    }
}

 需求：获取D盘目录下后缀名为.java的文件。

import java.io.*;
class MyFilenameFilter implements FilenameFilter
{
    private String suffix;
    MyFilenameFilter(String suffix){        
        this.suffix=suffix;
    }
    public boolean accept(File dir,String name){//复写accept方法
        return name.endsWith(suffix);
    }
}
class MyFilenameFilterDemo
{
    public static void main(String[] args)throws Exception 
    {
        File file=new File("D:");
        String[] dir=file.list(new MyFilenameFilter(".txt"));//只需要往这里传值就可以了。
        for(String name:dir){
            System.out.println(name);
        }
    }
}

需求：获取D盘目录下的隐藏文件。

import java.io.*;
class HiddenFile
{
    public static void main(String[] args) throws Exception
    {
        File file=new File("C:");
        File[] dir=file.listFiles(new FilenameFilter(){
            public boolean accept(File dir,String name){
                return dir.isHidden();
            }
        });
        for(File name:dir){
            System.out.println(name);
        }
    }
}

 2、递归

递归就是：函数自身调用自身。

什么时候用递归呢？

当一个功能被重复使用，而每一次使用该功能时的参数不确定，都由上次的功能元素结果来确定。

简单说：功能内部又用到该功能，但是传递的参数值不确定。(每次功能参与运算的未知内容不确定)。

递归的注意事项：

1：一定要定义递归的条件。

2：递归的次数不要过多。容易出现 StackOverflowError 栈内存溢出错误。

其实递归就是在栈内存中不断的加载同一个函数。

需求：对指定目录进行所有内容的列出（包含子目录中的内容）

import java.io.*;
class FileListDemo 
{
    public static void main(String[] args)throws Exception 
    {
        File file=new File("D:\mystudy\java");
        show(file);
    }
    public static void show(File file){
        System.out.println("........"+file);
        //获取指定目录下当前的所有文件夹或者文件对象
        File[] name=file.listFiles();
        for(File dir:name){
            if(dir.isDirectory())//如果是文件夹在进去递归遍历
                show(dir);
            else
                System.out.println(dir);
        }
    }
}

需求：利用递归求6的二进制值。

public class Demo{
       public static void main(String[] args){
            toBin(6);
      }

       public static void toBin(int num){
             if(num > 0){
                  toBin(num/2);
                  System.out.print(num%2);
            }
      }
}

需求：利用递归求1到10的和。

public class Demo{
       public static void main(String[] args){
             int sum = getSum(10);
            System.out.println(sum);
      }

       public static int getSum(int num){
             if(num == 1)
                   return 1;
             return num + getSum(num - 1);
      }
}

需求：删除一个带内容的目录。 

import java.io.*;
class DeleteFile 
{
    public static void main(String[] args) throws Exception
    {
        File file=new File("E:\javatest");
        removeDir(file);
    }
    public static void removeDir(File file){
        File[] dir=file.listFiles();
        for(File name:dir){
            if(name.isDirectory()){//判断是否是路径，如果是进入递归的遍历
                removeDir(name);                
            }
            else
                System.out.println(name+"... "+name.delete());            
        }
        System.out.println(file+"::"+file.delete());//最后把文件夹删掉
    }
}

需求：将一个指定目录下的java文件的绝对路径，存储到一个文本文件中。建立一个java文件列表文件。 

思路：

1，对指定的目录进行递归。

2，获取递归过程所以的java文件的路径。

3，将这些路径存储到集合中。

4，将集合中的数据写入到一个文件中。

import java.io.*;
import java.util.*;
class JavaFileList
{
    public static void main(String[] args) throws Exception
    {
        File file=new File("E:\javatest");
        List<File> list=new ArrayList<File>();
        fileToList(file,list);
        listToFile(list);
    }
    //把符合条件的目录存放到List集合中
    public static void fileToList(File dir,List<File> list){
        File[] file=dir.listFiles();
        for(File name:file){
            if(name.isDirectory())
                fileToList(name,list);
            else{
                if(name.getName().endsWith(".java"))//文件名为.java的添加进集合中
                    list.add(name);
            }
        }
    }

    //集合中存放的数据写到指定文件内
    public static void listToFile(List<File> list)throws IOException{
        BufferedWriter bfw=new BufferedWriter(new FileWriter("E:\黑马.txt"));
        for(File name:list){
            bfw.write(name.getAbsolutePath());//获取文件的绝对路径名
            bfw.newLine();
            bfw.flush();
        }
        bfw.close();
    }
}

 需求：将指定目录下所有.java文件拷贝到另一个目的中，并将扩展名改为.txt 

//编写程序，将指定目录下所有.java文件拷贝到另一个目的中，并将扩展名改为.txt
import java.io.*;
class  CopyFile
{
    public static void main(String[] args)throws Exception 
    {
        FileInputStream fis=null;
        FileOutputStream fos=null;
        File src=new File("E:\javatest\12");
        File des=new File("E:\安卓");
        if(!des.exists())
            des.mkdir();
        String[] dir=src.list(new FilenameFilter(){
            public boolean accept(File dir,String name){
                return name.endsWith(".java");
            }
        });

        for(String name:dir){
            System.out.println(name);
            fis=new FileInputStream(new File(src,name));
            fos=new FileOutputStream(new File(des,name.replace(".java",".txt")));
            int len=0;
            byte[] buf=new byte[1024];
            while ((len=fis.read(buf))!=-1)
            {
                fos.write(buf,0,len);
            }
        }
        fis.close();
        fos.close();
    }    
}

二、Properties类

继承体系：

Map集合

　　|--Hashtable

　　　　|--Properties

用于属性配置文件，键和值都是字符串类型。

Properties值Hashtable的子类。也就是说它具备map集合的特点。而且它里面存储的键值对都是字符串，没有泛型定义。是集合中和IO技术相结合的结合容器。该对象的特点就是：可以用于键值对形式的配置文件。那么在加载数据时需要数据有固定格式：键=值。

特点：1：可以持久化存储数据。2：键值都是字符串。3：一般用于配置文件。

1、Properties类中常用方法

(1)、设置键和值。相当与Map集合中的put方法

Object    setProperty(String key,String value);//添加元素

 (2)、获取

String    getProperty(String key);//根据键获取值
Set<String>    stringPropertyNames();//返回属性列表键集，存入Set集合

 (3)、加载和存入流

void    load(InputStream in);//将字节读取流中的数据加载进集合中
void    load(Reader reader);//JDK1.6才有,将字符读取流加载进集合
void    store(OutputStream out,String comments);//将属性列表（键值对）写入输出流。comments属性列表的描述。可以不写。
void    store(Writer writer,String comments);//JDK1.6才有。对应load(Reader)将属性列表（键值对）写入输出流。comments属性列表的描述。
void    list(PrintStream out);//将属性输出到输出流中
void    list(PrintWriter);//将属性输出到输出流中

 代码演示：

import java.util.*;
import java.io.*;
class PropertiesDemo
{
    public static void main(String[] args)throws Exception 
    {
        Properties pro=new Properties();
        pro.setProperty("6","小明");
        pro.setProperty("2","老王");
        pro.setProperty("3","赵四");
        pro.setProperty("5","黑马");
        method_1(pro);
        method_2();
        method_3();
    }
    public static void method_1(Properties pro){
        System.out.println(pro.getProperty("3"));
        //返回Set集合中存放的是Properties的键集
        Set<String> set=pro.stringPropertyNames();
        for(String key:set){
            System.out.println(key+"::"+pro.getProperty(key));
        }
    }
    //模拟load方法
    public static void method_2()throws Exception{
        Properties pro=new Properties();
        BufferedReader br=new BufferedReader(new FileReader("info.txt"));
        String line=null;
        while ((line=br.readLine())!=null)
        {
            String[] arr=line.split("=");            
            pro.setProperty(arr[0],arr[1]);

        }
        System.out.println(pro);
    }
    //对已有的配置文件中的信息进行修改
    //读取这个文件。并将这个文件中的键值数据存储到集合中。再通过集合对数据进行修改。load方法
    //再通过流将修改后的数据存储到文件中stroe方法
    public static void method_3()throws Exception{
        Properties pro=new Properties();
        FileReader fr=new FileReader("info.txt");        
        pro.load(fr);
        pro.setProperty("1","会更好");
        FileWriter fw=new FileWriter("info.txt");
        pro.store(fw,"");
        System.out.println(pro);
    }
}

 需求：限制程序运行次数。当运行次数到达5次时，给出，请您注册的提示。并不再让该程序执行。

思路：

1、应该有计数器。每次程序启动都需要计数一次，并且是在原有的次数上进行计数。

2、计数器就是一个变量。突然冒出一想法，程序启动时进行计数，计数器必须存在于内存并进行运算。可是程序一结束，计数器消失了。那么再次启动该程序，计数器又重新被初始化了。    而我们需要多次启动同一个应用程序，使用的是同一个计数器。这就需要计数器的生命周期边长，从内存存储到硬盘文件中。

3、如何使用这个计数器呢？首先，程序启动时，应该先读取这个用于记录计数器信息的配置文件。获取上一次计数器次数。并进行使用次数的判断。其次，对该次数进行自增，并自增后的次数重新存储到配置文件中。

4、文件中的信息该如何进行存储并体现。直接存储次数值可以，但是不明确该数据的含义。所以起名字就变得很重要。这就有了名字和值的对应，所以可以使用键值对。可是映射关系map集合搞定，又需要读取硬盘上的数据，所以map+io=properties。

import java.io.*;
import java.util.*;
class RunCount{
    public static void main(String[] args)throws IOException{
        File file=new File(“count.ini”);
        if(!file.exists())
            file.createNewFile();
        FileReader fr=new FileReader(file);
        Properties pro=new Properties();
        pro.load(fr);
        int count=0;
        String value=pro.getProperty(“time”);
        if(value!=null){
            count=Integet.parseInt(value);
            if(count>=5)
               throw new RuntimeException(“使用次数已到”);
　　　　}
　　　　count++;
　　　　pro.setProperty(“time”,Integer.toString(count));//String.valueOf(count)  把int型转成字符串
　　　　FileWriter fw=new FileWriter(file);
　　　　pro.store(fw,””);
　　　　fr.close();
　　　　fw.close();
24　　 }
}

三、IO包中其他类

1、PrintStream、PrintWriter打印流

打印流最厉害的地方就是有很多打印方法可供我们选择。

PrintStream继承体系

OutputStream

　　|--FilterOutputStream

　　　　|--PrintStream

PrintWriter继承体系

Writer

　　|--PrintWriter

PrintWriter与PrintStream：可以直接操作输入流和文件。

(1)、PrintStream字节打印流

PrintStream为其他输出流添加了功能，使它们能够方便地打印各种数据值并保持数据的表示形式。与其他输出流不同，PrintStream永远不会抛出IOException。

PrintStream打印的所有字符都使用平台的默认字符编码转换为字节。在需要写入字符而不是写入字节的情况下，应该使用PrintWriter类。

PrintStream构造函数，接收三种类型的值：无空参构造函数

1. 字符串路径

2. File对象

3. 字节输出流

前两个都JDK1.5版本才出现。而且在操作文本文件时，可指定字符编码了。

构造函数：

new    PrintStream(File file);//创建具有指定文件且不带自动行刷新的新打印流
new    PrintStream(File file,String csn);//创建具有指定文件名称和字符集且不带自动行刷新的新打印流
new    PrintStream(OutputStream out);//创建新的打印流
new    PrintStream(OutputStream out,boolean autoFlush);//创建新的打印流,并且可以自带自动刷新
new    PrintStream(OutputStream out,boolean autoFlush,String encoding);//创建新的打印流，既能自动刷新又能指定编码表
new    PrintStream(String fileName);//创建具有指定文件名称且不带自动行刷新的新打印流
new    PrintStream(String fileName, String csn) ;//创建具有指定文件名称且能指定编码表的新打印流

 代码演示：

import java.io.*;
class PrintStreamDemo
{
    public static void main(String[] args) throws IOException
    {
        File file=new File("安卓.txt");
        if(!file.exists())
            file.createNewFile();
        PrintStream out=new PrintStream(new FileOutputStream(file),true);
        //write(int b)方法只写最低8位
        //print方法将7878先变成字符串保持原样将数据打印到目的地
        out.println(7878);//运行结果:7878
    }
}

(2)、PrintWriter字符打印流

PrintWriter构造函数，接收四种类型的值：(重点)无空参

1.字符串路径

2.File对象

3.字节输出流

4.字符输出流

构造方法：

new    PrintWriter(File file);//使用指定文件创建不具有自动行刷新的新 PrintWriter.
new     PrintWriter(File file,String csn);//创建具有指定文件和字符集且不带自动刷行新的新 PrintWriter.
new    PrintWriter(OutputStream out);// 创建不带自动行刷新的新 PrintWriter。
new    PrintWriter(OutputStream out, boolean autoFlush)// 创建打印流,并且可以自动刷新。
new    PrintWriter(Writer out);// 创建不带自动行刷新的新 PrintWriter
PrintWriter(Writer out, boolean autoFlush)//创建自动行刷新的新 PrintWriter
new    PrintWriter(String fileName, String csn) ;//创建具有指定文件名称和字符集且不带自动行刷新的新 PrintWriter

 方法中直接操作文件的第二参数是编码表。

直接操作输出流的，第二参数是自动刷新。

import java.io.*;
class PrintWriterDemo
{
    public static void main(String[] args) throws IOException
    {
        File file=new File("安卓.txt");
        if(!file.exists())
            file.createNewFile();
        PrintWriter out=new PrintWriter(new FileWriter(file),true);
        //write(int b)方法只写最低8位
        //print方法将7878先变成字符串保持原样将数据打印到目的地
        out.println(78);//运行结果:78
    }
}

 需求：将键盘录入的数据写入到指定的文件中。

import java.io.*;
class PrintWriterDemo 
{
    public static void main(String[] args)throws IOException 
    {        
        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
//        PrintWriter out=new PrintWriter(new FileOutputStream("黑马.ini",true));
        PrintWriter out=new PrintWriter(new FileWriter("黑马.txt"),true);//true代表的是自动刷新
        String line=null;
        while ((line=br.readLine())!=null)
        {
            if("over".equals(line))
                break;
            out.println(line);//Println方法代表是是输出并且自动换行
        }
        out.close();
    }
}

 2、SequenceInputStream 序列流

将多个读取流合并成一个读取流，实现数据合并。

表示其他输入流的逻辑串联。它从输入流的有序集合开始，并从第一个输入流开始读取，直到到达文件末尾，接着从第二个输入流读取，依次类推，直到到达包含的最后一个输入流的文件末尾为止。这样做，可以更方便的操作多个读取流，其实这个序列流内部会有一个有序的集合容器，用于存储多个读取流对象。

该对象的构造函数参数是Enumeration，想要获取Enumeration，需要有Vector集合。但是Vector集合效率太低，已经被ArrayList所取代。这时候可以用Collections工具类中的Collections.enumeration()该方法返回的就是Enumeration接口。这样会大大提高效率的。

构造函数：

new SequenceInputStream(Enumeration<? extends InputStream> e);//该构造函数适合多个读取字节流对象操作
new SequenceInputStream(InputStream s1, InputStream s2);//该构造函数适合两个读取字节流对象操作

 需求：将1.txt、2.txt、3.txt文件中的数据合并到一个文件中。

import java.io.*;
import java.util.*;
class SequenceInputStreamDemo 
{
    public static void main(String[] args)throws IOException 
    {
        method_1();
    }
    public static void method_1()throws IOException{
        //定义Vector对象用来存储字节读取流对象
        Vector<FileInputStream> v=new Vector<FileInputStream>();
        v.add(new FileInputStream("E:\1.txt"));
        v.add(new FileInputStream("E:\2.txt"));
        v.add(new FileInputStream("E:\3.txt"));

        //用Vector对象中的elements方法获取Enumeration
        Enumeration<FileInputStream> en=v.elements();

        //创建SequenceInputStream对象，和流关联
        SequenceInputStream sis=new SequenceInputStream(en);
        FileOutputStream fw=new FileOutputStream("E:\4.txt");
        int len=0;
        byte[] buf=new byte[1024];
        while ((len=sis.read(buf))!=-1)
        {
            fw.write(buf,0,len);
        }
        sis.close();
        fw.close();
    }
    //上面用的Vector对象。这个对象比较低效，已经被ArrayList所替代了。所以下面我们用ArrayList集合来操作。
    public static void method_2()throws IOException{
        //创建ArrayList集合容器用来存放字节读取流对象，该容器效率比Vector集合效率高
        Collection<FileInputStream> coll=new ArrayList<FileInputStream>();
        //循环获取FileInputStream对象，添加进ArrayList集合中。
        for (int x=1;x<4 ;x++ )
        {
            coll.add(new FileInputStream("E:\"+x+".txt"));
        }
        //用Collections工具类中的enumeration方法获取Enumeration接口
        Enumeration<FileInputStream> en=Collections.enumeration(coll);
        //创建SequenceInputStream对象，和流关联
        SequenceInputStream sis=new SequenceInputStream(en);
        FileOutputStream fos=new FileOutputStream("E:\4.txt");
        int len=0;
        byte[] buf=new byte[1024];
        while ((len=sis.read(buf))!=-1)
        {
            fos.write(buf,0,len);
        }
        fos.close();
        sis.close();
    }
}

 需求：对文件的切割。

import java.io.*;
import java.util.*;
class  SplitDemo
{
    public static void main(String[] args) throws IOException
    {
        File file=new File("D:\年轮.mp3");
        //用读取流关联源文件
        FileInputStream fis=new FileInputStream(file);
        FileOutputStream fos=null;
        //创建目标文件
        File dir=new File("E:\年轮");
        if(!dir.exists())
            dir.mkdir();
        int len=0;
        //定义一个计数器用来记录切割后碎片的文件名
        int count=1;
        //定义一个1M的缓冲区
        byte[] buf=new byte[1024*1024];
        while ((len=fis.read(buf))!=-1)
        {
            fos=new FileOutputStream(new File(dir,(count++)+".part"));
            fos.write(buf,0,len);
        }
        //切割文件时，必须记录住被切割文件的名称，以及切割出来碎片文件的个数，以方便于合并。
        //这个信息为了进行描述，使用键值对的方式，用到了properties对象。
        Properties pro=new Properties();
        //将被切割文件的信息保存到pro集合中
        pro.setProperty("Count",Integer.toString(count));
        pro.setProperty("Name",file.getName());
        fos=new FileOutputStream(new File(dir,count+".properties"));
        //将pro集合中的数据存储到文件中
        pro.store(fos,"");
        fos.close();
        fis.close();
    }
}

 需求：从上例读取配置信息，并合并文件

import java.io.*;
import java.util.*;
class HeBingFile 
{
    public static void main(String[] args)throws IOException 
    {        
        FileInputStream fis=new FileInputStream("E:\年轮\6.properties");
        Properties pro=new Properties();
        pro.load(fis);
        //获取配置信息中切割的个数
        int count=Integer.parseInt(pro.getProperty("Count"));
        //获取配置信息中别切割的文件名
        String name=pro.getProperty("Name");
//        System.out.println(name);        
        File file=new File("E:\年轮");
        //将碎片文件和流对象关联并存储到集合中
        ArrayList<FileInputStream> al=new ArrayList<FileInputStream>();
        //获取该目录下的所有碎片文件,并添加到集合中
        for (int x=1;x<count ; x++)
        {
            al.add(new FileInputStream(new File(file,x+".part")));
        }
        Enumeration<FileInputStream> en=Collections.enumeration(al);
        SequenceInputStream sis=new SequenceInputStream(en);        
        FileOutputStream fos=new FileOutputStream("E:\"+name);
        int len=0;
        byte[] buf=new byte[1024];
        while ((len=sis.read(buf))!=-1)
        {
            fos.write(buf,0,len);
        }
        
    }
}

 3、ObjectInputStream、ObjectOutputStream 操作对象的流

被操作的对象需要实现Serializable接口。类通过实现java.io.Serializable接口以启用序列化功能，Serializable只是一个标记接口。

Serializable：用于启动对象的序列化功能，可以强制让指定类具备序列化功能，该接口中没有成员，这是一个标记接口。这个标记接口用于给序列化类提供UID。这个uid是依据类中的成员的数字签名进行运行获取的。如果不需要自动获取一个uid，可以在类中，手动指定一个名称为serialVersionUID id号。依据编译器的不同，或者对信息的高度敏感性。最好每一个序列化的类都进行手动显示的UID的指定。

注意：静态数据不能被序列化，因为静态数据不在堆内存中，是存储在静态方法区中。 

如何将非静态的数据不进行序列化？用transient 关键字修饰此变量即可。

ObjectInputStream类中方法：

new ObjectInputStream(InputStream in);// 创建从指定 InputStream 读取的 ObjectInputStream
int    available();//返回可以不受阻塞地读取的字节数。
boolean    readBoolean();//读取一个 boolean 值
byte    readByte();//读取一个 8 位的字节
char    readChar();//读取一个 16 位的 char 值
double    readDouble();//读取一个 64 位的 double 值
float    readFloat();//读取一个 32 位的 float 值
int    readInt();//读取一个 32 位的 int 值
long  readLong();//读取一个 64 位的 long 值
short  readShort();//读取一个 16 位的 short 值
Object  readObject();// 从 ObjectInputStream 读取对象
String  readUTF();//读取 UTF-8 修改版格式的 String

 ObjectOutputStream类中的方法：

new ObjectOutputStream(OutputStream Out);// 创建写入指定 OutputStream 的 ObjectOutputStream
void  writeBoolean(boolean val);//写入一个 boolean 值
void  writeByte(int val);// 写入一个 8 位字节
void  writeBytes(String str);//以字节序列形式写入一个 String
void  writeChar(int val);//写入一个 16 位的 char 值
void  writeDouble(double val);//读取一个 64 位的 double 值
void  writeFloat(float val);//写入一个 32 位的 float 值
void  writeInt(int val);//  写入一个 32 位的 int 值
void  writeLong(long val);//写入一个 64 位的 long 值
void  writeObject(Object obj);//将指定的对象写入 ObjectOutputStream
void  writeShort(int val);//写入一个 16 位的 short 值
void  writeUTF(String str);//  以 UTF-8 修改版格式写入此 String 的基本数据

代码演示：

Person.java文件

import java.io.*;
//实现Serializable接口以启用序列化功能
class Person implements Serializable
{
    //用于给被序列化的类加入ID号，用于判断类和对象是否是同一个版本
    //此时，再将Person类中属性修饰符修改为public，也不会出现任何异常
    private static final long serialVersionUID = 2332;
    private String name;
//    private transient String name;//用transient修饰后name将不会进行序列化
    private int age;
    Person(String name,int age){
        this.name=name;
        this.age=age;
    }
    public void setName(String name){
        this.name=name;
    }
    public String getName(){
        return name;
    }
    public void setAge(int age){
        this.age=age;
    }
    public int getAge(){
        return age;
    }
    public String toString(){
        return name+"::"+age;
    }
}

 ObjectOutputStreamDemo.java文件

import java.io.*;
class ObjectOutputStreamDemo 
{
    public static void main(String[] args)throws Exception
    {    
//        writeObj();
        readObj();
    }
    public static void writeObj()throws IOException{
        ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("obj.object"));
        oos.writeObject(new Person("黑马",120));
        oos.close();
    }
    public static void readObj()throws Exception{
        ObjectInputStream ois=new ObjectInputStream(new FileInputStream("obj.object"));
        Person p=(Person)ois.readObject();
        System.out.println(p);//运行结果：黑马::120
        ois.close();
    }
}

 4、管道流

PipedInputStream和PipedOutputStream：输入输出可以直接进行连接，通过结合线程使用。

import java.io.*;
class Read implements Runnable
{
    private PipedInputStream in;
    Read(PipedInputStream in){
        this.in=in;
    }
    public void run(){
        byte[] buf=new byte[1024];
        try
        {
            System.out.println("读取前。。没有数据阻塞");
            int len=in.read(buf);//read方法是阻塞式方法，没有收到数据前就是等待
            System.out.println("读到数据。。阻塞结束");
            System.out.println(new String(buf,0,len));
            
        }
        catch (IOException e)
        {
            System.out.println(e);
        }
        finally{
            try
            {
                in.close();
            }
            catch (IOException e)
            {
                System.out.println("关闭失败");
            }
        }
        
    }
}
class Write implements Runnable
{
    private PipedOutputStream out;
    Write(PipedOutputStream out){
        this.out=out;
    }
    public void run(){
        try
        {
            System.out.println("开始写入数据，等待6秒后。");
            Thread.sleep(6000);//让线程等待6秒后继续执行
            out.write("我是管道流".getBytes());
        }
        catch (Exception e)
        {
            System.out.println(e);
        }
        finally
        {
            try
            {
                out.close();
            }
            catch (IOException e)
            {
                System.out.println("关闭失败");
            }
        }        
        
    }
}

class PipedStreamDemo 
{
    public static void main(String[] args) throws IOException
    {
        PipedInputStream in=new PipedInputStream();
        PipedOutputStream out=new PipedOutputStream();
        in.connect(out);//管道输入流连接到管道输出流
        new Thread(new Read(in)).start();
        new Thread(new Write(out)).start();
    }
}

 5、RandomAccessFile 随机访问文件

随机访问文件，自身已经具备了读和写的方法。该类不算是IO体系中的子类，而是直接继承自Object。但是它是IO包中的成员，是因为它具备了读写功能，内部其实封装了一个数组，而且通过指针对数组的元素进行操作。可以通过getFilePointer获取指针位置，同时也可以通过seek改变指针的位置。其实完成读写的原理就是内部封装了字节输入流和输出流。

通过构造函数可以看出，该类只能操作文件，而且操作文件还有模式：只读r，读写rw等。

如果模式为只读r，则不会创建文件，会去读取一个已经存在文件。如果该文件不存在，则会出现异常。

如果模式为rw，操作的文件不存在，会自动创建。如果存在则不会覆盖。

特点：

1.该对象即可读取，又可写入。

2.该对象中的定义了一个大型的byte数组，通过定义指针来操作这个数组。

3.可以通过该对象的getFilePointer()获取指针的位置，通过seek()方法设置指针的位置。

4.该对象操作的源和目的必须是文件。

5.其实该对象内部封装了字节读取流和字节写入流。

注意：实现随机访问，最好是数据有规律。

import java.io.*;
class RandomAccessFileDemo 
{
    public static void main(String[] args) throws IOException
    {
        //writeFile_2();
        //readFile();
        }
    public static void readFile()throws IOException
    {
        RandomAccessFile raf = new RandomAccessFile("ran.txt","r");
        //调整对象中指针。
        //raf.seek(8*1);
        //跳过指定的字节数
        raf.skipBytes(8);
        byte[] buf = new byte[4];
        raf.read(buf);
        String name = new String(buf);
        int age = raf.readInt();
        System.out.println("name="+name);
        System.out.println("age="+age);
        raf.close();
    }
    public static void writeFile_2()throws IOException
    {
        RandomAccessFile raf =new RandomAccessFile("ran.txt","rw");
        //往指定位置写入数据
        raf.seek(8*0);
        raf.write("小明".getBytes());
        raf.writeInt(103);
        raf.close();
    }
    public static void writeFile()throws IOException
    {
         //如果文件不存在，则创建，如果文件存在，不创建
        RandomAccessFile raf = new RandomAccessFile("ran.txt","rw");
        raf.write("李四".getBytes());
        raf.writeInt(97);
        raf.write("王五".getBytes());
        raf.writeInt(99);
        raf.close();
    }
}

 6、DataInputStream与DataOutputStream

可以用于操作基本数据类型的数据的流对象。

import java.io.*;
class DataStreamDemo  
{
    public static void main(String[] args)throws IOException 
    {
//        write();
        read();
    }
    public static void read()throws IOException{
        DataInputStream dis=new DataInputStream(new FileInputStream("data.txt"));
        //输入流中读取基本数据类型
        int num=dis.readInt();
        double d=dis.readDouble();
        boolean b=dis.readBoolean();
        //读取一个UTF-8编码的字符串
        String s=dis.readUTF();
        System.out.println("num="+num);
        System.out.println("d="+d);
        System.out.println("b="+b);
        System.out.println("s="+s);
    }
    public static void write()throws IOException{
        DataOutputStream dos=new DataOutputStream(new FileOutputStream("data.txt"));
        //基本数据类型写入输出流中
        dos.writeInt(45);
        dos.writeDouble(45.2);
        dos.writeBoolean(true);
        //使用 UTF-8 修改版编码将一个字符串写入输出流,此写出的数据必须用readUTF()方法读取，转换流是不行的。
        dos.writeUTF("你好");
    }
}

 7、 ByteArrayInputStream与ByteArrayOutputStream 操作字节数组

用于操作字节数组的流对象。

ByteArrayInputStream ：在构造的时候，需要接收数据源，。而且数据源是一个字节数组。

ByteArrayOutputStream： 在构造的时候，不用定义数据目的，因为该对象中已经内部封装了可变长度的字节数组。这就是数据目的地。

因为这两个流对象都操作的数组，并没有使用系统资源。所有的操作都是在内存中完成的。所以，不用进行close关闭。

String  toString();// 使用平台默认的字符集，通过解码字节将缓冲区内容转换为字符串。 

import java.io.*;
class ByteArrayStreamDemo 
{
    public static void main(String[] args) 
    {
        //数据源。
        ByteArrayInputStream in=new ByteArrayInputStream("nihaojava".getBytes());
        //数据目的
        ByteArrayOutputStream out=new ByteArrayOutputStream();
        int by=0;
        while ((by=in.read())!=-1)
        {
            out.write(by);
        }

        System.out.println(out.toString());
    }
}

8、 CharArrayReader与CharArrayWrite 操作字符数组

9、StringReader 与 StringWriter 操作字符串

这两个流对象和ByteArrayStream的原理一样，可参考ByteArrayStream。

10、编码和解码

编码表的由来：

计算机只能识别二进制数据，早期由来是电信号。为了方便应用计算机，让它可以识别各个国家的文字。就将各个国家的文字用数字来表示，并一一对应，形成一张表，这就是编码表。

常见的编码表：

ASCII：美国标准信息交换码。用一个字节的7位可以表示。ISO8859-1：拉丁码表,欧洲码表。用一个字节的8位表示。

GB2312：中国的中文编码表。

GBK：中文编码表升级融合了更多的文字符号。两个字节。

Unicode：国际标准码，融合了多种文字。

所有文字都用两个字节来表示,Java语言使用的就是unicode

UTF-8：最多用三个字节来表示一个字符。

编码：字符串变成字节数组

Stringàbyte[]:   str.getBytes(charsetName);

解码：字节数组变成字符串

byte[]àString:   new String(byte[],charsetName);

如果编码编错了，解不出来。

如果编对了，解错了，又可能有救。可以在编一次，再解一次。

import java.util.*;
class EncodeDemo 
{
    public static void main(String[] args) throws Exception
    {
        String s="你好";
        byte[] by=s.getBytes("GBK");
        System.out.println(Arrays.toString(by));

        //解码
        String s1=new String(by,"UTF-8");
        System.out.println(s1);//解错了

        //在按照GBK编码一次
        byte[] b=s.getBytes();
        System.out.println(Arrays.toString(b));

        //在用UTF-8解码一次
        String s2=new String(b,"GBK");
        System.out.println(s2);
    }
}

 运行结果：

[-60, -29, -70, -61]
???
[-60, -29, -70, -61]
你好

如果编对了，解错了，也可能没救了。 

import java.util.*;
public class EncodeDemo{
       public static void main(String[] args) throws Exception{
            String s = "您好"; 
            //编码
            byte[] by = s.getBytes("gbk" );
            System.out.println(Arrays.toString(by));
            //解码
            String str= new String(by,"UTF-8" );
            System.out.println(str);
            //再编一次
            byte[] b = str.getBytes("UTF-8" );           
            System.out.println(Arrays.toString(b));
            //再解码一次
            System.out.println(new String(b,"gbk" ));
      }
    
}

 运行结果： 

[-60, -6, -70, -61]
????
[-17, -65, -67, -17, -65, -67, -17, -65, -67, -17, -65, -67]
锟斤拷锟斤拷

原因分析：

“您好”的gbk编码在UTF-8码表中查不到对应的字符，所以已经用“？”代替。“？”在UTF-8中的编码为-17 -65 -67

故即使使用UTF-8码表进行编码，然后再用GBK接码获取的字节也不是“您好”的gbk编码后的字节。所以再也不能成功解码了。

“谢谢”的gbk编码在UTF-8码表中可以查到对应的字符，为“ππ”。因此，使用UTF-8码表对“ππ”进行解码，获取的字节也依然是“您好”的gbk编码后的字节。   所以，不会出现“您好”发生的情况。

 

分析：联通乱码问题。

在记事本中输入联通，保存。关闭，重新打开此文件，发现乱码。这是怎么回事呢？

原因分析：

“联通”经过gbk编码后成四个字节：11000001、10101010、11001101、10101000。

正好符合UTF-8的编码规则。所以，记事本按照UTF-8进行了解码，从而出现了乱码现象。

 

练习：有五个学生，每个学生有3门课的成绩，从键盘输入以上数据（包括姓名，三门课成绩），输入的格式：如：zhangsan，30，40，60计算出总成绩，并把学生的信息和计算出的总分数高低顺序存放在磁盘文件"stud.txt"中。

思路：

1，通过获取键盘录入一行数据，并将该行中的信息取出封装成学生对象。

2，因为学生有很多，那么就需要存储，使用到集合。因为要对学生的总分排序。所以可以使用TreeSet。

 

/*
有五个学生，每个学生有3门课的成绩，
从键盘输入以上数据（包括姓名，三门课成绩），
输入的格式：如：zhagnsan，30，40，60计算出总成绩，
并把学生的信息和计算出的总分数高低顺序存放在磁盘文件"stud.txt"中。
*/
import java.io.*;
import java.util.*;
class Student implements Comparable<Student>
{
    private String name;
    private int cn,ma,en;
    private int sum;
    Student(String name,int cn,int ma,int en){
        this.name=name;
        this.cn=cn;
        this.ma=ma;
        this.en=en;
        sum=cn+ma+en;
    }
    public String getName(){
        return name;
    }
    public int getSum(){
        return sum;
    }
    public int compareTo(Student s){
        int num=this.sum-s.sum;
        return num==0?this.name.compareTo(s.name):num;
    }
    public int hashCode(){
        return name.hashCode()+sum*37;
    }
    public boolean equals(Object obj){
        if(!(obj instanceof Student))
            throw new RuntimeException("类型错误");
        Student stu=(Student)obj;
        return this.name.equals(stu.name)&&this.sum==stu.sum;
    }
    public String toString(){
        return "student["+name+", "+cn+", "+ma+", "+en+"]";
    }

}
class StuTools
{
    public static Set<Student> getStu()throws IOException{
        return getStu(null);//如果没有传比较器，返回没有传比较器的排序
    }
    public static Set<Student> getStu(Comparator<Student> comp)throws IOException{
        TreeSet<Student> ts=null;
        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
        if(comp==null)//这是Student自身排序
            ts=new TreeSet<Student>();
        else
            ts=new TreeSet<Student>(comp);//传入比较器
        String line=null;
        while ((line=br.readLine())!=null)
        {
            if("over".equals(line))
                break;
            String[] info=line.split(" ");
            ts.add(new Student(info[0],Integer.parseInt(info[1]),Integer.parseInt(info[2]),Integer.parseInt(info[3])));
        }
        return ts;
    } 
    public static void write2File(Set<Student> set)throws IOException{
        BufferedWriter out=new BufferedWriter(new FileWriter("stu.txt"));
        for(Student stu:set){
            out.write(stu.toString()+"	");
            out.write(String.valueOf(stu.getSum()));//把Integer转换成String
            out.newLine();
            out.flush();
        }
        out.close();
    }
}
class  StudentInfoTest 
{
    public static void main(String[] args) throws IOException
    {
        Comparator<Student> comp=Collections.reverseOrder();//反转现在Comparable接口的排序方式。
        Set<Student> set=StuTools.getStu(comp);
        StuTools.write2File(set);
    }
}

注：菜鸟日记，如有错误欢迎大神指正，欢迎探讨！！