------- android培训、java培训、期待与您交流！ ----------
字节流：
InputStream：是表示字节输入流的所有类的超类。
|--- FileInputStream：从文件系统中的某个文件中获得输入字节。哪些文件可用取决于主机环境。FileInputStream用于读取诸如图像数据之类的原始字节流。要读取字符流，请考虑使用 FileReader。
|---FilterInputStream：包含其他一些输入流，它将这些流用作其基本数据源，它可以直接传输数据或提供一些额外的功能。
|--- BufferedInputStream：该类实现缓冲的输入流。
|--- Stream：
|---ObjectInputStream：
|---PipedInputStream：
FileInputStream读取数据：
//读取方式一:一个一个的读，每读一个就打印一个。
public static void readFile_1() throws IOException
{
//创建一个文件输入流对象，关联要读取的文件
FileInputStream fips = new FileInputStream("fops.txt");
//len变量用来记录读到数据的长度
int len = 0;
//循环从输入流中读取数据
while ((len = fips.read()) != -1)
//每读到一个数据，就把读到的数据转换成字符串并打印输出
sop((char)len);
//关闭流资源
fips.close();
}
//读取方式二：定义数组，把读取出来的数据全部存入数据，然后再一次打印。
public static void readFile_2() throws IOException
{
//创建一个文件输入字节流，关联要读取的文件
FileInputStream fips = new FileInputStream("fops.txt");
//字节数组，指定大小为1024B
byte[] arr = new byte[1024];
//len变量用来记录读到数据的长度
int len = 0;
//循环从输入流中读取数据，存入字节数据，并记录数据长度
while ((len = fips.read(arr)) != -1)
//把最大长度的数据转换成字符串打印
sop(new String(arr, 0, len));
//关闭流资源
fips.close();
}
//读取方式三：available（）方法
public static void readFile_3() throws IOException
{
//创建一个文件输入字节流，关联要操作的文件
FileInputStream fips = new FileInputStream("fops.txt");
//创建一个长度刚刚好的数组。就不用再循环了。数据过大的话，不建议使用这种方式。
byte[] arr = new byte[fips.available()];
//读取输入流中的数据，存入字节数组
fips.read(arr);
//把字节数组中的数据转换为字符串打印
sop(new String(arr));
//sop(fips.available());
//关闭流资源
fips.close();
}
OutputStream：此抽象类是表示输出字节流的所有类的超类。
|--- FileOutputStream：文件输出流是用于将数据写入File或FileDescriptor的输出流。
|---FilterOutputStream：此类是过滤输出流的所有类的超类。
|--- BufferedOutputStream：该类实现缓冲的输出流。
|--- PrintStream：
|--- DataOutputStream：
|---ObjectOutputStream：
|---PipedOutputStream：
用FileOutputStream读取文件：
//写入文件方法
public static void writeFile() throws IOException
{
//创建一个文件字节输出流对象，关联要写入数据的文件
FileOutputStream fops = new FileOutputStream("fops.txt");
//把 "itheima"转换成字节数据，写入输出流中
fops.write("itheima.".getBytes());
//关闭流资源
fops.close();
}
* 流操作的基本规律：
* 最痛苦的就是，流对象有很多，不知道该用哪一个。
* 通过两个明确来确定：1.明确源和目的。源：输入流 InputStream Reader 目的：输出流 OutputStream Writer
* 2.操作的数据是否为纯文本 是：就用字符流 不是：用字节流。
*
* 当两个明确了之后就明确应该使用哪个具体的对象。
* 通过设备来进行区分：设备包括：
* 源设备包括：内存、硬盘、键盘
* 目的设备：内存、硬盘、控制台
*
* 需求：键盘录入，打印在控制台上。
* 源：键盘
* 目的：控制台 * 流操作的基本规律：
* 最痛苦的就是，流对象有很多，不知道该用哪一个。
* 通过两个明确来确定：1.明确源和目的。源：输入流 InputStream Reader 目的：输出流 OutputStream Writer
* 2.操作的数据是否为纯文本 是：就用字符流 不是：用字节流。
*
* 当两个明确了之后就明确应该使用哪个具体的对象。
* 通过设备来进行区分：设备包括：
* 源设备包括：内存、硬盘、键盘
* 目的设备：内存、硬盘、控制台
*
* 需求：键盘录入，打印在控制台上。
* 源：键盘
* 目的：控制台
代码体现：
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
public class TransStreamDemo
{
public static void main(String[] args) throws IOException
{
sop("请输入字符：");
//获取键盘录入对象，该对象返回读取字节流
//InputStream ips = System.in;
////使用转换流InputStreamReader把读取字节流转换为读取字符流对象
//InputStreamReader ipsr = new InputStreamReader(ips);
////创建一个读取字符流缓冲对象，把读取字符流对象作为参数传递给它
//BufferedReader bufr = new BufferedReader(ipsr);
//键盘录入
BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
//OutputStream ops = System.out;
////把字符流对象转换成字节流对象用OutputStreamWriter
//OutputStreamWriter opsw = new OutputStreamWriter(ops);
//
//BufferedWriter bufw = new BufferedWriter(opsw);
//控制台输出
BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(System.out));
//line变量用于记录字符
String line = null;
//循环读取缓冲区中的数据
while ((line = bufr.readLine()) != null)
{
//当输入的字符和 over 完全相同时，跳出循环，结束本程序
if ("over".equals(line))
break;
else
//当输入字符和over不一样时，则把输入的字符串转换成大写后再打印到控制台
bufw.write(line.toUpperCase());
bufw.newLine();
bufw.flush();
}
//关闭流资源
bufr.close();
}
//定义打印功能。
public static void sop(Object obj)
{
System.out.println(obj);
}
}
* 2.需求：将键盘录入的字符保存到文件中。
* 分析：
* ①.读取源：键盘录入 。InputStream Reader
* ②.是不是纯文本文件？是，所以用Reader
*
* 输入设备为键盘录入System.in，而System.in返回的是InputStream字节流对象，那么怎么用字符流Reader读取
* 源呢？为了操作键盘输入的数据，可以把字节流转换成字节流。按照字符串操作最方便。所以把System.in转换成字符流Reader,
* 要用到Reader体系中的转换流InputStreamReader
* InputStreamReader ipsr = new InputStreamReader(System.in);
* 需要提高效率吗？需要！ 就用到了BufferedReader
* BufferedReader bufr = new BufferedReader(ipsr);
*
* ③.目的：OutputStream Writer
* ④.是不是纯文本文件？是！所以用字符流Writer
* 目的地设备：硬盘。一个文件。所以用Writer体系中能操作文件的FileWriter。
* FileWriter fw = new FileWriter("d.txt");
* 需要提高效率吗？需要！要用到BufferedWriter。
* BufferedWriter bufw = new BufferedWriter(fw);
*
* 扩展：想要把录入的数据按照指定的编码表（utf-8）存入文件当中。
*
* ⑤.写入目的：OutputStream Writer
* ⑥.是不是纯文本文件？是！所以用字符流Writer
* 目的地设备：硬盘。一个文件。所以用Writer体系中能操作文件的FileWriter。
* 但是FileWriter使用的是默认编码表GBK
*
* 所以写入时，需要加入指定的编码表。而指定的编码表只有转换流才可以指定。所以要使用OutputStreamWriter
* OutputStreamWriter opsw = new OutputStreamWriter(new FileOutputStream("utf-8_Test.txt"), "UTF-8");
*
* 需要提高程序运行效率吗？需要：
* BufferedWriter bufw = new BufferedWriter(opsw);
*
* 所以，记住，转换流什么时候使用呢？字符和字节之间的桥梁，通常涉及到字符编码转换时需要用到转换流。
代码体现：
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.UnsupportedEncodingException;
public class TransStreamDemo7
{
public static void main(String[] args) throws IOException
{
//打印提示信息
System.out.println("请输入内容：");
//键盘录入，只要是键盘录入就可以用这个
BufferedReader bufr =
new BufferedReader(new InputStreamReader(System.in));
//将键盘录入的数据用指定的字符集写入到指定的文档中
BufferedWriter bufw =
new BufferedWriter(new OutputStreamWriter(new FileOutputStream("utf-8_Test.txt"), "UTF-8"));
//by变量用来几句从键盘录入的字符串
String by = null;
//一行一行的循环读取键盘录入
while ((by = bufr.readLine()) != null)
{
//如果读取 "over" 字符串时
if ("over".equals(by))
//跳出循环
break;
//将键盘录入的字符串转换成大写后写入输出流中
bufw.write(by.toUpperCase());
//每写一行就需要换行一次
bufw.newLine();
//换行之后还要刷新
bufw.flush();
}
//关闭输入流资源
bufr.close();
//关闭输出流资源
bufw.close();
}
}
通过FileInputStream和FileOutputStream复制图片的案例：
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/*复制一个图片：
* 思路：
* 1.用字节读取流对象和图片进行关联。
* 2.用字节写入对象创建一个图片文件，用于存储获取到的图片数据。
* 3.通过循环读写完成图片的复制。
* */
public class CopyPic
{
public static void main(String[] args)
{
//创建一个读取字节流对象
FileInputStream fis =null;
//创建一个写入字节流对象
FileOutputStream fos = null;
try
{
//读取字节流对象关联要读取的文件。
fis = new FileInputStream("freshfruit2.jpg");
//写入字节流对象创建一个文件
fos = new FileOutputStream("copy_freshfruit2.jpg");
//定义一个数组，用来存储读取字节流对象从关联文件中读取到的数据。
byte[] arr = new byte[1024*1024];
//len用来记录读取字节流对象读取到的数据的长度。
int len = 0;
//读取字节流对象循环读取关联文件中的数据并存入arr数组当中，返回数据长度。
while ((len = fis.read(arr)) != -1)
//写入字节流对象写入arr数组里面从0到len长度的数据。
fos.write(arr, 0, len);
}
//处理异常
catch (IOException e)
{
throw new RuntimeException("复制失败！");
}
finally
{
if (fis != null)
try
{
//关闭读取字节流资源
fis.close();
}
catch (IOException e)
{
throw new RuntimeException("读取流关闭失败！");
}
if (fos != null)
try
{
//关闭写入字节流资源
fos.close();
}
catch (IOException e)
{
throw new RuntimeException("写入流资源关闭失败！");
}
}
}
}
BufferedInputStream：该类实现缓冲的输入流。
BufferedOutputStream：该类实现缓冲的输出流。
缓冲区的出现就是为了提高流的操作效率
需求：复制Mp3,通过字节流缓冲区。
代码体现：
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class CopyMp3
{
public static void main(String[] args) throws IOException
{
//记录拷贝功能运行之前的时间点
long start = System.currentTimeMillis();
//调用拷贝功能
copy_1();
//记录拷贝后的时间点
long end = System.currentTimeMillis();
//拷贝后的时间点减去拷贝前的时间点就等于拷贝的时间
System.out.println("times="+(end-start));
}
//通过字节流的缓冲区完成，定义拷贝方法。
public static void copy_1() throws IOException
{
//创建读取字节流对象，并关联要读取的文件
FileInputStream fis = new FileInputStream("apologize.mp3");
//创建一个写入字节流对象，创建一个新的文件。
FileOutputStream fos = new FileOutputStream("apologize.mp3");
//创建读取字节流对象的缓冲区，并把读取字节流对象作为参数传递给缓冲区
BufferedInputStream bufis = new BufferedInputStream(fis);
//创建写入字节流对象的缓冲区，并把写入字节流对象作为参数传递给缓冲区
BufferedOutputStream bufos = new BufferedOutputStream(fos);
//定义记录字节的变量by
int by =0;
//循环的从读取字节流缓冲区中读取数据，用by记录
while ((by = bufis.read()) != -1)
//循环的向写入字节流缓冲区中写入数据
bufos.write(by);
//关闭读取流资源
bufis.close();
//关闭写入流资源
bufos.close();
}
}