通过流可以读写文件，流是一组有序列的数据序列，以先进先出方式发送信息的通道。
输入/输出流抽象类有两种：InputStream/OutputStream字节输入流和Reader/Writer字符输入流。
一、字节流
1.InputStream类
int read()：从输入流中读取下一个字节，并返回该字节对应的整型数字 0-255。
int read(byte[ ] b)：从输入流中读取多个字节，并将字节存放到数组b[ ]中，返回读到的字节个数，即数组长度。
int read(byte[ ] b ,int off ,int len)：从输入流中读取多个字节，并将字节存放到数组b[ ]中，从数组的off位置处开始存放，len是读到的字节个数。
2.OutputStream类
字节流输入步骤：
1.引用相关类；
2.创建FileInputStream类对象；
3.读取文本文件；
4.关闭流。
字节流输出步骤：
1.引用相关类；
2.创建FileOutputStream类对象；
3.写入文本文件；
4.关闭流。
案例：
package com.yh.filestring; import java.io.*; public class FileTest2 { public static void main(String[] args) { // 创建目录 File dir = new File("d:/eclipseWJ/HelloWorld/FileTest2"); dir.mkdirs(); // 创建文件 File file = new File("d:/eclipseWJ/HelloWorld/FileTest2/test2.txt"); FileOutputStream fos = null; FileInputStream fis = null; try {
if(!file.exists()) file.createNewFile(); fos = new FileOutputStream(file,true); // 在文件原有的内容上追加
fos = new FileOutputStream(file); // 直接覆盖文件原有的内容 String str = "学习Java!"; byte[] words = str.getBytes(); fos.write(words, 0, words.length); // 创建输入流对象 fis = new FileInputStream(file); int data; while ((data = fis.read()) != -1) { System.out.print((char) data); } } catch (FileNotFoundException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } finally { // 关闭输入流 try { fos.close(); fis.close(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } } } }
案例：将file1中的内容复制到file2
package com.yh.filestring; import java.io.*; public class FileCopy { public static void main(String[] args) { File dir = new File("D:/eclipseWJ/HelloWorld/filecopy"); File file1 = new File("D:/eclipseWJ/HelloWorld/filecopy/file1.txt"); File file2 = new File("d:/eclipseWJ/HelloWorld/filecopy/file2.txt"); dir.mkdirs(); FileInputStream fis = null; FileOutputStream fos = null; try {
if(!file1.exists()) file1.createNewFile();
if(!file2.exists()) file2.createNewFile(); fos = new FileOutputStream(file1); String str = "HelloWorld"; byte[] words = str.getBytes(); fos.write(words, 0, str.length()); fos.close(); fis = new FileInputStream(file1); fos = new FileOutputStream(file2, true); int len; byte[] word = new byte[1024]; while ((len = fis.read(word)) != -1) { // 读取到的字节存到数组word[]中，追加存储 fos.write(word,0,len); } fis.close(); fis = new FileInputStream(file2); int data; while ((data = fis.read()) != -1) { System.out.print((char)data); } } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } finally { try { fis.close(); fos.close(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } } } }
二、字符流
1.Reader类
Reader类常用方法：
int read()：从输入流中读取下一个字符，并返回该字符对应的整型数字 0-65535。
int read(char[ ] c)：从输入流中读取多个字符，并将字符存放到数组b[ ]中，返回读到的字符个数，即数组长度。
int read(char[ ] c ,int off ,int len)：从输入流中读取多个字符，并将字符存放到数组b[ ]中，从数组的off位置处开始存放，len是读到的字符个数。
子类InputStreamReader常用构造方法：
InputStreamReader(InputStream in)：参数是一个字节流对象，将一个字节流包装成字符流，读取内容按本地平台默认编码。
InputStreamReader(InputStream in ,String charserName)：参数是一个字节流对象和字符集编码，先将字节流包装成字符流，然后再按照这个字符集编码来读取到内容。
步骤：
1.创建FileInputStream类对象（字节流）；
2.创建InputStreamReader类对象，并将FileInputStream类对象和字符集编码名字作为构造函数的参数（字符流）；
3.创建BufferedReader类对象，并将InputStreamReader类对象作为构造函数的参数（字符流）；
4.读取文本。
代码示例（较为综合）：
package com.yh.filestring; import java.io.*; public class InputStreamReaderDemo { public static void main(String[] args) { // TODO Auto-generated method stub File file = new File("D:\eclipseWJ\HelloWorld\Chapter\File3.txt"); InputStream is = null; Reader isr = null; BufferedReader br = null; try { is = new FileInputStream(file); isr = new InputStreamReader(is,"UTF-8"); br = new BufferedReader(isr); StringBuffer bf = new StringBuffer(); String line = null; if((line = br.readLine())!=null) { bf.append(line); } System.out.println(bf); } catch (FileNotFoundException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } finally { try { br.close(); isr.close(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } } } }
文本文件读取类FileReader是InputStreamReader的子类：
构造方法：
FileReader(File file)
FileReader(String pathName)
FileReader只能按照本地平台的字符编码来读，不能通过用户特定的字符集编码来读。
本地平台字符集编码获得：String encoding = System.getProperty("file.encoding");
使用FileReader类读取文本步骤：
1.引用相关类；
2.创建FileReader类对象；
3.读取文本文件；
4.关闭流。
代码示例：
package com.yh.filestring; import java.io.*; public class FileReaderDemo { public static void main(String[] args) { FileReader filereader; try { filereader = new FileReader("d:/eclipseWJ/HelloWorld/FileTest2/test2.txt"); StringBuffer sbf = new StringBuffer(); char[] words = new char[1024]; while(filereader.read(words)!=-1) { // while只执行一次 sbf.append(words); } System.out.println(sbf); } catch (FileNotFoundException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } } }
BufferReader类：带有缓冲区的字符输入流
代码示例：
package com.yh.filestring; import java.io.*; public class FileTestBuffer { public static void main(String[] args) { BufferedReader reader = null; try { // 创建目录 File dir = new File("Chapter"); dir.mkdirs(); // 创建文件 File f = new File("D:\eclipseWJ\HelloWorld\Chapter\File1.txt"); f.createNewFile(); // 写入文本 FileWriter writer = new FileWriter(f); // 覆盖重写
FileWriter writer = new FileWriter(f, true); // 追加 BufferedWriter bufferedwriter = new BufferedWriter(writer); bufferedwriter.write("你好");
bufferedwriter.flush(); //将缓冲区的内容全部写入文本 bufferedwriter.close(); // 输出目录中的文件 if (dir.isDirectory()) { String[] fileContents = dir.list(); for (String i : fileContents) System.out.println(i); } // 读出文件内容 FileReader fileReader = new FileReader(f); reader = new BufferedReader(fileReader); String line = null; while ((line = reader.readLine()) != null) System.out.println(line); } catch (FileNotFoundException ex) { ex.printStackTrace(); } catch (IOException ex) { ex.printStackTrace(); }finally { try { reader.close(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } } } }
2.Writer类
参考上述Reader类。
三、读写二进制文件
读取特定图片并完成该图片的复制
代码示例：
package com.yh.filestring; import java.io.*; public class FIleImg { public static void main(String[] args) { // TODO Auto-generated method stub FileInputStream fis = null; DataInputStream dis = null; FileOutputStream fos = null; DataOutputStream dos = null; try { fis = new FileInputStream("D:\eclipseWJ\HelloWorld\fish.jpg"); dis = new DataInputStream(fis); fos = new FileOutputStream("D:\eclipseWJ\HelloWorld\newfish.jpg"); dos = new DataOutputStream(fos); int data; while ((data = dis.read()) != -1) { dos.write(data); } //dos.flush(); } catch (FileNotFoundException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } finally { try { dos.close(); fos.close(); dis.close(); fis.close(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } } } }
四、序列化和反序列化
五、总结
1.类的继承关系总结：
InputStream类（字节流）—— FileInputStream类 —— DataInputStream类（读取二进制文件）
OutputStream类（字节流）—— FileOutputStream类 —— DataOutputStream类（写入二进制文件）
Reader类（字符流）—— InputStreamReader类（构造函数参数：一个字节流InputStream类对象和字符集编码名字）和BufferedReader类（构造函数参数：一个Reader对象，提供通用的缓冲方式文本读取，readLine读取一个文本行）—— FileReader类（构造函数参数：File类对象或完整路径，无法指定字符集编码）
Writer类（字符流）—— OutputStreamWriter类（构造函数参数：一个字节流OutputStream类对象和字符集编码名字）和BufferedWriter类（构造函数参数：一个Writer对象，提供通用的缓冲方式文本写入）—— FileWriter类（构造函数参数：File类对象或完整路径，无法指定字符集编码）
2.字节和字符的关系：
Java采用unicode来表示字符，java中的一个char是2个字节，一个中文或英文字符的unicode编码都占2个字节，但如果采用其他编码方式，一个字符占用的字节数则各不相同。
在 GB-2312 编码或 GBK 编码中，一个英文字母字符存储需要1个字节，一个汉子字符存储需要2个字节。
在UTF-8编码中，一个英文字母字符存储需要1个字节，一个汉字字符储存需要3到4个字节。
在UTF-16编码中，一个英文字母字符存储需要2个字节，一个汉字字符储存需要3到4个字节（Unicode扩展区的一些汉字存储需要4个字节）。
在UTF-32编码中，世界上任何字符的存储都需要4个字节。
3.flush()方法
在进行文件写入相关操作时，需要调用。