黑马程序员_java IO流

——- android培训、java培训、期待与您交流！ ———-
IO(Input Output)流

概述
IO流用来处理设备之间的数据传输, Java对数据的操作是通过流的方式, Java用于操作流的对象都在IO包中。

结构
流按流向分为：输入流，输出流。
流按操作数据分为两种：字节流与字符流。
字节流：InputStream,OutputStream 字符流：Reader,Writer

 InputStream：字节输入流的所有类的超类
      ByteArrayInputStream：含缓冲数组，读取内存中字节数组的数据，未涉及流
      FileInputStream：从文件中获取输入字节。媒体文件
      BufferedInputStream：带有缓冲区的字节输入流
      DataInputStream：数据输入流，读取基本数据类型的数据
      ObjectInputStream：用于读取对象的输入流
      PipedInputStream：管道流，线程间通信，与PipedOutputStream配合使用
      SequenceInputStream：合并流，将多个输入流逻辑串联

 OutputStream：此抽象类是表示输出字节流的所有类的超类
      ByteArrayOutputStream：含缓冲数组，将数据写入内存中的字节数组，未涉及流
      FileOutStream：文件输出流，将数据写入文件
      BufferedOutputStream：带有缓冲区的字节输出流
      PrintStream：打印流，作为输出打印
      DataOutputStream：数据输出流，写入基本数据类型的数据
      ObjectOutputStream：用于写入对象的输出流
      PipedOutputStream：管道流，线程间通信，与PipedInputStream配合使用

 Reader：读取字符流的抽象类
      BufferedReader：将字符存入缓冲区，再读取
      LineNumberReader：带行号的字符缓冲输入流
      InputStreamReader：转换流，字节流和字符流的桥梁，多在编码的地方使用
      FileReader：读取字符文件的便捷类。

 Writer：写入字符流的抽象类
      BufferedWriter：将字符存入缓冲区，再写入
      OutputStreamWriter：转换流，字节流和字符流的桥梁，多在编码的地方使用
      FileWriter：写入字符文件的便捷类。

IO异常处理方式
1.在try的外边建立引用，在try内进行初始化
2.在finally里要定义.closs()方法，一定执行关闭流
3.要对.close()判断流不等于空
字符流基本操作数据的对象
文件的续写
FileWriter(String filename,boolean append):根据给定的文件名以及指示是否附加写入数据的boolean值来构造FileWriter对象。append：一个boolean值，如果为true，则将数据写入文件末尾处，而不是写入文件开始处。
注意：在Windows中回车符是由两个字符来表示，\r\n。
文本文件读取方式一
示例：读取单个字符
[java] view plaincopy在CODE上查看代码片派生到我的代码片
FileReader fr = new FileReader(“demo.txt”);//这里会出现：FileNotFoundException文件没找到异常。
Int ch = 0;
While((ch = fr.read())!=-1){//如果没有读到最后一个
System.out.println((char)ch);//需要强转
}
fr.close();
文本文件读取方式二
示例：通过字符数组进行读取
[java] view plaincopy在CODE上查看代码片派生到我的代码片
FileReader fr = new FileReader(“demo.txt”);
char[] buf = new char[1024];//一般缓冲区设置为1024的整数倍
Int len = 0;
While((len = fr.read(buf))!=-1){
System.out.print(new String(buf,0,len));
}
fr.close();
拷贝文本文件
方式一：读取一个字符就写一个字符，这个方法很慢。
示例：
[java] view plaincopy在CODE上查看代码片派生到我的代码片
FileWriter fw = new FileWriter(“demo_copy.txt”);//创建目的地
FileReader fr = new FileReader(“demo.txt”);//与已有文件关联
int ch = 0;
while((ch = fr.read())!=-1){
fw.write(ch);
}
fw.close();
fr.close();
方式二：先存起来在一起读出来。
示例：
[java] view plaincopy在CODE上查看代码片派生到我的代码片
FileWriter fw = null;
FileReader fr = null;
try
{
fw = new FileWriter(“SystemDemo_copy.txt”);
fr = new FileReader(“SystemDemo.java”);
char[] buf = new char[1024];
int len = 0;
while((len=fr.read(buf))!=-1)
{
fw.write(buf,0,len);
}
}
catch (IOException e)
{
throw new RuntimeException(“读写失败”);
}
finally
{
if(fr!=null)
try
{
fr.close();
}
catch (IOException e){}
if(fw!=null)
try
{
fw.close();
}
catch (IOException e){}
}
字符流缓冲区
缓冲区的出现提高了对数据的读写效率，缓冲区要结合流才可以使用，它是在流的基础上对流的功能进行了增强。
BufferWriter：写入流缓冲区。该缓冲区提供了一个跨平台的换行符：newLine()；
BufferReader:读取流缓冲区。该缓冲区提供一个一次读一行的方法:readLine,方便对文本数据的获取。当返回null时读到文件末尾。
通过缓冲区复制文本文件
示例：
[java] view plaincopy在CODE上查看代码片派生到我的代码片
/*
通过缓冲区复制一个.java文件。
*/
import java.io.*;
class CopyTextByBuf
{
public static void main(String[] args)
{
BufferedReader bufr = null;
BufferedWriter bufw = null;
try
{
bufr = new BufferedReader(new FileReader(“BufferedWriterDemo.java”));
bufw = new BufferedWriter(new FileWriter(“bufWriter_Copy.txt”));
String line = null;
while((line=bufr.readLine())!=null)
{
bufw.write(line);
bufw.newLine();
bufw.flush();
}
}
catch (IOException e)
{
throw new RuntimeException(“读写失败”);
}
finally
{
try
{
if(bufr!=null)
bufr.close();
}
catch (IOException e)
{
throw new RuntimeException(“读取关闭失败”);
}
try
{
if(bufw!=null)
bufw.close();
}
catch (IOException e)
{
throw new RuntimeException(“写入关闭失败”);
}
}
}
}
装饰设计模式
当想要对已有的对象进行功能增强时，可以定义类，将已有对象传入，基于已有的功能，并提供加强功能。那么自定义的该类称为装饰类。

装饰与继承的区别
装饰模式比继承要灵活。避免了继承体系臃肿,而且降低了类于类之间的关系。
装饰类因为增强已有对象，具备的功能和已有的是相同的，只不过提供了更强功能。
所以装饰类和被装饰类通常是都属于一个体系中的。
LineNumberReader：是BufferedReader的子类。跟踪行号的缓冲字符输入流。
.getLineNumber():获取行号。
字节流基本操作数据的对象
操作数据
FileOutputStream：写入字节数据。如果没有指定缓冲区，它可以不用刷新的，但还是要关资源。
FileIntputStream：读取字节数据。与字符流一样有两种方式。
int available();返回此输入流下一个方法调用可以不受阻塞地从此输入流读取(或跳过)的估计字节数。作用：可以定义一个刚刚好的缓冲区：byte[] buf = new byte[.available()];不用在循环了。
注意：这种方法容易内存溢出异常，所以要慎用。
复制一个图片
示例：
[java] view plaincopy在CODE上查看代码片派生到我的代码片
/*
思路：
1，用字节读取流对象和图片关联。
2，用字节写入流对象创建一个图片文件。用于存储获取到的图片数据。
3，通过循环读写，完成数据的存储。
4，关闭资源。
*/
import java.io.*;
class CopyPic
{
public static void main(String[] args)
{
FileOutputStream fos = null;
FileInputStream fis = null;
try
{
fos = new FileOutputStream(“c:\2.bmp”);
fis = new FileInputStream(“c:\1.bmp”);
byte[] buf = new byte[1024];
int len = 0;
while((len=fis.read(buf))!=-1)
{
fos.write(buf,0,len);
}
}
catch (IOException e)
{
throw new RuntimeException(“复制文件失败”);
}
finally
{
try
{
if(fis!=null)
fis.close();
}
catch (IOException e)
{
throw new RuntimeException(“读取关闭失败”);
}
try
{
if(fos!=null)
fos.close();
}
catch (IOException e)
{
throw new RuntimeException(“写入关闭失败”);
}
}
}
}
字节流缓冲区
复制mp3文件
示例：通过缓冲区来复制
[java] view plaincopy在CODE上查看代码片派生到我的代码片
import java.io.*;
class CopyMp3
{
public static void main(String[] args) throws IOException
{
long start = System.currentTimeMillis();//查看拷贝时间
copy_1();
long end = System.currentTimeMillis();
System.out.println((end-start)+”毫秒”);
}
//通过字节流的缓冲区完成复制。
public static void copy_1()throws IOException
{
BufferedInputStream bufis = new BufferedInputStream(new FileInputStream(“c:\0.mp3”));
BufferedOutputStream bufos = new BufferedOutputStream(new FileOutputStream(“c:\1.mp3”));
int by = 0;
while((by=bufis.read())!=-1)
{
bufos.write(by);
}
bufos.close();
bufis.close();
}
}
转换流：将字节转换为字符，可通过相应的编码表获得
转换流都涉及到字节流和编码表
读取键盘录入
InputStream in = System.in;
读取转换流
InputStreamReader：是字节流通向字符流的桥梁。
BufferedReader buf = new BufferedReader(newInputStreamReader(System.in));//定义一个键盘输入流
写入转换流
OutputStreamReader：是字符流通向字节流的桥梁。
BufferedWriter buf = new BufferedWriter(new OutputStreamReader(System.out));
流操作规律：
明确源和目的：
数据源：读取，InputStream和Reader
目的：写入：OutputStream和Writer
数据是否是纯文本：
是：字符流，Reader，Writer
否：字节流，InputStream，OutStream
明确数据设备：也是明确要操作的对象
源设备：内存、硬盘、键盘(System.in)
目的设备：内存、硬盘、控制台
是否提高效率：用BufferedXXX
是否需要指定编码表：转换流
OutputStreamWriter(OutputStream out,String charsetName)
InputStreamReader(InputStream in,String charsetName)
System类其他操作
改变标准输入输出设备，在System类中
setIn(InputStream in):重新分配”标准”输入流。setOut(PrintStream out): 重新分配”标准”输出流。
异常的日志信息
把异常信息存到文件里
示例：
[java] view plaincopy在CODE上查看代码片派生到我的代码片
import java.io.*;
import java.util.*;
import java.text.*;
class ExceptionInfo
{
public static void main(String[] args)
{
try
{
int[] arr = new int[2];
System.out.println(arr[3]);
}
catch (Exception e)
{
try
{
Date d = new Date();
SimpleDateFormat sdf = new SimpleDateFormat(“yyyy-MM-dd HH:mm:ss”);
String s = sdf.format(d);
PrintStream ps = new PrintStream(“exeception.log”);
ps.println(s);
System.setOut(ps);
}
catch (IOException ex)
{
throw new RuntimeException(“日志文件创建失败”);
}
e.printStackTrace(System.out);
}
}
}
系统信息
示例：
[java] view plaincopy在CODE上查看代码片派生到我的代码片
import java.util.*;
import java.io.*;
class SystemInfo
{
public static void main(String[] args) throws IOException
{
Properties prop = System.getProperties();
prop.list(new PrintStream(“sysinfo.txt”));
}
}

总结：
缓存技术的最终原理就是这个对象里面封装了数组，缓冲区的关闭其实是关闭缓冲区的流对象。
readLine方法返回的时候只返回回车符之前的数据内容，并不返回回车符。
装饰类通常会通过构造方法接收被装饰的对象，并基于被装饰的对象的功能，提供更强的功能。
不可以用字符流操作媒体文件，字符流只用来处理文字数据。
需要明确编码表就要用转换流。
——- android培训、java培训、期待与您交流！ ———-