8、文件IO操作

1、File类

File类的基本概念

File类：表示文件和目录路径名的抽象表示方法

File类可以实现文件的创建、删除、重命名、得到路径、创建时间等，是唯一与文件本身有关的操作类

File类的操作方法

import java.io.File;
import java.io.FileFilter;
import java.io.IOException;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;
/**
 * File类的使用
 * @description
 */
public class FileDemo {
   public static void main(String[] args) {
      //File类表示一个文件或目录
      // "C:\\test\\vince.txt"
      //"C:/test/vince.txt"
      File f1 = new File("c:"+File.separator+"test"+File.separator+"vince.txt");
      if(!f1.exists()){ //判断文件是否存在
         try {
            f1.createNewFile(); //创建文件
            System.out.println("文件创建成功");
         } catch (IOException e) {
            e.printStackTrace();
         }
      }
      //f1.isFile() :是否为文件 
      System.out.println("是否为文件夹："+f1.isDirectory());
      File f2 = new File("c:\\test\\my");
      boolean b = f2.delete();   //删除空文件夹
      System.out.println(b);
      String[] names = f2.list(); //列出当前目录下的所有文件名
      System.out.println(Arrays.toString(names));
      File[] fs = f2.listFiles();//列出当前目录下的所有文件，以file对象返回
      for(File f: fs){
         System.out.println("length="+f.length());
         System.out.println("name="+f.getName());
         System.out.println("相对路径="+f.getPath());
         System.out.println("绝对路径="+f.getAbsolutePath());
         System.out.println("是否为隐藏文件="+f.isHidden());
         System.out.println("是否可读文件="+f.canRead());
         Date date = new Date(f.lastModified());
         DateFormat df = new SimpleDateFormat("HH:mm:ss");
         System.out.println("文件最后修改的时间="+df.format(date));
         System.out.println("---------");
      }
      //相对路径与绝对路径的区别
      File f3 = new File("temp.txt");
      System.out.println(f3.getPath());
      System.out.println(f3.getAbsolutePath());
      //
      File f4 = new File("c:\\test\\dabin1");
      f4.mkdirs();
      //重命名与移动文件
      //重命名f4.renameTo(new File("c:\\test\\dabin1"));;
      //移动文件
      f4.renameTo(new File("c:\\test1"));
      //返回所有“.txt”格式的文件
      File f5 = new File("c:\\test\\my");
//    File[] files = f5.listFiles(new FileFilter() {
//       @Override
//       public boolean accept(File pathname) {
//          return pathname.getName().endsWith(".txt");
//       }
//    });
      File[] files = f5.listFiles((pathname)->pathname.getName().endsWith(".txt"));
      System.out.println("---------");
      for(File f:files){
         System.out.println(f.getName());
      }
   }
}

import java.io.File;
/**
 * 在指定的目录中查找文件
 * @description
 */
public class FileDemo2 {
   public static void main(String[] args) {
      findFile(new File("C:\\Users\\vince\\Downloads"),".jpg");
   }
   //查找文件的方法
   private static void findFile(File target,String ext){
      if(target==null)return;
      //如果文件是目录
      if(target.isDirectory()){
         File[] files = target.listFiles();
         if(files!=null){
            for(File f: files){
               findFile(f,ext);//递归调用
            }
         }
      }else{
         //此处表示File是一个文件
         String name = target.getName().toLowerCase();
         //System.out.println(name);
         if(name.endsWith(ext)){
            System.out.println(target.getAbsolutePath());
         }
      }
   }
}

2、字节流

1、IO流概述

IO流：输入输出流（Input/Output） 流是一组有顺序的，有起点和终点的字节集合，是对数据传输的总称或抽象。

即数据在两设备间的传输称为流

流的本质是数据传输，根据数据传输特性将流抽象为各种类，方便更直观的进行数据操作。

IO流的分类：

根据处理数据类型的不同分为：字符流和字节流

根据数据流向不同分为：输入流和输出流

2、字节输出流

OutputStream类定义

public abstract class OutputStream extends Object implements Closeable,Flushable

此抽象类是表示输出字节流的所有类的超类。输出流接受输出字节并将这些字节发送到InputStream 类某个接收器要向文件中输出，使用FileOutputStream类

3、字节输入流

InputStream类定义：

public abstract class InputStream extends Object implements Closeable

此抽象类是表示字节输入流的所有类的超类。 FileInputStream 从文件系统中的某个文件中获得输入字节

 package com.vince;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
/**
 * 字节输出输入流
 * 输出流：超类 OutputStream，对文件的输出流使用子类FileOutputStream
 * 输入流：超类InputStream，对文件的输入流使用子类FileInputStream
 * 
 * 输入输出字节流操作原理，每次只会操作一个字节，（从文件中读取或写入 ）
 * 字节操作流，默认每次执行写入操作会直接把数据写入文件
 * @author vince
 * @description
 */
public class ByteStreamDemo {
   private static void in(){
      //0、确定目标文件
      File file = new File("d:\\test\\test.txt");
      //1、构建 一个文件输入流对象
      try {
         InputStream in = new FileInputStream(file);
         byte[] bytes = new byte[10];
         StringBuilder buf = new StringBuilder();
         //读取过程 
         int len = -1;//表示每次读取的字节长度
         //把数据读入到数组中，并返回读取的字节数,当不等-1时，表示读取到数据，等于-1表示文件已经读完
         while((len = in.read(bytes))!=-1){
            //根据读取到的字节数组，再转换为字符串内容，添加到StringBilder中
            buf.append(new String(bytes,0,len));
         }
         //打印内容：
         System.out.println(buf);
         //关闭输入流
         in.close();
      } catch (FileNotFoundException e) {
         e.printStackTrace();
      } catch (IOException e) {
         e.printStackTrace();
      }  
   }
   private static void out(){
      //0、确定目标文件
      File file = new File("d:\\test\\test.txt");
      //1、构建一个文件输出流对象
      try {
         OutputStream out = new FileOutputStream(file,true); //append 为true表示追加内容，为false表示覆盖内容
         //2、输出的内容
         String info = "小桥流水人家\r\n";// \r\n表示换行
         //String line = System.getProperty("line.separator");//获取换行符
         //3、把内容写入到文件
         out.write(info.getBytes());       //以字节数组的形式写入
         //4、关闭流
         out.close();
         System.out.println("write success.");
      } catch (FileNotFoundException e) {
         e.printStackTrace();
      } catch (IOException e) {
         e.printStackTrace();
      }
   }
   public static void main(String[] args) {
      out();
      in();
   }
}

4、文件的复制

一边读、一边写

package com.vince;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
/**
 * @description
 */
public class CopyFileDemo {photo
   public static void main(String[] args) {
      System.out.println("start copy...");
      copy("d:\\photo.jpg","d:\\test\\photo.jpg");
      System.out.println("copy success.");
   }
   private static void copy(String src,String target){
      File srcFile = new File(src);
      File targetFile = new File(target);
      InputStream in = null;
      OutputStream out = null;
      try {
         in = new FileInputStream(srcFile);
         out = new FileOutputStream(targetFile);
         byte[] bytes = new byte[1024];
         int len = -1;
         while((len=in.read(bytes))!=-1){ 
            out.write(bytes, 0, len);
         }
      } catch (FileNotFoundException e) {
         e.printStackTrace();
      } catch (IOException e) {
         e.printStackTrace();
      }finally{
         try {
            if(in!=null)in.close();
            if(out!=null)out.close();
         } catch (IOException e) {
            e.printStackTrace();
         }
      }
   }
}

3、字符流

字节流与字符流的区别 在所有的流操作里。

字节永远是最基础的。任何基于字节的操作都是正确的。无论你是文本文件还是二进制的文件。

如果确认流里面只有可打印的字符，包括英文的和各种国家的文字，也包括中文，那么可以考虑用字符流。 由于编码不同，多字节的字符可能占用多个字节。比如GBK的汉字就占用2个字节，而UTF-8的汉字就占用3个字节。

所以，字符流是根据指定的编码，将1个或多个字节转化为java里面的unicode的字符，然后进行操作。字符操作一般使用Writer,Reader等， 字节操作一般都是InputStream, OutputStream 以及各种包装类，比如BufferedInputStream和BufferedOutputStream等。

总结：

如果你确认你要处理的流是可打印的字符，那么使用字符流会看上去简单一点。如果不确认，那么用字节流总是不会错的。

Writer

写入字符流的抽象类。子类必须实现的方法仅有 write(char[], int, int)、flush() 和close()。但是，多数子类将重写此 处定义的一些方法，以提供更高的效率和/或其他功能。 与OutputStream一样，对文件的操作使用：FileWriter类完成。

Reader

用于读取字符流的抽象类。子类必须实现的方法只有 read(char[], int, int)和close()。但是，多数子类将重写 此处定义的一些方法，以提供更高的效率和/或其他功能。 使用FileReader类进行实例化操作。

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Reader;
import java.io.Writer;
/**
 * 字符流：
 * 字符输出流：Writer，对文件的操作使用子类：FileWriter
 * 字符输入流：Reader，对文件的操作使用子类：FileReader
 * 每次操作的单位是一个字符
 * 文件字符操作流会自带缓存，默认大小为1024字节，在缓存满后，或手动刷新缓存，或关闭流时会把数据写入文件
 * 
 * 如何选择使用字节流还是字符流：
 * 一般操作非文本文件时，使用字节流，操作文本文件时，建议使用字符流
 * 
 * 字符流的内部实现还是字节流
 * @description
 */
public class CharStreamDemo {
   private static void in(){
      File file = new File("d:\\test\\test.txt");
      try {
         Reader in = new FileReader(file);
         char[] cs = new char[3];
         StringBuilder buf = new StringBuilder();
         int len = -1;
         while((len=in.read(cs))!=-1){
            buf.append(new String(cs,0,len));
         }
         in.close();
         System.out.println(buf);
      } catch (FileNotFoundException e) {
         e.printStackTrace();
      } catch (IOException e) {
         e.printStackTrace();
      }
   }
   private static void out(){
      File file = new File("d:\\test\\test.txt");
      try {
         Writer out = new FileWriter(file,true);
         out.write(",枯藤老树昏鸦");
         out.close();
      } catch (IOException e) {
         e.printStackTrace();
      }
   }
   public static void main(String[] args) {
      out();
      in();
   }
}

4、字节字符转换流

转换流，可以将一个字节流转换为字符流，也可以将一个字符流转换为字节流。

OutputStreamWriter：可以将输出的字符流转换为字节流的输出形式

InputStreamReader：将输入的字节流转换为字符流输入形式

package com.vince;
import java.io.*;
import java.nio.charset.Charset;
/**
 * 转换流
 * OutputStreamWriter：可以将输出的字符流转换为字节流的输出形式
   InputStreamReader：将输入的字节流转换为字符流输入形式
 * @author vince
 * @description
 */
public class ChangeStreamDemo {
   private static void write(OutputStream out){
      //Charset.defaultCharset()使用默认字符集
      Writer writer = new OutputStreamWriter(out,Charset.defaultCharset());
      try {
         writer.write("古道西风瘦马\r\n");
         writer.close();
      } catch (IOException e) {
         e.printStackTrace();
      }
   }
   private static void read(InputStream in){
      Reader reader = new InputStreamReader(in,Charset.defaultCharset());
      char[] cs = new char[1024];
      int len = -1;
      try {
         while((len=reader.read(cs))!=-1){
            System.out.println(new String(cs,0,len));
         }
         reader.close();
      } catch (IOException e) {
         e.printStackTrace();
      }
   }
   public static void main(String[] args) throws FileNotFoundException {
      InputStream in = new FileInputStream("d:\\test\\test.txt");
      read(in);
      OutputStream out = new FileOutputStream("d:\\test\\test.txt");
      write(out);
   }
}

5、缓冲流

首先要明确一个概念： 对文件或其它目标频繁的读写操作，效率低，性能差。

使用缓冲流的好处是，能够更高效的读写信息

原理是将数据先缓冲起来，然后一起写入或者读取出来。

BufferedInputStream： 为另一个输入流添加一些功能，在创建BufferedInputStream 时，会创建一个内部缓冲区数组，用于缓冲数据。

BufferedOutputStream：通过设置这种输出流，应用程序就可以将各个字节写入底层输出流中，而不必针对每次字节写入调用底层系统。

BufferedReader：从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。

BufferedWriter：将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.Reader;
import java.io.Writer;
/**
 * 缓存的目的：
 * 解决在写入文件操作时，频繁的操作文件所带来的性能降低的问题，
 * BufferedOutputStream 内部默认的缓存大小是8KB，每次写入时存储到缓存中的byte数组中，当数组存满时，会把数组中的数据写入文件，
 * 并且缓存下标归零
 * 
 * 字符流
 * 1、加入字符缓存流，增强读取功能（readLine）
 * 2、更高效的读取数据
 * FileReader: 内部使用InputStreamReader( sun.nio.cs.StreamDecoder),解码过程，byte->char，默认缓存大小是8K
 * BufferedReader:默认缓存大小是8K，但可以手动指定缓存大小，把数据进接读取到缓存中，减少每次转换过程,效率更高
 * BufferedWriter 同上
 * 
 * @description
 */
public class BufferStreamDemo {
   private static void charWriter(){
      File file = new File("d://test//test.txt");
      try {
         Writer writer = new FileWriter(file);
         BufferedWriter bw = new BufferedWriter(writer);
         bw.write("古道西风瘦马");
         bw.flush();       //刷新缓存
         bw.close();
      } catch (FileNotFoundException e) {
         e.printStackTrace();
      } catch (IOException e) {
         e.printStackTrace();
      }
   }
   private static void charReader(){
      File file = new File("d://test//test.txt");
      try {
         Reader reader = new FileReader(file);
         //为字符流提供缓存，以达到高效读取的目的
         BufferedReader br = new BufferedReader(reader);
         char[] cs = new char[1024];
         int len = -1;
         while((len=br.read(cs))!=-1){
            System.out.println(new String(cs,0,len));
         }
         br.close();
      } catch (FileNotFoundException e) {
         e.printStackTrace();
      } catch (IOException e) {
         e.printStackTrace();
      }
   }
   private static void byteReader2(){
      File file = new File("d://test//test.txt");
      try(BufferedInputStream bis = new BufferedInputStream(new FileInputStream(file))) {
         byte[] bytes = new byte[1024];
         int len = -1;
         while((len=bis.read(bytes))!=-1){
            System.out.println(new String(bytes,0,len));
         }
      } catch (FileNotFoundException e) {
         e.printStackTrace();
      } catch (IOException e) {
         e.printStackTrace();
      }
   }
   private static void byteReader(){
      File file = new File("d://test//test.txt");
      try {
         InputStream in = new FileInputStream(file);
         //构造一个字节缓冲流
         BufferedInputStream bis = new BufferedInputStream(in);
         byte[] bytes = new byte[1024];
         int len = -1;
         while((len=bis.read(bytes))!=-1){
            System.out.println(new String(bytes,0,len));
         }
         bis.close();
      } catch (FileNotFoundException e) {
         e.printStackTrace();
      } catch (IOException e) {
         e.printStackTrace();
      }
   }
   private static void byteWriter(){
      File file = new File("d://test//test.txt");
      try {
         OutputStream out = new FileOutputStream(file,true);
         //构造一个字节缓冲流
         BufferedOutputStream bos = new BufferedOutputStream(out);
         //
         String info = "小桥流水人家";
         bos.write(info.getBytes());
         bos.close();
         //out.close();
      } catch (FileNotFoundException e) {
         e.printStackTrace();
      } catch (IOException e) {
         e.printStackTrace();
      }
   }
   public static void main(String[] args) {
      byteWriter();
      byteReader();
   }
}

6、打印流

打印流的主要功能是用于输出，在整个IO包中打印流分为两种类型：

字节打印流：PrintStream

字符打印流：PrintWriter

打印流可以很方便的进行输出

package com.vince;
import java.io.BufferedOutputStream;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.OutputStream;
import java.io.PrintStream;
import java.io.PrintWriter;
import java.io.Writer;
/**
 * 打印流:很方便的进行输出
 * 
 * 字节打印流
 * 在字节输出时，可以增强输出功能
 * 字符打印流
 * 
 * @author vince
 * @description
 */
public class PrintStreamDemo {
   private static void charPrint(){
      File file = new File("d:\\test\\test.txt");
      try {
         Writer out = new FileWriter(file);
         //加缓存
         BufferedWriter bos = new BufferedWriter(out);
         //增强打印功能
         PrintWriter pw = new PrintWriter(bos);
         pw.println("枯藤老树昏鸦，小桥流水人家");
         pw.close();
      } catch (FileNotFoundException e) {
         e.printStackTrace();
      } catch (IOException e) {
         e.printStackTrace();
      }
   }
   private static void bytePrint(){
      File file = new File("d:\\test\\test.txt");
      try {
         OutputStream out = new FileOutputStream(file);
         //加缓存
         BufferedOutputStream bos = new BufferedOutputStream(out);
         //增强打印功能
         PrintStream ps = new PrintStream(bos);
         ps.println("枯藤老树昏鸦，小桥流水人家");
         ps.close();
      } catch (FileNotFoundException e) {
         e.printStackTrace();
      }
   }
   public static void main(String[] args) {
      bytePrint();
      charPrint();
   }
}

7、对象流

对象流的两个类：

ObjectOutputStream 将 Java 对象的基本数据类型和图形写入 OutputStream

ObjectInputStream 对以前使用 ObjectOutputStream 写入的基本数据和对象进行反序列化。

序列化一组对象：

在序列化操作中，同时序列化多个对象时，反序列化也必须按顺序操作，如果想要序列化一组对象该如何操作呢？ 序列化一组对象可采用：对象数组的形式，因为对象数组可以向Object进行转型操作。

transient关键字：

如果用transient声明一个实例变量，当对象存储时，它的值不需要维持。

ObjectStreamDemo

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
public class ObjectStreamDemo {
   /**
    * 对象序列化
    * 把对象写入文件：实际写入的是类名、属性名、属性类型、属性的值等
    */
   private static void writeObjects(){
      Dog dog = new Dog("wangwang",2,"母");   //以组的形式将对象写入，在读取的时候，也要将对象的类型转为相应的组
      Dog dog2 = new Dog("2哈",3,"公");
      Dog[] dogs = {dog,dog2};
      File file = new File("d:\\test\\dog.obj");
      try {
         OutputStream out = new FileOutputStream(file);
         ObjectOutputStream oos = new ObjectOutputStream(out);
         oos.writeObject(dogs);
         oos.close();
      } catch (FileNotFoundException e) {
         e.printStackTrace();
      } catch (IOException e) {
         e.printStackTrace();
      }
   }
   /**
    * 反序列化的过程
    * 从文件中把对象的内容读取出来，还原成对象
    */
   private static void readObject(){
      File file = new File("d:\\test\\dog.obj");
      try {
         InputStream in = new FileInputStream(file);
         ObjectInputStream ois = new ObjectInputStream(in);
         Dog dog = (Dog)ois.readObject();
         ois.close();
         System.out.println(dog);
      } catch (FileNotFoundException e) {
         e.printStackTrace();
      } catch (IOException e) {
         e.printStackTrace();
      } catch (ClassNotFoundException e) {
         e.printStackTrace();
      }
   }
   /**
    * 对象序列化
    * 把对象写入文件：实际写入的是类名、属性名、属性类型、属性的值等
    */
   private static void writeObject(){
      Dog dog = new Dog("wangwang",2,"母");
      File file = new File("d:\\test\\dog.obj");
      try {
         OutputStream out = new FileOutputStream(file);
         ObjectOutputStream oos = new ObjectOutputStream(out);
         oos.writeObject(dog);
         oos.close();
      } catch (FileNotFoundException e) {
         e.printStackTrace();
      } catch (IOException e) {
         e.printStackTrace();
      }
   }
   public static void main(String[] args) {
      writeObject();
      readObject();
   }
}

Dog

import java.io.Serializable;
//如果一个类创建的对象，需要被序列化，那么该类必须实现Serializable接口，
//Serializable是一个标记接口，没有任何定义，为了告诉JVM该类对象可以被序列化
//什么时候对象需要被序列化呢？
//1、把对象保存到文件中（存储到物理介质）
//2、对象需要在网络上传输
//如果对象没有实现Serializable接口，会报错误：java.io.NotSerializableException
public class Dog implements Serializable{
   private static final long serialVersionUID = 1L;        //序列化编号，确定是不是一个对象
   private String name;
   private int age;
   private String sex;
   private transient int id; //在序列化中被忽略
   public String getName() {
      return name;
   }
   public void setName(String name) {
      this.name = name;
   }
   public int getAge() {
      return age;
   }
   public void setAge(int age) {
      this.age = age;
   }
   public String getSex() {
      return sex;
   }
   public void setSex(String sex) {
      this.sex = sex;
   }
   public Dog(String name, int age, String sex) {
      super();
      this.name = name;
      this.age = age;
      this.sex = sex;
   }
   public Dog() {
      super();
      // TODO Auto-generated constructor stub
   }
   @Override
   public String toString() {
      return "Dog [name=" + name + ", age=" + age + ", sex=" + sex + "]";
   }
}

8、字节数组流

ByteArrayInputStream

包含一个内部缓冲区，该缓冲区包含从流中读取的字节。内部计数器跟踪 read 方法要提供的下一个字节。 关闭 ByteArrayInputStream 无效。此类中的方法在关闭此流后仍可被调用，而不会产生任何 IOException。

ByteArrayOutputStream

此类实现了一个输出流，其中的数据被写入一个 byte 数组。缓冲区会随着数据的不断写入而自动增长。可使用 toByteArray() 和 toString() 获取数据。 关闭ByteArrayOutputStream 无效。此类中的方法在关闭此流后仍可 被调用，而不会产生任何 IOException。

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
/**
 * 字节数组流：
 * 基于内存操作，内部维护着一个字节数组，我们可以利用流的读取机制来处理字符串
 * 无需关闭
 * @description
 */
public class ByteArrayStreamDemo {
   private static void byteArray(){
      String s = "12345676dfghjhg(*$$%^&SDFGHJ";
      ByteArrayInputStream bais = new ByteArrayInputStream(s.getBytes());
      ByteArrayOutputStream baos = new ByteArrayOutputStream();
      int curr = -1;//每次读取的字节
      while((curr=bais.read())!=-1){
         if((curr>=65 && curr<=90) || (curr>=97 && curr<=122)){
            baos.write(curr);
         }
      }
      //此时无需关闭，原因，字节数组流是基于内存的操作流
      System.out.println(baos.toString());                                    //dfghjhgSDFGHJ
   }
   public static void main(String[] args) {
      byteArray();
   }
}

9、数据流

DataInputStream：

数据输入流允许应用程序以与机器无关方式从底层输入流中读取基本 Java 数据类型。应用程序可以使用数据输出 流写入稍后由数据输入流读取的数据。DataInputStream对于多线程访问不一定是安全的。 线程安全是可选的，它由此类方法的使用者负责。

DataOutputStream：

数据输出流允许应用程序以适当方式将基本 Java 数据类型写入输出流中。然后，应用程序可以使用数据输入流将数据读入。

案例： 实现文件分割合并。

与底层无关，还原很方便

package com.vince;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
/**
 * 数据流
 * 与机器无关的操作JAVA的基本数据类型
 * @description
 */
public class DataStreamDemo {
   private static void read(){
      File file = new File("d:\\test\\test.dat");
      try {
         InputStream in = new FileInputStream(file);
         BufferedInputStream bis = new BufferedInputStream(in);
         DataInputStream dis = new DataInputStream(bis);
         int num = dis.readInt();
         byte b = dis.readByte();
         String s = dis.readUTF();
         System.out.println(num+","+b+","+s);
         dis.close();
      } catch (FileNotFoundException e) {
         e.printStackTrace();
      } catch (IOException e) {
         e.printStackTrace();
      }
   }
   private static void write(){
      File file = new File("d:\\test\\test.dat");
      try {
         OutputStream out = new FileOutputStream(file);
         BufferedOutputStream bos = new BufferedOutputStream(out);
         DataOutputStream dos = new DataOutputStream(bos);
         dos.writeInt(10); //写入4个字节
         dos.writeByte(1);//写入1个字节
         dos.writeUTF("中");
         dos.close();
      } catch (FileNotFoundException e) {
         e.printStackTrace();
      } catch (IOException e) {
         e.printStackTrace();
      }
   }
   public static void main(String[] args) {
      write();
      read();
   }
}

文件分割与合并

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.SequenceInputStream;
import java.util.Enumeration;
import java.util.Vector;
/**
 * 文件分割合并示例
 * 
 * @description
 */
public class FileDivisionMergeDemo {
   /**
    * 文件的分割 targetFile 要分割的目标文件 cutSize 每个文件大小
    */
   private static void division(File targetFile, long cutSize) {
      if (targetFile == null)
         return;
      // 计算总分割的文件数
      int num = targetFile.length() % cutSize == 0 ? (int) (targetFile.length() / cutSize)
            : (int) (targetFile.length() / cutSize + 1);
      try {
         // 构造一个文件输入流
         BufferedInputStream in = new BufferedInputStream(new FileInputStream(targetFile));
         BufferedOutputStream out = null;
         byte[] bytes = null;// 每次要读取的字节数
         int len = -1; //每次实际读取的长度
         int count = 0;// 每一个文件要读取的次数
         //循环次为生成文件的个数
         for (int i = 0; i < num; i++) {
            out = new BufferedOutputStream(
                  new FileOutputStream(new File("c:\\test\\" + (i + 1) + "-temp-" + targetFile.getName())));
            if (cutSize <= 1024) {
               bytes = new byte[(int) cutSize];
               count = 1;
            } else {
               bytes = new byte[1024];
               count = (int) cutSize / 1024;
            }
            while (count > 0 && (len = in.read(bytes)) != -1) {
               out.write(bytes, 0, len);
               out.flush();
               count--;
            }
            //计算每个文件大小除于1024的余数，决定是否要再读取一次
            if (cutSize % 1024 != 0) {
               bytes = new byte[(int) cutSize % 1024];
               len = in.read(bytes);
               out.write(bytes, 0, len);
               out.flush();
               out.close();
            }
         }
         in.close();
      } catch (FileNotFoundException e) {
         e.printStackTrace();
      } catch (IOException e) {
         e.printStackTrace();
      }
   }
   /**
    * 文件合并
    */
   private static void merge(Enumeration<InputStream> es) {   //枚举类型
      //构造一个合并流
      SequenceInputStream sis = new SequenceInputStream(es);
      try {
         BufferedOutputStream bos = new BufferedOutputStream(
               new FileOutputStream("c:\\test\\第01章_Java开发入门_01_计算机基本概念与DOS命令.avi"));
         byte[] bytes = new byte[1024];
         int len = -1;
         while((len=sis.read(bytes))!=-1){
            bos.write(bytes,0,len);
            bos.flush();
         }
         bos.close();
         sis.close();
         System.out.println("合并完成.");
      } catch (FileNotFoundException e) {
         e.printStackTrace();
      } catch (IOException e) {
         e.printStackTrace();
      }
   }
   public static void main(String[] args) {
//    File file = new File("c:\\第01章_Java开发入门_01_计算机基本概念与DOS命令.avi");
//    division(file, 1024 * 1024 * 20);
      try {
         InputStream in1 = new FileInputStream(new File("c:\\test\\1-temp-第01章_Java开发入门_01_计算机基本概念与DOS命令.avi"));
         InputStream in2 = new FileInputStream(new File("c:\\test\\2-temp-第01章_Java开发入门_01_计算机基本概念与DOS命令.avi"));
         InputStream in3 = new FileInputStream(new File("c:\\test\\3-temp-第01章_Java开发入门_01_计算机基本概念与DOS命令.avi"));
         InputStream in4 = new FileInputStream(new File("c:\\test\\4-temp-第01章_Java开发入门_01_计算机基本概念与DOS命令.avi"));
         InputStream in5 = new FileInputStream(new File("c:\\test\\5-temp-第01章_Java开发入门_01_计算机基本概念与DOS命令.avi"));
         //集合工具类，内部实现使用了数组
         Vector<InputStream> v = new Vector<InputStream>();    
         v.add(in1);
         v.add(in2);
         v.add(in3);
         v.add(in4);
         v.add(in5);
         Enumeration<InputStream> es = v.elements();
         merge(es);
      } catch (FileNotFoundException e) {
         e.printStackTrace();
      }
   }
}

10、合并流、字符串流、管道流

一、合并流：

SequenceInputStream 表示其他输入流的逻辑串联。它从输入流的有序集合开始，并从第一个输入流开始读取， 直到到达文件末尾，接着从第二个输入流读取，依次类推，直到到达包含的最后一个输入流的文件末尾为止。

二、字符串流

1、StringReader 其源为一个字符串的字符流。

2、StringWriter 一个字符流，可以用其回收在字符串缓冲区中的输出来构造字符串。 关闭 StringWriter 无效。此类中的方法在关闭该流后仍可被调用，而不会产生任何 IOException。

package com.vince;
import java.io.IOException;
import java.io.StreamTokenizer;
import java.io.StringReader;
/**
 * 字符串流:以一个字符串为数据源，来构造一个字符流
 * 作用：在WEB开发中，我们经常要从服务器上获取数据，数据的返回格式通过是一个字符串（XML,JSON），我们需要把这个字符串构造成一个字符流
 * 然后再用第三方的数据解析器来解析数据。
 * StringWriter
 * @description
 */
public class StringStreamDemo {
   private static void stringReader(){
      String info = "good good study day day up";
      StringReader sr = new StringReader(info);
      //流标记器
      StreamTokenizer st = new StreamTokenizer(sr);
      int count = 0;
      while(st.ttype != StreamTokenizer.TT_EOF){
         try {
            if(st.nextToken()==StreamTokenizer.TT_WORD){
               count++;
            }
         } catch (IOException e) {
            e.printStackTrace();
         }
      }
      sr.close();
      System.out.println("count="+count);
   }
   public static void main(String[] args) {
      stringReader();
   }
}

三、管道流

管道输入流应该连接到管道输出流；管道输入流提供要写入管道输出流的所有数据字节。通常，数据由某个线程从 PipedInputStream 对象读取，并由其他线程将其写入到相应的 PipedOutputStream。

不建议对这两个对象尝试使用单个线程，因为这样可能死锁线程。管道输入流包含一个缓冲区，可在缓冲区限定的范围内将读 操作和写操作分离开。如果向连接管道输出流提供数据字节的线程不再存在，则认为该管道已损坏。

package com.vince;
import java.io.IOException;
import java.io.PipedInputStream;
import java.io.PipedOutputStream;
/**
 * 管道流测试：一个线程写入，一个线程读取
 * 作用，用于线程之间的数据通讯
 * @description
 */
public class PipedStreamDemo {
   public static void main(String[] args) {
      PipedInputStream pin = new PipedInputStream();  
       PipedOutputStream pout = new PipedOutputStream();  
       try {
         pin.connect(pout); //两个管道进行链接
      } catch (IOException e) {
         e.printStackTrace();
      }  //输入流与输出流连接  
       ReadThread readTh   = new ReadThread(pin);  
       WriteThread writeTh = new WriteThread(pout);  
       new Thread(readTh).start();  
       new Thread(writeTh).start();  
      //读到：你好...
   }
}
//读取数据的线程
class ReadThread implements Runnable {
   private PipedInputStream pin; //输入管道
   ReadThread(PipedInputStream pin){
      this.pin = pin;
   }
   public void run(){
      try {
         byte[] buf = new byte[1024];
         int len = pin.read(buf); // read阻塞
         String s = new String(buf, 0, len);
         System.out.println("读到："+s);
         pin.close();
      } catch (Exception e) {
         e.printStackTrace();
      }
   }
}
//写入数据的线程
class WriteThread implements Runnable {
   private PipedOutputStream pout; //输出管道
   WriteThread(PipedOutputStream pout) {
      this.pout = pout;
   }
   public void run() {
      try {
         pout.write("你好...".getBytes()); // 管道输出流
         pout.close();
      } catch (Exception e) {
         e.printStackTrace();
      }
   }
}

11、RandomAccessFile

RandomAccessFile是IO包的类，从Object直接继承而来。 只可以对文件进行操作，可以对文件进行读取和写入。

当模式为r是，当文件不存在时会报异常，

当模式为rw时，当文件不存在时，会自己动创建文件，当文件已经存在时 不会对原有文件进行覆盖。

RandomAccessFile有强大的文件读写功能，其内部是大型 byte[]，可以通过seek(),getFilePointer()等方法操作的指针，方便对数据进行写入与读取。还可以对基本数据类型进行直接的读和写操作。

RandomAccessFile的绝大多数功能，已经被JDK 1.4的nio的“内存映射文件(memory-mapped files)”给取代了，考虑一下是不是用“内存映射文件”来代替RandomAccessFile了。

package com.vince;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.RandomAccessFile;
/**
 * RandromAccessFile
 * @author vince
 * @description
 */
public class RandromAccessFileDemo {
   public static void main(String[] args) {
      try {
         //读取文件
         RandomAccessFile r = new RandomAccessFile("d:\\3D0.jpg","r");
         //写入文件
         RandomAccessFile w= new RandomAccessFile("d:\\test\\3D0.jpg","rw");
         byte[] bytes = new byte[1024];
         int len = -1;
         while((len=r.read(bytes))!=-1){
            w.write(bytes,0,len);
         }
         w.close();
         r.close();
      } catch (FileNotFoundException e) {
         e.printStackTrace();
      } catch (IOException e) {
         // TODO Auto-generated catch block
         e.printStackTrace();
      }
      System.out.println("copy success.");
   }
}