IO流3

IO流（字节流File读写操作）
字符流：
FileReader
FileWriter。


BufferedReader
BufferedWriter


字节流：
InputStream（读）  OutputStream（写）

3.OutputStream抽象类
   1）此抽象类是表示输出字节流的所有类的超类。输出流接受输出字节并将这些字节发送到某个接收器。


   需要定义 OutputStream 子类的应用程序必须始终提供至少一种可写入一个输出字节的方法。
   2）方法：
  <1> void close() 
     关闭此输出流并释放与此流有关的所有系统资源。 
  <2>void flush() 
     刷新此输出流并强制写出所有缓冲的输出字节。 
  <3>void write(byte[] b) 
     将 b.length 个字节从指定的 byte 数组写入此输出流。 
  <4>void write(byte[] b, int off, int len) 
     将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此输出流。 
  <5>abstract  void write(int b) 
     将指定的字节写入此输出流
 4.OutputStream ----> FileOutputStream
   1）文件输出流是用于将数据写入 File 或 FileDescriptor 的输出流。
   文件是否可用或能否可以被创建取决于基础平台。特别是某些平台
   一次只允许一个 FileOutputStream（或其他文件写入对象）打开文件进行写入。
   在这种情况下，如果所涉及的文件已经打开，则此类中的构造方法将失败。


   FileOutputStream 用于写入诸如图像数据之类的原始字节的流。
   要写入字符流，请考虑使用 FileWriter
   2）构造方法：
  FileOutputStream(File file) 
     创建一个向指定 File 对象表示的文件中写入数据的文件输出流。

需求，想要操作图片数据。这时就要用到字节流。
复制一个图片.
import java.io.*;
class  File1
{
public static void main(String[] args) throws IOException
{
writeFile();
readFile_3();
}


public static void writeFile()throws IOException
{
FileOutputStream fos=new FileOutputStream("fos.txt");
fos.write("abcde".getBytes());
fos.close();
}


public static void readFile_1() throws IOException
{
FileInputStream fis=new FileInputStream("fos.txt");
int ch=0;
while((ch=fis.read())!=-1)
System.out.println((char)ch);
fis.close();
}


public static void readFile_2() throws IOException
{
FileInputStream fis=new FileInputStream("fos.txt");
int ch=0;
byte[] buf=new byte[1024];
while((ch=fis.read(buf))!=-1)
System.out.println(new String(buf,0,ch));
fis.close();
}
public static void readFile_3() throws IOException
{
FileInputStream fis=new FileInputStream("fos.txt");
byte[] buf=new byte[fis.available()];//定义一个刚刚好的缓冲期。不用循环
fis.read(buf);
System.out.println(new String(buf));
}
}

练习：
/*
复制一个图片
思路：
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的复制。通过缓冲区。
BufferedOutputStream
BufferedInputStream
*/
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(（char）by);
}


bufos.close();
bufis.close();



}
}

/*
读取键盘录入。
System.out:对应的是标准输出设备，控制台。
System.in:对应的标准输入设备：键盘。

需求：
通过键盘录入数据。
当录入一行数据后，就将该行数据进行打印。
如果录入的数据是over，那么停止录入。


*/
import java.io.*;
class  ReadIn
{
public static void main(String[] args) throws IOException
{
InputStream in = System.in;
StringBuilder sb = new StringBuilder();


while(true)
{
int ch = in.read();
if(ch=='\r')
continue;
if(ch=='\n')
{
String s = sb.toString();
if("over".equals(s))
break;
System.out.println(s.toUpperCase());
sb.delete(0,sb.length());
}
else
sb.append((char)ch);


}
}
}




通过刚才的键盘录入一行数据并打印其大写，发现其实就是读一行数据的原理。
也就是readLine方法。


能不能直接使用readLine方法来完成键盘录入的一行数据的读取呢？




readLine方法是字符流BufferedReader类中的方法。


而键盘录入的read方法是字节流InputStream的方法。


那么能不能将字节流转成字符流在使用字符流缓冲去的readLine方法呢？


将字节流对象转成字符流对象，使用转换流。InputStreamReader
*/
import java.io.*;


class  TransStreamDemo
{
public static void main(String[] args) throws IOException
{
//获取键盘录入对象。
InputStream in = System.in;


//将字节流对象转成字符流对象，使用转换流。InputStreamReader
InputStreamReader isr = new InputStreamReader(in);


//为了提高效率，将字符串进行缓冲区技术高效操作。使用BufferedReader


BufferedReader bufr = new BufferedReader(isr);


String line = null;


while((line=bufr.readLine())!=null)
{
if("over".equals(line))
break;
System.out.println(line.toUpperCase());
}


bufr.close();


}
}


写入转换流
import java.io.*;


class  TransStreamDemo
{
public static void main(String[] args) throws IOException
{
//键盘录入最常见写法。一次可以写入一行
BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(System.out));
String line = null;
while((line=bufr.readLine())!=null)
{
if("over".equals(line))
break;
bufw.write(line.toUpperCase());
bufw.newLine();
bufw.flush();
}


bufr.close();


}
}

流操作的基本规律：
最痛苦的就是流对象有很多，不知道该用哪一个。


通过三个明确来完成。


1，明确源和目的。
源：输入流。InputStream  Reader
目的：输出流。OutputStream  Writer。
2，操作的数据是否是纯文本。
是：字符流。
不是：字节流。


3，当体系明确后，在明确要使用哪个具体的对象。
通过设备来进行区分：
源设备：内存，硬盘。键盘
目的设备：内存，硬盘，控制台。


练习：
将一个文本文件中数据存储到另一个文件中。复制文件。
源：因为是源，所以使用读取流。InputStream Reader 
是不是操作文本文件。
是！这时就可以选择Reader
这样体系就明确了。


接下来明确要使用该体系中的哪个对象。
明确设备：硬盘。上一个文件。
Reader体系中可以操作文件的对象是 FileReader


是否需要提高效率：是！。加入Reader体系中缓冲区 BufferedReader.




FileReader fr = new FileReader("a.txt");
BufferedReader bufr = new BufferedReader(fr);








目的：OutputStream Writer
是否是纯文本。
是！Writer。
设备：硬盘，一个文件。
Writer体系中可以操作文件的对象FileWriter。
是否需要提高效率：是！。加入Writer体系中缓冲区 BufferedWriter

FileWriter fw = new FileWriter("b.txt");
BufferedWriter bufw = new BufferedWriter(fw);


练习：
需求：将键盘录入的数据保存到一个文件中。
这个需求中有源和目的都存在。
那么分别分析
源：InputStream Reader
是不是纯文本？是！Reader

设备：键盘。对应的对象是System.in.
不是选择Reader吗？System.in对应的不是字节流吗？
为了操作键盘的文本数据方便。转成字符流按照字符串操作是最方便的。
所以既然明确了Reader，那么就将System.in转换成Reader。
用了Reader体系中转换流,InputStreamReader


InputStreamReader isr = new InputStreamReader(System.in);


需要提高效率吗？需要！BufferedReader
BufferedReader bufr = new BufferedReader(isr);






目的：OutputStream  Writer
是否是存文本？是！Writer。
设备：硬盘。一个文件。使用 FileWriter。
FileWriter fw = new FileWriter("c.txt");
需要提高效率吗？需要。
BufferedWriter bufw = new BufferedWriter(fw);


**************
扩展一下，想要把录入的数据按照指定的编码表（utf-8），将数据存到文件中。

目的：OutputStream  Writer
是否是存文本？是！Writer。
设备：硬盘。一个文件。使用 FileWriter。
但是FileWriter是使用的默认编码表。GBK.

但是存储时，需要加入指定编码表utf-8。而指定的编码表只有转换流可以指定。
所以要使用的对象是OutputStreamWriter。
而该转换流对象要接收一个字节输出流。而且还可以操作的文件的字节输出流。FileOutputStream


OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("d.txt"),"UTF-8");


需要高效吗？需要。
BufferedWriter bufw = new BufferedWriter(osw);


所以，记住。转换流什么使用。字符和字节之间的桥梁，通常，涉及到字符编码转换时，
需要用到转换流。


练习：键盘录入，存入电脑文件中
import java.io.*;
class Test4 
{
public static void main(String[] args)  throws IOException
{
//InputStream in=System.in;
//InputStreamReader isr=new InputStreamReader(in);
//BufferedReader bufr=new BufferedReader(isr);
BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("read.txt")));
String line=null;
while((line=bufr.readLine())!=null)
{
if("over".equals(line))
break;
bufw.write(line.toUpperCase());
bufw.newLine();
bufw.flush();


}
}
}