java基础10（IO流）-字节流

IO流

输入与输出【参照物是程序】

如果从键盘、文件、网络甚至是另一个进程（程序或系统）将数据读入到程序或系统中，称为输入

如果是将程序或系统中的数据写到屏幕、硬件上的文件、网络上的另一端或者是一个进程（程序或系统），称为输出

IO流的分类

• 根据数据流向不同分为：输入流和输出流
  
  输入流: 程序可以从中读取数据的流
  
  输出流: 程序能向其中写入数据的流
• 根据数据处理类不同分为：字节流和字符流
  
  字节流：以字节为单位传输数据的流
  
  字符流：以字符为单位传输数据的流

注：数据所在文件若能用win下记事本打开则用字符流

IO流类结构图

读数据

InputStream读取数据

int read() ： 从此输入流中读取一个数据字节
int read(byte[] b): 从此输入流中将最多 b.length 个字节的数据读入一个 byte 数组中。返回值是一次读取字节数组的个数
int read(byte[] b, int off, int len): 从此输入流中将最多 len 个字节的数据读入一个 byte 数组中 

InputStream读取数据（一次读取一个字节）

import java.io.FileInputStream;
import java.io.IOException;

public class FileInputStreamDemo{
		public static void main(String[] args) throws IOException{
			FileInputStream file = new FileInputStream("/home/hadoop/1.txt");
/*
			int by = file.read();//一次读取一个字节
			System.out.println(by);
			System.out.println((char) by);
*/

			//方式1（一次读取一个字节）
			int by = 0;
			while((by = file.read()) != -1){
//				System.out.print(by);//不转的话读出来全是数字
				System.out.print((char)by);//这里需要注意文件中如果有中文将出问题，因为将中文也转成char了;要读取的文件中有换行符，直接读取过来，所以这里不需要换行符
			}
			file.close();

	}
}

InputStream读取数据（一次读取一个字节数组）

import java.io.FileInputStream;
import java.io.IOException;

public class FileInputStreamDemo2{
	public static void main(String[] args)throws IOException{
		FileInputStream fis = new FileInputStream("/home/hadoop/1.txt");

		byte[] bys = new byte[1024];
		int len = 0;
		while((len = fis.read(bys)) != -1){ //读取到的实际长度是-1就没有数据了
			System.out.print(new String(bys,0,len));//进行转换
		}

		fis.close();
	}
}

BufferedInputStream读取数据(一次读一个字节)

import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;

public class BufferedInputStreamDemo{
	public static void main(String[] args)throws IOException{
		BufferedInputStream bis = new BufferedInputStream(new FileInputStream("/home/hadoop/1.txt"));

		int by =0;
		while((by = bis.read()) != -1){
			System.out.print((char)by);
		}

		bis.close();
	}
}

BufferedInputStream读取数据(一次读一个字节数组)

import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;

public class BufferedInputStreamDemo{
	public static void main(String[] args)throws IOException{
		BufferedInputStream bis = new BufferedInputStream(new FileInputStream("/home/hadoop/1.txt"));

		byte[] bys = new byte[1024];
		int len = 0;
		while((len = bis.read(bys)) != -1){
			System.out.print(new String(bys,0,len));
		}

		bis.close();
	}
}

写数据

OutputStream写数据

void write(byte[] b):将 b.length 个字节从指定的 byte 数组写入此输出流
void write(byte[] b, int off, int len): 将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此输出流。
void write(int b): 将指定的字节写入此输出流。 

FileOutputStream写数据（写一个字节）

import java.io.FileOutputStream;
import java.io.IOException;

public class FileOutputStreamDemo{
	public static void main(String[] args)throws IOException{
/*		//创建字节输出流对象
		File file = new File("/home/hadoop/1.txt");
		FileOutputStream fos = new FileOutputStream(File file);
*/
		FileOutputStream fos = new FileOutputStream("/home/hadoop/wu.txt",true);//true表示追加数据

		fos.write("wujiadong".getBytes());//将字符串转成字节数组
		fos.write(97);//写一个字节
		fos.close();

	}
}

FileOutputStream写数据（写一个字节数组和写字节数组的部分）

import java.io.FileOutputStream;
import java.io.IOException;

public class FileOutputStreamDemo{
	public static void main(String[] args)throws IOException{
/*		//创建字节输出流对象
		File file = new File("/home/hadoop/1.txt");
		FileOutputStream fos = new FileOutputStream(File file);
*/
		FileOutputStream fos = new FileOutputStream("/home/hadoop/wu.txt",true);
		byte[] bys = {97,98,99,100};
		fos.write(bys);//写一个字节数组

		fos.write(bys,1,3);//写一个字节数组的一部分
		fos.close();
	}
}

BufferedOutputStream写数据

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.BufferedOutputStream;

public class BufferedOutputStreamDemo{
	public static void main(String[] args)throws IOException{
	//	FileOutputStream fis = new FileOutputStream("/home/hadoop/wu2.txt");
	//	BufferedOutputStream bos = new BufferedOutputStream(fis);
		//简单写法
		BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("/home/hadoop/wu3.txt"));
		//写数据
		bos.write("hello,wujiadong".getBytes());

		//释放资源
		bos.close();

	}
}

读写数据练习

复制数据

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class CopyFileDemo{
	public static void main(String[] args) throws IOException {
		//封装数据源
		FileInputStream fis = new FileInputStream("/home/hadoop/11.txt");

		//封装目的地
		FileOutputStream fos = new FileOutputStream("/home/hadoop/a.txt");

		//复制数据
		int by = 0;
		while((by = fis.read()) != -1){
			fos.write(by);
		}

		//释放资源
		fis.close();
		fos.close();
	}
}
---------------------------------------
注：这种方法一次读一个字节，比较慢
----------------------------------------

复制数据

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class CopyFileDemo1{
	public static void main(String[] args)throws IOException{
		//封装数据源
		FileInputStream fis = new FileInputStream("/home/hadoop/11.txt");
		FileOutputStream fos = new FileOutputStream("/home/hadoop/wu.txt");

		//复制数据
		byte[] bys = new byte[1024];
		int len = 0;
		while((len = fis.read(bys)) != -1){
			fos.write(bys,0,len);
		}

		//释放资源
		fis.close();
		fos.close();
	}
}

字节流4种方式复制文件

/*
 * 字节流4种方式复制文件
 * 基本字节流一次读写一个字节
 * 基本字节流一次读写一个字节数组
 * 高效字节流一次读写一个字节
 * 高效字节流一次读写一个字节数组
 */

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;

public class CopyDemo{
	public static void main(String[] args)throws IOException{
		long start = System.currentTimeMillis();

//		method1("/home/hadoop/1.txt","/home/hadoop/javatest/1.txt");
//		method2("/home/hadoop/1.txt","/home/hadoop/javatest/1.txt");
//		method3("/home/hadoop/1.txt","/home/hadoop/javatest/1.txt");
		method4("/home/hadoop/1.txt","/home/hadoop/javatest/1.txt");

		long end = System.currentTimeMillis();
		System.out.println("共耗时："+(end - start)+"mm");
	}
		public static void method1(String srcString,String desString)throws IOException{
			FileInputStream fis = new FileInputStream(srcString);
			FileOutputStream fos = new FileOutputStream(desString);

			//方法1：读写一个字节
			int by = 0;
			while((by = fis.read()) != -1){
				fos.write(by);
			}

			fis.close();
			fos.close();

		}		

		public static void method2(String srcString,String desString)throws IOException{
			FileInputStream fis = new FileInputStream(srcString);
			FileOutputStream fos = new FileOutputStream(desString);

			//方式2：读取一个字节数组
			byte[] bys = new byte[1024];
			int len = 0;
			while((len = fis.read(bys)) != -1){
				fos.write(bys,0,len);
			}

			fis.close();
			fos.close();
		}	

		public static void method3(String srcString,String desString)throws IOException{
			BufferedInputStream bis = new BufferedInputStream(new FileInputStream(srcString));
			BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(desString));

			//方式3：高效读取一个字节
			int by = 0;
			while((by = bis.read()) != -1){
				bos.write(by);
			}

			bis.close();
			bos.close();
		}

		public static void method4(String srcString,String desString)throws IOException{
			BufferedInputStream bis = new BufferedInputStream(new FileInputStream(srcString));
			BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(desString));

			//高效读取一个字节数组
			byte[] bys = new byte[1024];
			int len = 0;
			while((len = bis.read(bys)) != -1){
				bos.write(bys,0,len);
			}

			bis.close();
			bos.close();
		}
}