输出流：程序（内存）--->外界设备
输?流：外界设备--->程序（内存）
字符流：处理字符相关，如处理?本数据（如txt?件), Reader/Writer
字节流: 处理字节相关，如声?或者图?等?进制，InputStream/OutputStream
字节流以字节（8bit）为单位，字符流以字符为单位，根据码表映射字符，?次可能读多个字节
字节流可以处理?乎所有?件，字符流只能处理字符类型的数据
字符流 Reader/Writer
字节流 InputStream/OutputStream
- InputStream是输?字节流的?类，它是?个抽象类（?般?他的?类）
int read()
从输?流中读取单个字节,返回0到255范围内的int字节值,字节数据可直接转换为int类 型, 如果已经到达流末尾?没有可?的字节，则返回－1
int read(byte[] buf)
从输?流中读取?定数量的字节，并将其存储在缓冲区数组buf中, 返回实际读取的字节数，如果已经到达流末尾?没有可?的字节，则返回－1
long skip(long n)
从输?流中跳过并丢弃 n 个字节的数据。
int available()
返回这个流中有多少个字节数，可以把buf数组?度定为这个
void close() throws IOException
关闭输?流并释放与该流关联的系统资源
抽象类InputStream?来具体实现类的创建对象, ?件字节输?流, 对?件数据以字节的形式进?读取操作
//传??件所在地址
public FileInputStream(String name) throws FileNotFoundException
//传??件对象
public FileInputStream(File file) throws FileNotFoundException
public class Main {
public static void main(String[] args)throws IOException {
String dir = "C:\\work";
String name = "test.txt";
File file = new File(dir,name);
InputStream inputStream = new FileInputStream(file);
testRead(inputStream);
testSkip(inputStream);
testReadByteArr(inputStream);
}
/**
* 读取所有字节
* @param inputStream
* @throws IOException
*/
public static void testReadByteArr(InputStream inputStream)throws IOException{
//如果buf的长度为0，则不读取任何字节并返回0；每次读取的字节数最多等于buf的长度
// 写法1
// byte[] buf = new byte[1024];
// 写法2
byte[] buf = new byte[inputStream.available()];
int length;
//循环读取文件内容，输入流中将最多的buf.length个字节数据读入一个buf数组中，返回类型是读取到的字节数
//如果这个缓冲区没有满的话，则返回真实的字节数
while ((length = inputStream.read(buf))!=-1){
//System.out.print(new String(buf,0,length)); // 从buf数组中读取，从0开始读取，读取到length
//中文乱码问题，换成GBK,或者UTF-8
System.out.print(new String(buf,0,length,"UTF-8"));
}
// 关闭流
inputStream.close();
}
/**
* 读取1个字节
* @param inputStream
* @throws IOException
*/
public static void testRead(InputStream inputStream)throws IOException{
//对于汉字等 unicode中的字符不能正常读取，只能以乱码的形式显示
int read = inputStream.read();
System.out.println(read);
System.out.println((char)read);
// 关闭流
inputStream.close();
}
/**
*
* @param inputStream
* @throws IOException
*/
public static void testSkip(InputStream inputStream)throws IOException{
// 跳过2个字节，读取第3个字节
long skipSize = inputStream.skip(2);
System.out.println(skipSize);
int read = inputStream.read();
System.out.println(read);
System.out.println((char)read);
// 关闭流
inputStream.close();
}
}
- OutputStream是输出字节流的?类，它是?个抽象类
void write(int b)
将指定的字节写?输出流
void write(byte[] b)throws IOException
将b.length个字节的byte数组写?当前输出流
void flush() throws IOException
write是写到缓冲区中，可以认为是内存中,当缓冲区满时系统会?动将缓冲区的内容写??件，但是?般还有?部分有可能会留在内存这个缓冲区中, 所以需要调?flush空缓冲区数据。
void close() throws IOException
关闭输?流并释放与该流关联的系统资源
- 抽象类OutputStream?来具体实现类的创建对象, ?件字节输出流, 对?件数据以字节的形式进?输出的操作
//传?输出的?件地址
public FileOutputStream(String name)
//传??标输出的?件对象
public FileOutputStream(File file)
//传??标输出的?件对象, 是否可以追加内容
public FileOutputStream(File file, boolean append)
public class Main {
public static void main(String[] args)throws IOException {
String dir = "C:\\work";
String name = "test.txt";
String target = "b.txt";
File file = new File(dir,name); // 拼接文件的路径
InputStream inputStream = new FileInputStream(file); // 读取文件
// 写法1，写入数据，会自动创建文件，但是不会创建多级目录下的文件
// OutputStream outputStream = new FileOutputStream(dir+File.separator+target);
// 写法2，写入数据，不覆盖文件，追加数据
OutputStream outputStream = new FileOutputStream(dir+File.separator+target,true);
// 测试
testOut(inputStream,outputStream);
testOutBuf(inputStream,outputStream);
}
/**
* 将inputStream中的数据写入outputStream
* @param inputStream
* @param outputStream
* @throws IOException
*/
public static void testOutBuf(InputStream inputStream,OutputStream outputStream)throws IOException {
byte [] buf = new byte[1024];
int length ;
while (( length = inputStream.read(buf))!=-1){
outputStream.write(buf,0,length);
}
//关闭流
inputStream.close();
outputStream.close();
}
// 写入文件测试1，单个字节读取，中文会有问题
public static void testOut(InputStream inputStream,OutputStream outputStream)throws IOException{
int value = 0;
while (value!=-1){
value = inputStream.read();
outputStream.write(value);
}
//最后记得关闭流
inputStream.close();
outputStream.close();
}
}
它是内存空间的?部分，在内存空间中预留了?定的存储空间，这些存储空间?来缓冲输?或输出的数据，这部分空间就叫做缓冲区，缓冲区是具有?定??的
# 缓冲，缓和冲击，例如操作磁盘?内存慢的很多，所以不?缓冲区效率很低
# 数据传输速度和数据处理的速度存在不平衡，?如你每秒要写100次硬盘，对系统冲击很?，浪费了?量时间在忙着处理开始写和结束写这两个事件，?buffer暂存起来，变成每10秒写?次硬盘，数据可以直接送往缓冲区，?速设备不?再等待低速设备，对系统的冲击就很?，写?效率?了
BufferInputStream
BufferOutputStream
- BufferInputStream 缓冲字节输?流
# BufferedInputStream 通过预先读??整段原始输?流数据?缓冲区中，?外界对BufferedInputStream的读取操作实际上是在缓冲区上进?，如果读取的数据超过了缓冲区的范围，那么BufferedInputStream负责重新从原始输?流中载?下?截数据填充缓冲区，然后外界继续通过缓冲区进?数据读取
# 好处：避免了?量的磁盘IO，原始的InputStream类实现的read是即时读取的，每?次读取都会是?次磁盘IO操作（哪怕只读取了1个字节的数据），如果数据量巨?，这样的磁盘消耗?常可怕
# 缓冲区的实现: 读取可以读取缓冲区中的内容，当读取超过缓冲区的内容后再进??次磁盘IO，载??段数据填充缓冲，下?次读取?般情况就直接可以从缓冲区读取，减少了磁盘IO
# 默认缓冲区??是8k, int DEFAULT_BUFFER_SIZE = 8192
//对输?流进?包装，??默认的缓冲区是8k
public BufferedInputStream(InputStream in);
//对输?流进?包装,指定创建具有指定缓冲区??的
public BufferedInputStream(InputStream in,int size);
/从输?流中读取?个字节
public int read();
//从字节输?流中给定偏移量处开始将各字节读取到指定的 byte 数组中。
public int read(byte[] buf,int off,int len);
//关闭释放资源，关闭的时候这个流即可，InputStream会在??被关闭
void close();
- BufferOutputStream 缓冲字节输出流
//对输出流进?包装,??默认的缓冲区是8k
public BufferedOutputStream(OutputStream out);
//对输出流进?包装,指定创建具有指定缓冲区??的
public BufferedOutputStream(OutputStream out,int size);
# 常?的三个?法
//向输出流中输出?个字节
public void write(int b);
//将指定 byte 数组中从偏移量 off 开始的 len 个字节写?缓冲的输出流。
public void write(byte[] buf,int off,int len);
//刷新此缓冲的输出流，强制使所有缓冲的输出字节被写出到底层输出流中。
public void flush();
//关闭释放资源，关闭的时候这个流即可，OutputStream会在??被关闭, JDK7新特性try(在这?声明的会?动关闭){}
void close();
public class BufferMain {
public static void main(String [] args){
try{
FileInputStream fis = new FileInputStream("C:\\Users\\79466\\Desktop\\test\\a.txt");
BufferedInputStream bis = new BufferedInputStream(fis);
FileOutputStream fos = new FileOutputStream("C:\\Users\\79466\\Desktop\\test\\copy.txt");
BufferedOutputStream bos = new BufferedOutputStream(fos);
int size;
byte [] buf = new byte[1024];
while ( (size =bis.read(buf))!=-1){
bos.write(buf,0,size);
}
//刷新此缓冲区的输出流，才可以保证数据全部输出完成，
//bos.flush();
bis.close();
bos.close();
}catch (Exception e){
}
}
}