day19字节流和字符流转换，明确源和目的

/*
字符流：
FileReader
FileWriter

BufferedReader
BufferedWriter

字节流：
InputStream
OutputStream(写就是输出)

BufferedInputStream
BufferedOutputStream

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

能不能直接使用readLine方法来完成

readLine方法是字符流bufferReader类中的方法

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

能不能将字节流转换为字符流，使用字符流方法InputStreamReader

字符转换为字节，OutputStreamWriter
*/
import java.io.*;
class TransStreamDemo 
{
public static void main(String[] args) throws IOException
{
//获取键盘录入对象
InputStream in=System.in;

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

//为了提高字符的读取效率，加入了缓冲技术
//只要将流对象作为参数传入缓冲区的构造函数
BufferedReader bufr=new BufferedReader(isr);

//上面三种合一种，键盘的最常见的写法
BufferedReader bufr=
new BufferedReader(new InputStreamReader(System.in));

OutputStream out=System.out;
OutputStreamWriter osw=new OutputStreamWriter(out);
BufferedWriter bufw=new BufferedWriter(osw);

String line=null;
while ((line=bufr.read())!=null)
{
if("over".equals())
break;
//System.out.println(line.toUpperCase());
bufw.write(line.toUpperCase());
bufw.newLine();
bufw.flush();
}
}

}

----------------------------------

/*
1.
源：键盘输入
目的：控制台

2.把键盘的录入的数据储存到一盒文件中
源：键盘
目的：文件

3.需求：把文件数据打印到控制台
原：文件
目的：控制台
***********************************
流操作的基本规律
流的对象很多，不知道用哪一个

通过两个明确来完成

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

3.当体系明确后，再明确使用那个具体对象
通过设备来区分
源设备：内存，硬盘，键盘
目的设备：内存，硬盘，控制台

*************************************************
1.将文本文件数据存储到另一个文件，复制文件
(1)源：因为是源，所以使用读取流InputStream Reader
是操作文本，选择Reader

接下来明确设备：硬盘，上的文件
Reader体系可以操作文件的对象是FileReader

是否要提高效率：是，加入Reader体系中缓冲区BufferedReader

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

(2)目的：OutputStream Writer
是纯文本，选择Writer
设备：硬盘上一个文件
writer体系选择可以操作的对象：FileWriter
是否要提高效率：是，加入Reader体系中缓冲区BufferedWriter

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

练习：将一个图片文件数据存储到另一个文件
FileInputStream fis=new FileInputStream();
BufferedInputStream bfis=new BufferedInputStream(fis);

----------------------------------------------------------------------------------
2.需求：将键盘录入的数据保存到一个文件
(1)源：InputStream Reader
是纯文本，用Reader

设备：键盘。对应的对象的System.in
不是选择Reader，System.in对应的不是字节流
为了操作键盘的文本数据方便，转换字符流按照字符串操作
System.in转成Reader
用了Reader的体系转换流，InputStreamReader

InputStreamReader isr=new InputStreamReader();

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

(2)目的：OutputStream Writer
是否存文本，是：Writer
设备：硬盘，一个文件，选择·：FileWriter
FileWriter fw=new FileWriter();
需要提高效率嘛？需要
BufferedWriter bufw=new BufferedWriter(fw);

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

目的：OutputStream Writer
是否存文本，是：Writer
设备：硬盘，一个文件，选择·：FileWriter
但FileWriter是使用的默认编码表GBK

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

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

需要提高效率嘛 需要
BufferedWriter bufw=new BufferedWriter(osw);

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

*/
import java.io.*;
class TransStreamDemo2
{
public static void main(String[] args) throws IOException
{
//键盘的最常见的写法
BufferedReader bufr=
new BufferedReader(new InputStreamReader(System.in));

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

String line=null;
while ((line=bufr.read())!=null)
{
if("over".equals())
break;
//System.out.println(line.toUpperCase());
bufw.write(line.toUpperCase());
bufw.newLine();
bufw.flush();
}
}
}

----------------------------------------------

import java.io.*;
class TransStreamDemo3
{
public static void main(String[] args) throws IOException
{
//System.setIn (new FileInputStream("person.java"));
System.setOut(new PrintStream("zzz.txt"));
BufferedReader bufr=
new BufferedReader(new InputStreamReader(System.in));

BufferedWriter bufw=
new BufferedWriter(new OutputStreamWriter(System.out));

String line=null;
while ((line=bufr.read())!=null)
{
if("over".equals())
break;
//System.out.println(line.toUpperCase());
bufw.write(line.toUpperCase());
bufw.newLine();
bufw.flush();
}
}
}

----------------------------------------------

/*
通过缓冲区复制一个.Java文件

*/
import java.io.*;
class CopyTextByBuf 
{
public static void main(String[] args) 
{
BufferedReader bufr=null;
BufferedWriter bufw=null;

try
{
bufr=new BufferedReader(new FileReader("BufferWriterDemo.java"));
bufw=new BufferedWriter(new FileWriter("bufWriter_Copy.txt"));

String line=null;

while ((line=bufr.readLine())!=null)
{
bufw.writer(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("写入关闭失败")；
}
}
}
}

-----------------------------------------------------

/*
复制一个图片
思路
1.用字节流读取对象和文件关联
2.用字节写入流对象创造一个图片文件，用于存储到图片数据
3.通过循环读写，完成数据存储
4.关闭资源
*/
class  CpyPic
{
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的复制，通过缓冲区
BufferedInputStream
BufferedOutputStream

*/
import java.io.*;
class  CopyMp3
{
public static void main(String[] args) 
{
long start=System.currentTimeMillis();
copy_2();
long end=System.currentTimeMillis();


System.out.println((end-start)+"毫秒");
}

public static void copy_2()throws IOException
{
MyBufferedInputStream bufis=new MyBufferedInputStream(new FileInputStream("c:\\1.mp3"));
BufferedOutputStream bufos=new BufferedOutputStream(new FileOutputStream("c:\\2.mp3"));

int by=0;
while ((by=bufis.myRead())!=-1)
{
bufos.write(by);
}

bufos.close();
bufis.myClose();
}
//通过字节流的缓冲区完成复制
public static void copy_1()throws IOException
{
BufferedInputStream bufis=new BufferedInputStream(new FileInputStream("c:\\1.mp3"));
BufferedOutputStream bufos=new BufferedOutputStream(new FileOutputStream("c:\\2.mp3"));

int by=0;
while ((by=bufis.read())!=-1)
{
bufos.write(by);
}

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