一、字节流：
IO异常的处理
代码实现:
1 public class FileOutputStreamDemo3 { 2 public static void main(String[] args) { 3 File file = new File("c:\file.txt"); 4 //定义FileOutputStream的引用 5 FileOutputStream fos = null; 6 try { 7 //创建FileOutputStream对象 8 fos = new FileOutputStream(file); 9 //写出数据 10 fos.write("abcde".getBytes()); 11 } catch (IOException e) { 12 System.out.println(e.toString() + "----"); 13 throw new RuntimeException("文件写入失败，重试"); 14 15 } finally { 16 //一定要判断fos是否为null，只有不为null时，才可以关闭资源 17 if (fos != null) { 18 try { 19 fos.close(); 20 } catch (IOException e) { 21 throw new RuntimeException("关闭资源失败"); 22 } 23 } 24 } 25 } 26 }
1、字节输出流OutputStream
OutputStream此抽象类，是表示输出字节流的所有类的超类。操作的数据都是字节，定义了输出字节流的基本共性功能方法。
输出流中定义都是写write方法，如下图:
OutputStream有很多子类，其中子类FileOutputStream可用来写入数据到文件。
FileOutputStream类，即文件输出流，是用于将数据写入 File的输出流。
关系
构造方法
代码实现：
public static void main(String[] args) throws IOException { //FileOutputStream的构造方法：如果文件存在，则覆盖，如果不存在，则创建 // 换行 FileOutputStream fos=new FileOutputStream("x:\test\bian.txt",true);//续写 /*fos.write(49); fos.write(48); fos.write(48);*/ /*byte[] bytes={-65,-66,-67,-68}; fos.write(bytes,1,2);*/ fos.write("xuezhiqian ".getBytes()); //字符串转字节 /*new String(bytes);*/ //字节转字符串 fos.close(); }
2、字节输入流InputStream
常用方法：
FileInputStream类
构造方法：
FileInputStream类读取数据read方法
代码实现：
1 public static void main(String[] args) throws IOException { 2 FileInputStream fis=new FileInputStream("x:\test\test.txt"); 3 int len=0; 4 while((len=fis.read())!=-1){ 5 System.out.println((char)len);//转字符 6 } 7 /*int a=fis.read(); 8 System.out.println((char)a); 9 int b=fis.read(); 10 System.out.println((char)b); 11 int c=fis.read(); 12 System.out.println((char)c); 13 int d=fis.read(); 14 System.out.println((char)d); 15 int e=fis.read(); 16 System.out.println((char)e); 17 int f=fis.read(); 18 System.out.println((char)f);*/ 19 /*char ch=97; 20 System.out.println(ch);*/ 21 fis.close(); 22 } 23 }
读取数据read(byte[])方法
代码实现：
1 public class InputStreamDemo2 { 2 public static void main(String[] args) throws IOException { 3 FileInputStream fis=new FileInputStream("x:\test\test.txt"); 4 byte[] bytes=new byte[2]; 5 int len=0; 6 while((len=fis.read(bytes))!=-1){ 7 System.out.println(new String(bytes,0,len)); 8 } 9 /* //第一次读 10 int len=fis.read(bytes); 11 System.out.println(len); 12 System.out.println(new String(bytes)); 13 //第二次读 14 len=fis.read(bytes); 15 System.out.println(len); 16 System.out.println(new String(bytes)); 17 //第三次读 18 len=fis.read(bytes); 19 System.out.println(len); 20 System.out.println(new String(bytes)); 21 //第4次读 22 len=fis.read(bytes); 23 System.out.println(len); 24 System.out.println(new String(bytes));*/ 25 fis.close(); 26 } 27 28 }
字节流复制文件
代码实现：
public class CopyDemo { 2 public static void main(String[] args) throws IOException { 3 long time1=System.currentTimeMillis(); 4 //1.明确数据源（要复制哪个文件） 5 FileInputStream fis=new FileInputStream("C:\Program Files\java\eclipse.zip"); 6 //2.明确目的地（要复制到哪个文件） 7 FileOutputStream fos=new FileOutputStream("x:\test\d\java.txt"); 8 //3.复制 9 int len=0; 10 while((len=fis.read())!=-1){ 11 fos.write(len); 12 } 13 long time2=System.currentTimeMillis(); 14 System.out.println(time2-time1); 15 //4.释放资源 16 fis.close(); 17 fos.close(); 18 } 19 20 }
3、缓冲字节流
①写入数据到流中，字节缓冲输出流 BufferedOutputStream
②读取流中的数据，字节缓冲输入流 BufferedInputStream
它们的内部都包含了一个缓冲区，通过缓冲区读写，就可以提高了IO流的读写速度
字节缓冲输出流BufferedOutputStream
构造方法：
public BufferedOutputStream(OutputStream out)创建一个新的缓冲输出流，以将数据写入指定的底层输出流。
代码实现：
1 //缓冲字节输出流 2 public static void method1() throws IOException{ 3 FileOutputStream fos=new FileOutputStream("e:\test\haha",true); 4 BufferedOutputStream bos=new BufferedOutputStream(fos); 5 //bos.write(100); 6 bos.write("你好啊".getBytes()); 7 bos.close(); 8 }
字节缓冲输入流 BufferedInputStream
构造方法：
public BufferedInputStream(InputStream in)
代码实现：
1 //缓冲字节输入流 2 public static void method2() throws IOException{ 3 FileInputStream fis=new FileInputStream("e:\test\haha"); 4 BufferedInputStream bis=new BufferedInputStream(fis); 5 int len=0; 6 while((len=bis.read())!=-1){ 7 System.out.print((char)len); 8 } 9 bis.close(); 10 }
对比字节流read()，字节流read(byte [])，缓冲字节流read()，缓冲字节流read(byte [])它们的速度
1 //字节流read() 2 public static void method1() throws IOException{ 3 long time1=System.currentTimeMillis(); 4 FileInputStream fis=new FileInputStream("d:\DW\jdk\javafx-src.zip"); 5 FileOutputStream fos=new FileOutputStream("e:\test\text\haha1.zip"); 6 int len=0; 7 while((len=fis.read())!=-1){ 8 fos.write(len); 9 } 10 long time2=System.currentTimeMillis(); 11 System.out.println(time2-time1); 12 fis.close(); 13 fos.close(); 14 } 15 //字节流read(byte []) 16 public static void method2() throws IOException{ 17 long time1=System.currentTimeMillis(); 18 FileInputStream fis=new FileInputStream("d:\DW\jdk\javafx-src.zip"); 19 FileOutputStream fos=new FileOutputStream("e:\test\text\haha2.zip"); 20 int len=0; 21 byte[] bytes=new byte[1024]; 22 while((len=fis.read(bytes))!=-1){ 23 fos.write(bytes, 0, len); 24 } 25 long time2=System.currentTimeMillis(); 26 System.out.println(time2-time1); 27 fis.close(); 28 fos.close(); 29 } 30 //缓冲字节流read() 31 public static void method3() throws IOException{ 32 long time1=System.currentTimeMillis(); 33 FileInputStream fis=new FileInputStream("d:\DW\jdk\javafx-src.zip"); 34 BufferedInputStream bis=new BufferedInputStream(fis); 35 FileOutputStream fos=new FileOutputStream("e:\test\text\haha3.zip"); 36 BufferedOutputStream bos=new BufferedOutputStream(fos); 37 int len=0; 38 while((len=bis.read())!=-1){ 39 bos.write(len); 40 } 41 long time2=System.currentTimeMillis(); 42 System.out.println(time2-time1); 43 fis.close(); 44 fos.close(); 45 } 46 //缓冲字节流read(byte []) 47 public static void method4() throws IOException{ 48 long time1=System.currentTimeMillis(); 49 FileInputStream fis=new FileInputStream("d:\DW\jdk\javafx-src.zip"); 50 BufferedInputStream bis=new BufferedInputStream(fis); 51 FileOutputStream fos=new FileOutputStream("e:\test\text\haha4.zip"); 52 BufferedOutputStream bos=new BufferedOutputStream(fos); 53 int len=0; 54 byte[] bytes=new byte[1024]; 55 while((len=bis.read(bytes))!=-1){ 56 bos.write(bytes, 0, len); 57 } 58 long time2=System.currentTimeMillis(); 59 System.out.println(time2-time1); 60 fis.close(); 61 fos.close(); 62 }
结果：
速度总结：（慢——>快）
字节流read() < 缓冲字节流read() < 字节流read(byte []) < 缓冲字节流read(byte [])
二、字符流
字节流读取字符的问题
代码实现：
1 public class CharStreamDemo { 2 public static void main(String[] args) throws IOException { 3 //给文件中写中文 4 writeCNText(); 5 //读取文件中的中文 6 readCNText(); 7 } 8 //读取中文 9 public static void readCNText() throws IOException { 10 FileInputStream fis = new FileInputStream("c:\cn.txt"); 11 int ch = 0; 12 while((ch = fis.read())!=-1){ 13 System.out.println(ch); 14 } 15 } 16 //写中文 17 public static void writeCNText() throws IOException { 18 FileOutputStream fos = new FileOutputStream("c:\cn.txt"); 19 fos.write("欢迎你".getBytes()); 20 fos.close(); 21 } 22 }
1.字符输入流Reader
基础方法：
FileReader类
代码实现:
public class ReaderDemo { public static void main(String[] args) throws IOException { //通过字符数组的方式读 FileReader fr=new FileReader("x:\test\test.txt"); int len=0; char[] ch=new char[1024]; while((len=fr.read(ch))!=-1){ System.out.println(new String(ch,0,len)); } fr.close(); //method1(fr); } public static void method1(FileReader fr) throws IOException{ //通过一个字符一个字符的方法读 int len=0; while((len=fr.read())!=-1){ System.out.print((char)len); } fr.close(); } }
2.字符输入流writer
基础方法：
FileWriter类
构造方法：
字符流复制文件代码实现：
1 public class JpgCopy1 { 2 //字符流复制文件 3 public static void main(String[] args) throws IOException { 4 //1.明确数据源 5 FileReader fr=new FileReader("X:\test\img1.jpg"); 6 //2.明确目的地 7 FileWriter fw=new FileWriter("x:\test\a\img1.jpg"); 8 //3.复制 9 int len=0; 10 char[] ch=new char[1024]; 11 while((len=fr.read(ch))!=-1){ 12 fw.write(ch, 0, len); 13 } 14 //4.释放资源 15 fr.close(); 16 fw.close(); 17 } 18 }
flush()和close()的区别
close是在关闭之前刷新一次
flush是一边存一边刷
代码实现：
1 public class WriterDemo { 2 public static void main(String[] args) throws IOException { 3 //写入中文字符 4 FileWriter fw=new FileWriter("x:\test\test.txt"); 5 fw.write("你好"); 6 fw.flush();//可刷新多次 7 //fw.close();//具有一次刷新功能 8 } 9 }
3.字符缓冲输出流 BufferedWriter
将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。
方法：newLine() 根据当前的系统，写入一个换行符
1 //缓冲字符输出流 2 //bw.newLine();换行可以实现平台无关性 3 //win 换行 4 //linux 换行 5 public static void method5() throws IOException{ 6 FileWriter fw=new FileWriter("E:\test\test.txt"); 7 BufferedWriter bw=new BufferedWriter(fw); 8 bw.write("你好吗".toCharArray());//字符转字符数组 9 bw.flush(); 10 bw.write("我很好"); 11 bw.newLine();//换行 12 bw.flush(); 13 bw.newLine(); 14 bw.write(100); 15 bw.close(); 16 }
4.字符缓冲输入流 BufferedReader
从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。
方法：readLine() 读取一个文本行，包含该行内容的字符串，不包含任何行终止符，如果已到达流末尾，则返回 null
代码实现：
public class BufferedReaderDemo { public static void main(String[] args) throws IOException { //1,创建流 FileReader fr=new FileReader("file.txt") BufferedReader in = new BufferedReader(fr); //2，读数据 //一次一个字符 //一次一个字符数组 //一次读取文本中一行的字符串内容 String line = null; while( (line = in.readLine()) != null ){ System.out.println(line); } //3,关闭流 in.close(); } }
使用字符缓冲流完成文本文件的复制
public class CopyTextFile { public static void main(String[] args) throws IOException { //1，指定数据源， 是数据源中读数据，采用输入流 BufferedReader in = new BufferedReader(new FileReader("file.txt")); //2,指定目的地，是把数据写入目的地，采用输出流 BufferedWriter out = new BufferedWriter(new FileWriter("copyFile.txt")); //3,读数据 String line = null; while ( (line = in.readLine()) != null ) { //4，写数据 out.write(line); //写入换行符号 out.newLine(); out.flush(); } //5，关闭流 out.close(); in.close(); } }
总结：流的操作规律
IO流中对象很多，解决问题(处理设备上的数据时)到底该用哪个对象呢？
把IO流进行了规律的总结(四个明确)：
明确一：要操作的数据是数据源还是数据目的。
源：InputStream Reader
目的：OutputStream Writer
先根据需求明确要读，还是要写。
明确二：要操作的数据是字节还是文本呢？
源：
字节：InputStream
文本：Reader
目的：
字节：OutputStream
文本：Writer
已经明确到了具体的体系上。
明确三：明确数据所在的具体设备。
源设备：
硬盘：文件 File开头。
内存：数组，字符串。
键盘：System.in;
网络：Socket
目的设备：
硬盘：文件 File开头。
内存：数组，字符串。
屏幕：System.out
网络：Socket
完全可以明确具体要使用哪个流对象。
明确四：是否需要额外功能呢？
额外功能：
转换吗？转换流。InputStreamReader OutputStreamWriter
高效吗？缓冲区对象。BufferedXXX