补：
输入：泛指对某设备进行数据的输入

import java.io.UnsupportedEncodingException;
import java.util.*;
import java.util.Scanner;

public class Main {
	
	public static void main(String args[]) throws UnsupportedEncodingException {
		Scanner sc = new  Scanner(System.in);
		String str="中华人民共和国";
		byte[] bytes = str.getBytes("GBK");
		//以GBK / GB2312编码转化为字节
		System.out.println(bytes.length);
		//输出字符长度：14
		byte[] bytes = str.getBytes("UTF-8");
		//以UTF-8编码转化为字节
		System.out.println(bytes.length);
		//输出字符长度：21
		sc.close();
	}
}

如果是新建.txt文件，系统自动在最前面加入几个字节
在不同编码方式下，得到的字节流不一样。

流（Stream）是从源读取并写入目标的数据序列。
输入流用于从源读取数据。

输出流用于将数据写入目标。

流的类型

根据流包含的数据，可以将其分类为：

字节流
字符流

字节流(Byte)

JAVA.IO
字节流用于读取和写入单个字节（8位）的数据。

所有字节流类都派生自称为InputStream和OutputStream的基本抽象类。

Java InputStream类

抽象类（不能直接new，创建对象）

主要的子类：
　　 1） FileInputStream把一个文件作为InputStream，实现对文件的读取操作
　　 2） ByteArrayInputStream：把内存中的一个缓冲区作为InputStream使用
　　 3） StringBufferInputStream：把一个String对象作为InputStream
　　 4） PipedInputStream：实现了pipe的概念，主要在线程中使用
　　 5） SequenceInputStream：把多个InputStream合并为一个InputStream

** FileInputStream**

常用构造方法：

常用成员方法：

int read()

输入流读取的步骤

import java.io.FileInputStream;
import java.io.IOException;
import java.util.*;
public class Main {
	
	public static void main(String args[]) throws IOException {
		FileInputStream fis=new FileInputStream("E:\\data.txt");
		System.out.println(fis.available());//输出字节长度
		
		//一次读取一个字节，获取ASCII值
		//如果越界，返回-1
		int len=fis.read();//读取了第1个
		System.out.println(len);
		
		len=fis.read();//读取了第2个
		System.out.println(len);
		
		len=fis.read();//读取了第3个
		System.out.println(len);
		
		len=fis.read();//读取了第4个
		System.out.println(len);//如果越界，返回-1
		 long l1=System.currentTimeMillis();
		System.out.println(fis.available());//输出字节长度
		  len=fis.read();
		  while(len!=-1) {
			  System.out.println(len);
			  len=fis.read();
		  }
		  long l2=System.currentTimeMillis();
		  System.out.println(l2-l1);//计算读取时间
		 fis.close();
		 
	}
}

read(bytes)//效率比较高
read（bytes,int begin,int end）//当有需要固定某些字符时候才使用，不常用

import java.io.FileInputStream;
import java.io.IOException;
import java.util.*;
public class Main {
	
	public static void main(String args[]) throws IOException {
		 
		  FileInputStream fis2=new FileInputStream("E:\\data.txt");
		  byte[] bytes=new byte[2];
		int  le=fis2.read(bytes);
		  System.out.println(le);
		  System.out.println(Arrays.toString(bytes));
		  
		  bytes=new byte[2];
		  le=fis2.read(bytes);
		  System.out.println(le);
		  System.out.println(Arrays.toString(bytes));
		  
		  bytes=new byte[2];
		  le=fis2.read(bytes);
		  System.out.println(le);
		  System.out.println(Arrays.toString(bytes));
		  
		  bytes=new byte[2];
		  le=fis2.read(bytes);
		  System.out.println(le);
		  System.out.println(Arrays.toString(bytes));
		  
		  
		  fis2.close();
		  System.out.println("--------------------------");
		  FileInputStream fis3=new FileInputStream("E:\\data.txt");
		  byte[] bytes2=new byte[2];
			int  le2=fis3.read(bytes2);
		  while(le2!=-1) {
			 // System.out.println(le2);
			  //System.out.println(Arrays.toString(bytes2));
			  String strr=new String(bytes2,0,le2);
			  System.out.println(strr);
			  
			  le2=fis3.read(bytes2);
		  }
		//再简化
		while((fis3.read(bytes2)!=-1) {
			  String strr=new String(bytes2,0,le2);
			  System.out.println(strr);
		  }
			  fis3.close();
	}
}

Java OutputStream类

OutputStream的子类
　　 1） FileOutputStream 文件流
　　 2） PipedOutputStream 管道流
　　 3） ObjectOutputStream将对象序列化后写入指定地方
　　 4） ByteArrayOutputStream在字节数组和流之间搭建桥梁
　　 5） SequenceOutputStream 是多种输入流的逻辑串联
　　 6） FilterInputStream 过滤流，在读写数据的同时还可以对数据进行特殊处理

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.*;
public class Main {
	
	public static void main(String args[]) throws IOException, InterruptedException {
		 FileOutputStream fos=new FileOutputStream("data1.dat");
		 fos.write(65);//a
		 fos.write(49);//1
		 fos.write(97);//A
		fos.close();
		
		 byte[] bytes="ceshiceshiceshiceshiceshi123456".getBytes();
		 FileOutputStream fos2=new FileOutputStream("data2.dat");
          fos2.write(bytes);
          fos2.write("测试".getBytes());
          fos2.close();
          
          FileOutputStream fos3=new FileOutputStream("data3.dat");
          byte[] bytes2="测试ceshiceshiceshiceshiceshi123456".getBytes();
         // fos3.write(bytes,2,10);//从2开始写10个字符
          fos3.write(bytes2,0,3);//从2开始写100个字符
         
          fos3.close();
	}
}

Data Output/Input Stream

注意：按什么格式输入，就按什么格式输出。
按某格式输出，只会输出某格式的字符。

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


public class Datatext {
public static void main(String[] args) throws IOException {
DataOutputStream  dos1=
  new DataOutputStream(new FileOutputStream("data2.dat"));
     dos1.writeInt(100);
     dos1.writeLong(2121212121212l);
     dos1.writeUTF("你好sfsafsfsafsf");
DataInputStream dis1=
	new DataInputStream(new FileInputStream("data2.dat"));
	
	int data1=dis1.readInt();
	System.out.println(data1);
	
	long l=dis1.readLong();
	System.out.println(l);
	
	String str1=dis1.readUTF();
	System.out.println(str1);
	dos1.close();
	dis1.close();
}
}

BufferedInputStream

import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class BufferedStreamTest {

	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
        BufferedInputStream bis1=
        		new BufferedInputStream(new FileInputStream("data2.dat"));
       
        long l2=System.currentTimeMillis();
        
        byte[] a=new byte[10000];
      int len=  bis1.read(a);
	    //读一个字节，放在缓冲区（默认为8k/8192字节），还继续在访问，不返回，故效率高
	    System.out.println(len);
	    
	    long l1=System.currentTimeMillis();
	    
	    System.out.println(l1-l2);
	}

}

RandomAccessFileTest

import java.awt.RadialGradientPaint;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.RandomAccessFile;

import org.omg.Messaging.SYNC_WITH_TRANSPORT;

public class RandomAccessFileTest {

	public static void main(String[] args) throws IOException {
		
		//文件指针
		RandomAccessFile raf1=
				new RandomAccessFile("data1.dat", "rw");
		raf1.writeInt(1000);
		raf1.writeDouble(1.1231);
		raf1.writeUTF("13213");
		
		//指针回位
		raf1.seek(0);
		int i=raf1.readInt();
		double d=raf1.readDouble();
		String str1=raf1.readUTF();
		System.out.println(i);
		System.out.println(d);
		System.out.println(str1);
		raf1.close();
		
		
	}

}

字符流(Character )

字符流用于读取和写入单个数据字符。

所有字符流类都派生自基本抽象类Reader和Writer。

Java Reader类

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

public class FileReadWriterTest {

	public static void main(String[] args) throws IOException {
		// 写
		FileWriter writer = // 以字符为单位写数据：“中” 以GBK输入需要2个字节，1个字符
				new FileWriter("data1.txt", false);
		// 默认为覆盖false ，true代表追加。

		writer.write(65);
		writer.write("\n中国\n".toCharArray());
		writer.write("中华人民共和国\n".toCharArray(), 2, 4);
		writer.write("中国人民解放军\n");
		writer.write("中华人民共和国\n", 2, 6);
		writer.close();

		// 读
		FileReader reader = new FileReader("data1.txt");
		char[] chars = new char[5];
		int len = 0;
		while ((len = reader.read(chars)) != -1) {
			System.out.println(chars);
			String str = new String(chars, 0, len);
			System.out.println(str);
		}

	}

}

Java Writer类

输入输出重定向

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintStream;
import java.util.*;
public class Main {
	
	public static void main(String args[]) throws IOException, InterruptedException {
		
		
		//输出重定向
		System.setOut(new PrintStream("data7.txt"));
        System.out.println("sifjisfjdifjdsfidjfifjdsif");
        
          //输入重定向
      		System.setIn(new FileInputStream("data7.txt"));
      		Scanner sc=new Scanner(System.in);
      		String str=sc.next();
      		System.out.println(str);
	}
}

File类

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream.GetField;
import java.io.PrintStream;
import java.util.*;
public class Main {
	
	public static void main(String args[]) throws IOException, InterruptedException {
      File file=new File("E:\\eclipse-workspace\\my\\data1");//绝对路径“/”=="\\"
      System.out.println(file.exists());//文件是否存在
      if(file.exists()) {
    	  file.delete();//只能删除空文件夹/文件。
    	  
      }
      else {
    	  file.mkdir();//创建
      }
      
      file =new File("src/Main.java");//相对路径     “/”=="\\"
      System.out.println(file.exists());
      System.out.println(file.getAbsolutePath());//从相对路径找到绝对路径(不需要文件存在)
      System.out.println(file.getTotalSpace());//如果是真的，则输出文件所在磁盘的容量大小
      System.out.println(file.getFreeSpace());//如果是真的，则输出文件所在磁盘的可用容量的大小
      System.out.println(file.getParent());//返回文件的上一级文件名
      System.out.println(file.getName());//返回文件名
      System.out.println(file.getPath());//返回相对路径
      
      System.out.println(file.lastModified());//返回此抽象路径名表示的文件最后一次被修改的时间。
      
      System.out.println(file.length());//返回文件大小（字节数）
      
      file=new File("abc.txt");
      System.out.println(file.exists());
      file.createNewFile();//创建新文件.txt
      System.out.println(file.exists());
      
      
    
      
  //    file.deleteOnExit();//虚拟机执行结束/程序结束时候再删除文件；
	}
}

List系列方法

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FilenameFilter;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream.GetField;
import java.io.PrintStream;
import java.nio.file.DirectoryStream.Filter;
import java.util.*;

import org.omg.CosNaming.NamingContextExtPackage.StringNameHelper;
public class Main {
	
	public static void main(String args[]) throws IOException, InterruptedException {
      File file=new File("E:\\eclipse-workspace");

      //list
      String[]  files=file.list();//返回目录中的文件和目录。
      for(String filename:files) {
    	  System.out.println(filename);
      }
      String[] files1=  file.list(new FilenameFilter() {//匿名内部类
		
		
		public boolean accept(File dir, String name) {
		//	System.out.println(dir);//父路径
		//	System.out.println(name);//文件名称
			if(name.endsWith(".txt")) return true;
			else 
			return false;//返回false的不能被输出
		}
	});
         for(String afile:files1) {
        	 System.out.println(afile);
         }
	}
}