本文详细介绍了Java中的IO流，包括流的概念、分类、字符流与字节流的区别以及文件的读写操作。通过示例代码展示了如何使用InputStream、FileInputStream、OutputStream和FileOutputStream进行文件的读取和写出。此外，还提到了文件拷贝的过程，包括单个文件和整个目录的拷贝。最后，讨论了如何利用PrintStream进行打印输出以及System.in、System.out和System.err的重定向。
JAVA--IO流
(一)IO原理与概念
一、概念
流:流动 、流向 从一端移动到另一端 源头与目的地
程序 与 文件|数组|网络连接|数据库 ，以程序为中心
二、IO流分类
流向: 输入流与输出流
数据:字节流:二进制，可以一切文件 包括 纯文本 doc 音频、视频等等
字符流:文本文件，只能处理纯文本
3、功能:节点:包裹源头
处理:增强功能，提供性能
三、字符流与字节流 (重点) 与文件
1、字节流
输入流:InputStream read(byte[] b) 、read(byte[] b, int off, int len) +close()
FileInputStream()
输出流:OutputStream write(byte[] b) write(byte[] b, int off, int len) +flush() +close()
FileOutputStream
2、字符流
输入流:Reader read(char[] cbuf) read(char[] cbuf, int off, int len) +close()
FileReader()
输出流:Writer write(char[] cbuf) write(char[] cbuf, int off, int len) +flush() +close()
write(String str, int off, int len)
FileWriter()
四、操作
1、 举例:搬家 -->读取文件
1)、关联房子 --->建立与文件联系
2)、选择搬家 -->选择对应流
3)、搬家-->读取|写出
a)、卡车大小--->数组大小
b)、运输-->读取、写出
4)、打发over-->释放资源
2、操作
1)建立联系
2)选择流
3)操作 数组大小+read 、write
4)释放资源
(二)字节流
字节流:可以处理一切文件，包括二进制 音频、视频 、doc等
节点流: InputStream FileInputStream
OutputStream FileOutputStream
一、读取文件
1、建立联系 File对象 源头
2、选择流 文件输入流 InputStream FileInputStream
3、操作 : byte[] car =new byte[1024]; +read+读取大小
输出
4、释放资源 :关闭
5 类图
packagecom.bjsxt.io.byteIO;importjava.io.File;importjava.io.FileInputStream;importjava.io.FileNotFoundException;importjava.io.IOException;importjava.io.InputStream;/*** 文件的读取
* 1、建立联系 File对象
2、选择流 文件输入流 InputStream FileInputStream
3、操作 : byte[] car =new byte[1024]; +read+读取大小
输出
4、释放资源 :关闭
*@authorAdministrator
**/
public classDemo01 {/***@paramargs*/
public static voidmain(String[] args) {//1、建立联系 File对象
File src =new File("e:/xp/test/a.txt");//2、选择流
InputStream is =null; //提升作用域
try{
is=newFileInputStream(src);//3、操作 不断读取 缓冲数组
byte[] car =new byte[1024];int len =0; //接收 实际读取大小//循环读取
StringBuilder sb =newStringBuilder();while(-1!=(len=is.read(car))){//输出 字节数组转成字符串
String info =new String(car,0,len);
sb.append(info);
}
System.out.println(sb.toString());
}catch(FileNotFoundException e) {
e.printStackTrace();
System.out.println("文件不存在");
}catch(IOException e) {
e.printStackTrace();
System.out.println("读取文件失败");
}finally{try{//4、释放资源
if (null !=is) {
is.close();
}
}catch(Exception e2) {
System.out.println("关闭文件输入流失败");
}
}
}
}
fileinputstream
二、写出文件
1、建立联系 File对象 目的地
2、选择流 文件输出流 OutputStream FileOutputStream
3、操作 : write() +flush
4、释放资源 :关闭
5 类图
packagecom.bjsxt.io.byteIO;importjava.io.File;importjava.io.FileNotFoundException;importjava.io.FileOutputStream;importjava.io.IOException;importjava.io.OutputStream;/*** 写出文件
1、建立联系 File对象 目的地
2、选择流 文件输出流 OutputStream FileOutputStream
3、操作 : write() +flush
4、释放资源 :关闭
*@authorAdministrator
**/
public classDemo02 {/***@paramargs*/
public static voidmain(String[] args) {//1、建立联系 File对象 目的地
File dest =new File("e:/xp/test/test.txt");//2、选择流 文件输出流 OutputStream FileOutputStream
OutputStream os =null;//以追加形式 写出文件 必须为true 否则为覆盖
try{
os=new FileOutputStream(dest,true);//3、操作
String str="bjsxt is very good \r\n";//字符串转字节数组
byte[] data =str.getBytes();
os.write(data,0,data.length);
os.flush();//强制刷新出去
} catch(FileNotFoundException e) {
e.printStackTrace();
System.out.println("文件未找到");
}catch(IOException e) {
e.printStackTrace();
System.out.println("文件写出失败");
}finally{//4、释放资源 :关闭
try{if (null !=os) {
os.close();
}
}catch(Exception e2) {
System.out.println("关闭输出流失败");
}
}
}
}
fileoutputstream
三、文件拷贝 程序为桥梁
1、建立联系 File对象 源头 目的地
2、选择流
文件输入流 InputStream FileInputStream
文件输出流 OutputStream FileOutputStream
3、操作 : 拷贝
byte[] flush =new byte[1024];
int len =0;
while(-1!=(len=输入流.read(flush))){
输出流.write(flush,0,len)
}
输出流.flush
packagecom.bjsxt.io.byteIO;importjava.io.File;importjava.io.FileInputStream;importjava.io.FileNotFoundException;importjava.io.FileOutputStream;importjava.io.IOException;importjava.io.InputStream;importjava.io.OutputStream;/**1、建立联系 File对象 源头 目的地
2、选择流
文件输入流 InputStream FileInputStream
文件输出流 OutputStream FileOutputStream
3、操作 : 拷贝
byte[] flush =new byte[1024];
int len =0;
while(-1!=(len=输入流.read(flush))){
输出流.write(flush,0,len)
}
输出流.flush
4、释放资源 :关闭 两个流
*@authorAdministrator
**/
public classCopyFileDemo {/***@paramargs
*@throwsFileNotFoundException*/
public static voidmain(String[] args) {
String src="E:/xp/test";
String dest="e:/xp/test/4.jpg";try{
copyFile(src,dest);
}catch(FileNotFoundException e) {
e.printStackTrace();
System.out.println("文件不存在");
}catch(IOException e) {
e.printStackTrace();
System.out.println("拷贝文件失败|关闭流失败");
}
}/*** 文件的拷贝
*@param源文件路径
*@param目录文件路径
*@throwsFileNotFoundException,IOException
*@return
*/
public static void copyFile(String srcPath,String destPath) throwsFileNotFoundException,IOException {//1、建立联系 源(存在且为文件) +目的地(文件可以不存在)
File src =newFile(srcPath);
File dest=newFile(destPath);if(! src.isFile()){ //不是文件或者为null
System.out.println("只能拷贝文件");throw new IOException("只能拷贝文件");
}//2、选择流
InputStream is =newFileInputStream(src);
OutputStream os=newFileOutputStream(dest);//3、文件拷贝 循环+读取+写出
byte[] flush =new byte[1024];int len =0;//读取
while(-1!=(len=is.read(flush))){//写出
os.write(flush, 0, len);
}
os.flush();//强制刷出//关闭流
os.close();
is.close();
}
}
copyfile
4、释放资源 :关闭 两个流
四、文件夹拷贝
1、递归查找子孙级文件|文件夹
2、文件 复制(IO流复制)
文件夹 创建
3、 A
/ \
as.txt b
|
b.txt
AA
|
A
/ \
a.txt b
|
b.txt
4、不能将父目录拷贝到子目录中
删除超长目录
packagecom.bjsxt.io.byteIO;importjava.io.File;importjava.io.FileNotFoundException;importjava.io.IOException;/*** 文件夹的拷贝
* 1、文件 赋值 copyFile
* 2、文件 创建 mkdirs()
* 3、递归查找子孙级
*
*@authorAdministrator
**/
public classCopyDir {/***@paramargs*/
public static voidmain(String[] args) {//源目录
String srcPath="E:/xp/test/a";//目标目录
String destPath="E:/xp/test/a/b";try{
FileUtil.copyDir(srcPath,destPath);
}catch(FileNotFoundException e) {
e.printStackTrace();
}catch(IOException e) {
e.printStackTrace();
}
}/*** 拷贝文件夹
*@paramsrc 源路径
*@paramdest 目标路径*/
public static voidcopyDir(String srcPath,String destPath){
File src=newFile(srcPath);
File dest=newFile(destPath);
copyDir(src,dest);
}/*** 拷贝文件夹
*@paramsrc 源File对象
*@paramdest 目标File对象*/
public static voidcopyDir(File src,File dest){if(src.isDirectory()){ //文件夹
dest =newFile(dest,src.getName());
}
copyDirDetail(src,dest);
}/*** 拷贝文件夹细节
*@paramsrc
*@paramdest*/
public static voidcopyDirDetail(File src,File dest){if(src.isFile()){ //文件
try{
FileUtil.copyFile(src, dest);
}catch(FileNotFoundException e) {
e.printStackTrace();
}catch(IOException e) {
e.printStackTrace();
}
}else if(src.isDirectory()){ //文件夹//确保目标文件夹存在
dest.mkdirs();//获取下一级目录|文件
for(File sub:src.listFiles()){
copyDirDetail(sub,newFile(dest,sub.getName()));
}
}
}
}
copydir
packagecom.bjsxt.io.byteIO;importjava.io.BufferedInputStream;importjava.io.BufferedOutputStream;importjava.io.File;importjava.io.FileInputStream;importjava.io.FileNotFoundException;importjava.io.FileOutputStream;importjava.io.IOException;importjava.io.InputStream;importjava.io.OutputStream;/*** 文件操作
* 1、文件拷贝
* 2、文件夹拷贝 拒绝自己拷贝给自己
*@authorAdministrator
**/
public classFileUtil {/*** 拷贝文件夹
*@paramsrc 源路径
*@paramdest 目标路径
*@throwsIOException
*@throwsFileNotFoundException*/
public static void copyDir(String srcPath,String destPath) throwsFileNotFoundException, IOException{//拒绝自己拷贝给自己
if(srcPath.equals(destPath)){return;
}
File src=newFile(srcPath);
File dest=newFile(destPath);
copyDir(src,dest);
}/*** 拷贝文件夹
*@paramsrc 源File对象
*@paramdest 目标File对象
*@throwsIOException
*@throwsFileNotFoundException*/
public static void copyDir(File src,File dest) throwsFileNotFoundException, IOException{if(src.isDirectory()){ //文件夹
dest =newFile(dest,src.getName());if(dest.getAbsolutePath().contains(src.getAbsolutePath())){
System.out.println("父目录不能拷贝到子目录中");return;
}
}
copyDirDetail(src,dest);
}/*** 拷贝文件夹细节
*@paramsrc
*@paramdest*/
public static void copyDirDetail(File src,File dest) throwsFileNotFoundException,IOException{if(src.isFile()){ //文件
try{
FileUtil.copyFile(src, dest);
}catch(FileNotFoundException e) {//e.printStackTrace();
throwe;
}catch(IOException e) {//e.printStackTrace();
throwe;
}
}else if(src.isDirectory()){ //文件夹//确保目标文件夹存在
dest.mkdirs();//获取下一级目录|文件
for(File sub:src.listFiles()){
copyDirDetail(sub,newFile(dest,sub.getName()));
}
}
}/*** 文件的拷贝
*@param源文件路径
*@param目录文件路径
*@throwsFileNotFoundException,IOException
*@return
*/
public static void copyFile(String srcPath,String destPath) throwsFileNotFoundException,IOException {//1、建立联系 源(存在且为文件) +目的地(文件可以不存在)
copyFile(new File(srcPath),newFile(destPath));
}/*** 文件的拷贝
*@param源文件File对象
*@param目录文件File对象
*@throwsFileNotFoundException,IOException
*@return
*/
public static void copyFile(File src,File dest) throwsFileNotFoundException,IOException {if(! src.isFile()){ //不是文件或者为null
System.out.println("只能拷贝文件");throw new IOException("只能拷贝文件");
}//dest为已经存在的文件夹，不能建立于文件夹同名的文件
if(dest.isDirectory()){
System.out.println(dest.getAbsolutePath()+"不能建立于文件夹同名的文件");throw new IOException(dest.getAbsolutePath()+"不能建立于文件夹同名的文件");
}//2、选择流
InputStream is =new BufferedInputStream(newFileInputStream(src));
OutputStream os=new BufferedOutputStream(newFileOutputStream(dest));//3、文件拷贝 循环+读取+写出
byte[] flush =new byte[1024];int len =0;//读取
while(-1!=(len=is.read(flush))){//写出
os.write(flush, 0, len);
}
os.flush();//强制刷出//关闭流
os.close();
is.close();
}
}
Fileutil
(三) 字符流
字符流:只能处理 纯文本，全部为可见字符 .txt .html
节点流 Reader FileReader
Writer FileWriter
一、纯文本读取
1、建立联系
2、选择流 Reader FileReader
3、读取 char[] flush =new char[1024];
4、关闭
5 类图
packagecom.bjsxt.io.charIO;importjava.io.File;importjava.io.FileNotFoundException;importjava.io.FileReader;importjava.io.IOException;importjava.io.Reader;/*** 纯文本读取
*@authorAdministrator
**/
public classDemo01 {/***@paramargs*/
public static voidmain(String[] args) {//创建源
File src =new File("E:/xp/test/a.txt");//选择流
Reader reader =null;try{
reader=newFileReader(src);//读取操作
char[] flush =new char[1024];int len =0;while(-1!=(len=reader.read(flush))){//字符数组转成 字符串
String str =new String(flush,0,len);
System.out.println(str);
}
}catch(FileNotFoundException e) {
e.printStackTrace();
System.out.println("源文件不存在");
}catch(IOException e) {
e.printStackTrace();
System.out.println("文件读取失败");
}finally{try{if (null !=reader) {
reader.close();
}
}catch(Exception e2) {
}
}
}
}
fileReader
二、纯文本写出
1、建立联系
2、选择流 Writer FileWriter
3、读取 write(字符数组,0,长度)+flush
write(字符串)
append(字符|字符串)
4、关闭
5 类图
packagecom.bjsxt.io.charIO;importjava.io.File;importjava.io.FileNotFoundException;importjava.io.FileWriter;importjava.io.IOException;importjava.io.Writer;/*** 写出文件
*@authorAdministrator
**/
public classDemo02 {/***@paramargs*/
public static voidmain(String[] args) {//创建源
File dest =new File("e:/xp/test/char.txt");//选择流
Writer wr =null;try{//追加文件，而不是覆盖文件
wr =newFileWriter(dest);//写出
String msg ="追加.....锄禾日当午\r\n码农真辛苦\r\n一本小破书\r\n一读一上午";
wr.write(msg);
wr.append("倒萨发了看电视剧 ");
wr.flush();
}catch(FileNotFoundException e) {
e.printStackTrace();
}catch(IOException e) {
e.printStackTrace();
}finally{try{if (null !=wr) {
wr.close();
}
}catch(Exception e2) {
}
}
}
}
filewriter
packagecom.bjsxt.io.charIO;importjava.io.File;importjava.io.FileNotFoundException;importjava.io.FileReader;importjava.io.FileWriter;importjava.io.IOException;importjava.io.Reader;importjava.io.Writer;/*** 纯文本拷贝
*@authorAdministrator
**/
public classCopyFileDemo {/***@paramargs*/
public static voidmain(String[] args) {//创建源 仅限于 字符的纯文本
File src =new File("E:/xp/test/Demo03.java");
File dest=new File("e:/xp/test/char.txt");//选择流
Reader reader =null;
Writer wr=null;try{
reader=newFileReader(src);
wr=newFileWriter(dest);//读取操作
char[] flush =new char[1024];int len =0;while(-1!=(len=reader.read(flush))){
wr.write(flush,0, len);
}
wr.flush();//强制刷出
} catch(FileNotFoundException e) {
e.printStackTrace();
System.out.println("源文件不存在");
}catch(IOException e) {
e.printStackTrace();
System.out.println("文件读取失败");
}finally{try{if (null !=wr) {
wr.close();
}
}catch(Exception e2) {
}try{if (null !=reader) {
reader.close();
}
}catch(Exception e2) {
}
}
}
}
filrcopy
(四) 处理流
处理流:增强功能、提供性能，节点流之上
一、缓冲流
1)、字节缓冲流
BufferedInputStream
BufferedOutputStream
packagecom.bjsxt.io.buffered;importjava.io.BufferedInputStream;importjava.io.BufferedOutputStream;importjava.io.File;importjava.io.FileInputStream;importjava.io.FileNotFoundException;importjava.io.FileOutputStream;importjava.io.IOException;importjava.io.InputStream;importjava.io.OutputStream;/*** 字节流文件拷贝+缓冲流 ，提高性能
* 缓冲流(节点流)
*@authorAdministrator
**/
public classBufferedByteDemo {/***@paramargs*/
public static voidmain(String[] args) {
}/*** 文件的拷贝
*@param源文件路径
*@param目录文件路径
*@throwsFileNotFoundException,IOException
*@return
*/
public static void copyFile(String srcPath,String destPath) throwsFileNotFoundException,IOException {//1、建立联系 源(存在且为文件) +目的地(文件可以不存在)
File src =newFile(srcPath);
File dest=newFile(destPath);if(! src.isFile()){ //不是文件或者为null
System.out.println("只能拷贝文件");throw new IOException("只能拷贝文件");
}//2、选择流
InputStream is =new BufferedInputStream(newFileInputStream(src));
OutputStream os=new BufferedOutputStream( newFileOutputStream(dest));//3、文件拷贝 循环+读取+写出
byte[] flush =new byte[1024];int len =0;//读取
while(-1!=(len=is.read(flush))){//写出
os.write(flush, 0, len);
}
os.flush();//强制刷出//关闭流
os.close();
is.close();
}
}
bufferedinputstream
2)、字符缓冲流
BufferedReader readLine()
BufferedWriter newLine()
File src =new File("E:/xp/test/Demo03.java");
File dest=new File("e:/xp/test/char.txt");//选择流
BufferedReader reader =null;
BufferedWriter wr=null;try{
reader=new BufferedReader(newFileReader(src));
wr=new BufferedWriter(newFileWriter(dest));//读取操作
/*char[] flush =new char[1024];
int len =0;
while(-1!=(len=reader.read(flush))){
wr.write(flush, 0, len);
}*/
//新增方法的操作
String line =null;while(null!=(line=reader.readLine())){
wr.write(line);//wr.append("\r\n");
wr.newLine(); //换行符号
}
wr.flush();//强制刷出
} catch(FileNotFoundException e) {
e.printStackTrace();
bufferedReader
二、转换流: 字节流 转为字符流 处理乱码(编码集、解码集)
1、编码与解码概念
编码： 字符 ---编码字符集>二进制
解码 : 二进制 --解码字符集-> 字符
2、乱码:
1)编码与解码的字符集不统一
2)字节缺少，长度丢失
3、文件乱码
InputStreamReader(字节输入流,"解码集")
OutputStreamWriter(字符输出流,"编码集")
packagecom.bjsxt.io.convert;importjava.io.UnsupportedEncodingException;public classConverDemo01 {/***@paramargs
*@throwsUnsupportedEncodingException*/
public static void main(String[] args) throwsUnsupportedEncodingException {
String str="中国";byte[] data =str.getBytes();//字节数不完整
System.out.println(new String(data,0,3));
}/*** 编码与解码字符集必须相同，否则乱码
*@throwsUnsupportedEncodingException*/
public static void test1() throwsUnsupportedEncodingException{//解码 byte -->char
String str ="中国"; //gbk//编码 char -->byte
byte[] data =str.getBytes();//编码与解码字符集同一
System.out.println(newString(data));
data=str.getBytes("utf-8"); //设定编码字符集//不同一出现乱码
System.out.println(newString(data));//编码
byte[] data2 = "中国".getBytes("utf-8");//解码
str=new String(data2,"utf-8");
System.out.println(str);
}
}
convert1
packagecom.bjsxt.io.convert;importjava.io.BufferedInputStream;importjava.io.BufferedOutputStream;importjava.io.BufferedReader;importjava.io.BufferedWriter;importjava.io.File;importjava.io.FileInputStream;importjava.io.FileOutputStream;importjava.io.IOException;importjava.io.InputStreamReader;importjava.io.OutputStreamWriter;/*** 转换流: 字节转为字符
* 1、输出流 OutputStreamWriter 编码
* 2、输入流 InputStreamReader 解码
*
* 确保源不能为乱码
*@authorAdministrator
**/
public classConverDemo02 {/***@paramargs
*@throwsIOException*/
public static void main(String[] args) throwsIOException {//指定解码字符集
BufferedReader br =newBufferedReader(newInputStreamReader(newBufferedInputStream(newFileInputStream(new File("E:/xp/test/Demo03.java"))),"UTF-8")
);//写出文件 编码
BufferedWriter bw =newBufferedWriter(newOutputStreamWriter(newBufferedOutputStream(new FileOutputStream(new File("E:/xp/test/encode.java")))));
String info=null;while(null!=(info=br.readLine())){//System.out.println(info);
bw.write(info);
bw.newLine();
}
bw.flush();
bw.close();
br.close();
}
}
convert2
(五) 处理流
一、节点流
1、字节数组 字节 节点流
输入流:ByteArrayInputStream read(byte[] b, int off, int len) + close()
输出流:ByteArrayOutputStream write(byte[] b, int off, int len) +toByteArray() 不要使用多态
packagecom.bjsxt.io.others;importjava.io.BufferedInputStream;importjava.io.ByteArrayInputStream;importjava.io.ByteArrayOutputStream;importjava.io.IOException;importjava.io.InputStream;/*** 字节数组 节点流
* 数组的长度有限 ，数据量不会很大
*
* 文件内容不用太大
* 1、文件 --程序->字节数组
* 2、字节数组 --程序->文件
*
*
*
*@authorAdministrator
**/
public classByteArrayDemo01 {/***@paramargs
*@throwsIOException*/
public static void main(String[] args) throwsIOException {
read(write());
}/*** 输出流 操作与文件输出流 有些不同， 有新增方法，不能使用多态
*@throwsIOException*/
public static byte[] write() throwsIOException{//目的地
byte[] dest;//选择流 不同点
ByteArrayOutputStream bos =newByteArrayOutputStream();//操作 写出
String msg ="操作与 文件输入流操作一致";byte[] info =msg.getBytes();
bos.write(info,0, info.length);//获取数据
dest =bos.toByteArray();//释放资源
bos.close();returndest;
}/*** 输入流 操作与 文件输入流操作一致
* 读取字节数组
*@throwsIOException*/
public static void read(byte[] src) throwsIOException{//数据源传入//选择流
InputStream is =newBufferedInputStream(newByteArrayInputStream(
src
)
);//操作
byte[] flush =new byte[1024];int len =0;while(-1!=(len=is.read(flush))){
System.out.println(new String(flush,0,len));
}//释放资源
is.close();
}
}
bytearrayinputstream
packagecom.bjsxt.io.others;importjava.io.BufferedInputStream;importjava.io.BufferedOutputStream;importjava.io.ByteArrayInputStream;importjava.io.ByteArrayOutputStream;importjava.io.File;importjava.io.FileInputStream;importjava.io.FileOutputStream;importjava.io.IOException;importjava.io.InputStream;importjava.io.OutputStream;/***1、文件 --程序->字节数组
*1)、文件输入流
* 字节数组输出流
*
*
* 2、字节数组 --程序->文件
* 1)、字节数组输入流
* 文件输出流
*@authorAdministrator
**/
public classByteArrayDemo02 {/***@paramargs
*@throwsIOException*/
public static void main(String[] args) throwsIOException {byte[] data =getBytesFromFile("e:/xp/test/1.jpg");
toFileFromByteArray(data,"e:/xp/test/arr.jpg");
}/*** 2、字节数组 --程序->文件*/
public static void toFileFromByteArray(byte[] src,String destPath) throwsIOException{//创建源//目的地
File dest=newFile(destPath);//选择流//字节数组输入流
InputStream is =new BufferedInputStream(newByteArrayInputStream(src));//文件输出流
OutputStream os =new BufferedOutputStream(newFileOutputStream(dest));//操作 不断读取字节数组
byte[] flush =new byte[1];int len =0;while(-1!=(len =is.read(flush))){//写出到文件中
os.write(flush, 0, len);
}
os.flush();//释放资源
os.close();
is.close();
}/*** 1、文件 --程序->字节数组
*@return*@throwsIOException*/
public static byte[] getBytesFromFile(String srcPath) throwsIOException{//创建文件源
File src =newFile(srcPath);//创建字节数组目的地
byte[] dest =null;//选择流//文件输入流
InputStream is =new BufferedInputStream(newFileInputStream(src));//字节数组输出流 不能使用多态
ByteArrayOutputStream bos =newByteArrayOutputStream();//操作 不断读取文件 写出到字节数组流中
byte[] flush =new byte[1024];int len =0;while(-1!=(len =is.read(flush))){//写出到字节数组流中
bos.write(flush, 0, len);
}
bos.flush();//获取数据
dest =bos.toByteArray();
bos.close();
is.close();returndest;
}
}
bytearrayoutputstream
二、处理流
1、基本类型+String 保留数据+类型
输入流:DataInputStream readXxx
输出流:DataOutputStream writeXxx
packagecom.bjsxt.io.others;importjava.io.BufferedInputStream;importjava.io.BufferedOutputStream;importjava.io.DataInputStream;importjava.io.DataOutputStream;importjava.io.File;importjava.io.FileInputStream;importjava.io.FileNotFoundException;importjava.io.FileOutputStream;importjava.io.IOException;/*** 数据类型(基本+String)处理流
* 1、输入流 DataInputStream readXxx()
* 2、输出流 DataOutputStream writeXxx()
* 新增方法不能使用多态
*
* java.io.EOFException :没有读取到相关的内容
*@authorAdministrator
**/
public classDataDemo01 {/***@paramargs*/
public static voidmain(String[] args) {try{//write("e:/xp/test/data.txt");//read("e:/xp/test/arr.txt");//非法内容
read("e:/xp/test/data.txt");
}catch(IOException e) {//TODO Auto-generated catch block
e.printStackTrace();
}
}/*** 从文件读取数据+类型
*@throwsIOException*/
public static void read(String destPath) throwsIOException{//创建源
File src =newFile(destPath);//选择流
DataInputStream dis =newDataInputStream(newBufferedInputStream(newFileInputStream(src)
)
);//操作 读取的顺序与写出一致 必须存在才能读取//不一致，数据存在问题
long num2 =dis.readLong();double num1 =dis.readDouble();
String str=dis.readUTF();
dis.close();
System.out.println(num2+"-->"+str);
}/*** 数据+类型输出到文件
*@throwsIOException*/
public static void write(String destPath) throwsIOException{double point =2.5;long num=100L;
String str="数据类型";//创建源
File dest =newFile(destPath);//选择流 DataOutputStream
DataOutputStream dos =newDataOutputStream(newBufferedOutputStream(newFileOutputStream(dest)
)
);//操作 写出的顺序 为读取准备
dos.writeDouble(point);
dos.writeLong(num);
dos.writeUTF(str);
dos.flush();//释放资源
dos.close();
}
}
datainputsteam
packagecom.bjsxt.io.others;importjava.io.BufferedInputStream;importjava.io.BufferedOutputStream;importjava.io.ByteArrayInputStream;importjava.io.ByteArrayOutputStream;importjava.io.DataInputStream;importjava.io.DataOutputStream;importjava.io.IOException;/*** 数据类型(基本+String)处理流
* 1、输入流 DataInputStream readXxx()
* 2、输出流 DataOutputStream writeXxx()
* 新增方法不能使用多态
*
* java.io.EOFException :没有读取到相关的内容
*@authorAdministrator
**/
public classDataDemo02 {/***@paramargs*/
public static voidmain(String[] args) {try{byte[] data=write();
read(data);
System.out.println(data.length);
}catch(IOException e) {//TODO Auto-generated catch block
e.printStackTrace();
}
}/*** 从字节数组读取数据+类型
*@throwsIOException*/
public static void read(byte[] src) throwsIOException{//选择流
DataInputStream dis =newDataInputStream(newBufferedInputStream(newByteArrayInputStream(src)
)
);//操作 读取的顺序与写出一致 必须存在才能读取
double num1 =dis.readDouble();long num2 =dis.readLong();
String str=dis.readUTF();
dis.close();
System.out.println(num1+"-->"+num2+"-->"+str);
}/*** 数据+类型输出到字节数组中
*@throwsIOException*/
public static byte[] write() throwsIOException{//目标数组
byte[] dest =null;double point =2.5;long num=100L;
String str="数据类型";//选择流 ByteArrayOutputStream DataOutputStream
ByteArrayOutputStream bos =newByteArrayOutputStream();
DataOutputStream dos=newDataOutputStream(newBufferedOutputStream(
bos
)
);//操作 写出的顺序 为读取准备
dos.writeDouble(point);
dos.writeLong(num);
dos.writeUTF(str);
dos.flush();
dest=bos.toByteArray();//释放资源
dos.close();returndest;
}
}
dataoutputsteam
2、引用类型 (对象) 保留数据+类型
反序列化 输入流:ObjectInputStream readObject()
序列化 输出流:ObjectOutputStream writeObject()
注意:
1)、先序列化后反序列化；反序列化顺序必须与序列化一致
2)、不是所有的对象都可以序列化， java.io.Serializable
不是所有的属性都需要序列化，transient
packagecom.bjsxt.io.others;importjava.io.BufferedInputStream;importjava.io.BufferedOutputStream;importjava.io.ByteArrayInputStream;importjava.io.ByteArrayOutputStream;importjava.io.DataInputStream;importjava.io.DataOutputStream;importjava.io.IOException;/*** 数据类型(基本+String)处理流
* 1、输入流 DataInputStream readXxx()
* 2、输出流 DataOutputStream writeXxx()
* 新增方法不能使用多态
*
* java.io.EOFException :没有读取到相关的内容
*@authorAdministrator
**/
public classDataDemo02 {/***@paramargs*/
public static voidmain(String[] args) {try{byte[] data=write();
read(data);
System.out.println(data.length);
}catch(IOException e) {//TODO Auto-generated catch block
e.printStackTrace();
}
}/*** 从字节数组读取数据+类型
*@throwsIOException*/
public static void read(byte[] src) throwsIOException{//选择流
DataInputStream dis =newDataInputStream(newBufferedInputStream(newByteArrayInputStream(src)
)
);//操作 读取的顺序与写出一致 必须存在才能读取
double num1 =dis.readDouble();long num2 =dis.readLong();
String str=dis.readUTF();
dis.close();
System.out.println(num1+"-->"+num2+"-->"+str);
}/*** 数据+类型输出到字节数组中
*@throwsIOException*/
public static byte[] write() throwsIOException{//目标数组
byte[] dest =null;double point =2.5;long num=100L;
String str="数据类型";//选择流 ByteArrayOutputStream DataOutputStream
ByteArrayOutputStream bos =newByteArrayOutputStream();
DataOutputStream dos=newDataOutputStream(newBufferedOutputStream(
bos
)
);//操作 写出的顺序 为读取准备
dos.writeDouble(point);
dos.writeLong(num);
dos.writeUTF(str);
dos.flush();
dest=bos.toByteArray();//释放资源
dos.close();returndest;
}
}
objectinputoutstream
packagecom.bjsxt.io.others;/*** 空接口只是标识
*@authorAdministrator
**/
public class Employee implementsjava.io.Serializable {//不需要序列化
private transientString name;private doublesalary;publicEmployee() {
}public Employee(String name, doublesalary) {super();this.name =name;this.salary =salary;
}publicString getName() {returnname;
}public voidsetName(String name) {this.name =name;
}public doublegetSalary() {returnsalary;
}public void setSalary(doublesalary) {this.salary =salary;
}
}
Employee
3、打印流 PrintStream println() print()
packagecom.bjsxt.io.others;importjava.io.BufferedOutputStream;importjava.io.File;importjava.io.FileNotFoundException;importjava.io.FileOutputStream;importjava.io.PrintStream;/*** PrintStream 打印流 -->处理流
*@authorAdministrator
**/
public classPrintStreamDemo01 {/***@paramargs
*@throwsFileNotFoundException*/
public static void main(String[] args) throwsFileNotFoundException {
System.out.println("test");
PrintStream ps=System.out;
ps.println(false);//输出到文件
File src = new File("e:/xp/test/print.txt");
ps= new PrintStream(new BufferedOutputStream(newFileOutputStream(src)));
ps.println("io is so easy....");
ps.close();
}
}
PrintStream
4、三个常量 : System.in /out/err System.setIn() setOut() setErr()
packagecom.bjsxt.io.others;importjava.io.BufferedInputStream;importjava.io.BufferedOutputStream;importjava.io.FileDescriptor;importjava.io.FileInputStream;importjava.io.FileNotFoundException;importjava.io.FileOutputStream;importjava.io.InputStream;importjava.io.PrintStream;importjava.util.Scanner;/*** 三个常量
* 1、System.in 输入流 键盘输入
* 2、System.out 输出流 控制台输出
* System.err
*
* ==>重定向
* setIn()
* setOut()
* setErr()
* FileDescriptor.in
* FileDescriptor.out
*@authorAdministrator
**/
public classSystemDemo01 {/***@paramargs
*@throwsFileNotFoundException*/
public static void main(String[] args) throwsFileNotFoundException {//test1();//test2();//重定向
System.setOut(new PrintStream(new BufferedOutputStream(new FileOutputStream("e:/xp/test/print.txt")),true));
System.out.println("a"); //控制台 -->文件
System.out.println("test");//回控制台
System.setOut(new PrintStream(new BufferedOutputStream(new FileOutputStream(FileDescriptor.out)),true));
System.out.println("back....");
}public static void test2() throwsFileNotFoundException{
InputStream is=System.in; //键盘输入
is = new BufferedInputStream(new FileInputStream("e:/xp/test/print.txt"));
Scanner sc= newScanner(is);//System.out.println("请输入:");
System.out.println(sc.nextLine());
}public static voidtest1(){
System.out.println("test");
System.err.println("err");
}
}
System
packagecom.bjsxt.io.others;importjava.io.BufferedReader;importjava.io.IOException;importjava.io.InputStream;importjava.io.InputStreamReader;/*** 封装输入
*@authorAdministrator
**/
public classBuffereIn {/***@paramargs
*@throwsIOException*/
public static void main(String[] args) throwsIOException {
InputStream is=System.in;
BufferedReader br= new BufferedReader(newInputStreamReader(is));
System.out.println("请输入。。。。");
String msg=br.readLine();
System.out.println(msg);
}
conslo
(六)文件分割与合并
packagecom.bjsxt.io.others;importjava.io.File;importjava.io.IOException;importjava.io.RandomAccessFile;importcom.bjsxt.io.util.FileUtil;/*** 文件的分割思路
* 1、分割的块数 size n块
* 2、每一块的大小 blockSize
* 最后:总的文件大小 -(n-1)*blockSize
*
*@authorAdministrator
**/
public classRndDemo01 {/***@paramargs
*@throwsIOException*/
public static void main(String[] args) throwsIOException {
RandomAccessFile rnd=new RandomAccessFile(new File("E:/xp/20130502/test/test.java"),"r");
rnd.seek(40);//定义缓冲大小
byte[] flush =new byte[1024];//接收长度
int len =0;while(-1!=(len=rnd.read(flush))){if(len>=20){
System.out.println(new String(flush,0,20));break;
}else{
System.out.println(new String(flush,0,len));
}
}
FileUtil.close(rnd);
}
}
random
packagecom.bjsxt.io.others;importjava.io.BufferedInputStream;importjava.io.BufferedOutputStream;importjava.io.File;importjava.io.FileInputStream;importjava.io.FileNotFoundException;importjava.io.FileOutputStream;importjava.io.IOException;importjava.io.InputStream;importjava.io.RandomAccessFile;importjava.io.SequenceInputStream;importjava.util.ArrayList;importjava.util.List;importjava.util.Vector;importcom.bjsxt.io.util.FileUtil;public classSplitFile {//文件的路径
privateString filePath;//文件名
privateString fileName;//文件大小
private longlength;//块数
private intsize;//每块的大小
private longblockSize;//分割后的存放目录
privateString destBlockPath;//每块的名称
private ListblockPath;publicSplitFile(){
blockPath= new ArrayList();
}publicSplitFile(String filePath,String destBlockPath){this(filePath,destBlockPath,1024);
}public SplitFile(String filePath,String destBlockPath,longblockSize){this();this.filePath=filePath;this.destBlockPath =destBlockPath;this.blockSize=blockSize;
init();
}/*** 初始化操作 计算 块数、确定文件名*/
public voidinit(){
File src=null;//健壮性
if(null==filePath ||!(((src=newFile(filePath)).exists()))){return;
}if(src.isDirectory()){return;
}//文件名
this.fileName =src.getName();//计算块数 实际大小 与每块大小
this.length =src.length();//修正 每块大小
if(this.blockSize>length){this.blockSize =length;
}//确定块数
size= (int)(Math.ceil(length*1.0/this.blockSize));//确定文件的路径
initPathName();
}private voidinitPathName(){for(int i=0;i
}
}/*** 文件的分割
* 0)、第几块
* 1、起始位置
* 2、实际大小
*@paramdestPath 分割文件存放目录*/
public voidsplit(){long beginPos =0; //起始点
long actualBlockSize =blockSize; //实际大小//计算所有块的大小、位置、索引
for(int i=0;i
actualBlockSize =this.length-beginPos;
}
spiltDetail(i,beginPos,actualBlockSize);
beginPos+=actualBlockSize; //本次的终点，下一次的起点
}
}/*** 文件的分割 输入 输出
* 文件拷贝
*@paramidx 第几块
*@parambeginPos 起始点
*@paramactualBlockSize 实际大小*/
private void spiltDetail(int idx,long beginPos,longactualBlockSize){//1、创建源
File src = new File(this.filePath); //源文件
File dest = new File(this.blockPath.get(idx)); //目标文件//2、选择流
RandomAccessFile raf = null; //输入流
BufferedOutputStream bos=null; //输出流
try{
raf=new RandomAccessFile(src,"r");
bos=new BufferedOutputStream(newFileOutputStream(dest));//读取文件
raf.seek(beginPos);//缓冲区
byte[] flush = new byte[1024];//接收长度
int len =0;while(-1!=(len=raf.read(flush))){if(actualBlockSize-len>=0){ //查看是否足够//写出
bos.write(flush, 0, len);
actualBlockSize-=len; //剩余量
}else{ //写出最后一次的剩余量
bos.write(flush, 0, (int)actualBlockSize);break;
}
}
}catch(FileNotFoundException e) {
e.printStackTrace();
}catch(IOException e) {
e.printStackTrace();
}finally{
FileUtil.close(bos,raf);
}
}/*** 文件的合并*/
public voidmerge(String destPath){//创建源
File dest =newFile(destPath);//选择流
BufferedOutputStream bos=null; //输出流
SequenceInputStream sis =null ;//输入流//创建一个容器
Vector vi = new Vector();try{for (int i = 0; i < this.blockPath.size(); i++) {
vi.add(new BufferedInputStream(new FileInputStream(new File(this.blockPath.get(i)))));
}
bos=new BufferedOutputStream(new FileOutputStream(dest,true)); //追加
sis=newSequenceInputStream(vi.elements());//缓冲区
byte[] flush = new byte[1024];//接收长度
int len =0;while(-1!=(len=sis.read(flush))){
bos.write(flush,0, len);
}
bos.flush();
FileUtil.close(sis);
}catch(Exception e) {
}finally{
FileUtil.close(bos);
}
}/*** 文件的合并*/
public voidmerge1(String destPath){//创建源
File dest =newFile(destPath);//选择流
BufferedOutputStream bos=null; //输出流
try{
bos=new BufferedOutputStream(new FileOutputStream(dest,true)); //追加
BufferedInputStream bis = null;for (int i = 0; i < this.blockPath.size(); i++) {
bis= new BufferedInputStream(new FileInputStream(new File(this.blockPath.get(i))));//缓冲区
byte[] flush = new byte[1024];//接收长度
int len =0;while(-1!=(len=bis.read(flush))){
bos.write(flush,0, len);
}
bos.flush();
FileUtil.close(bis);
}
}catch(Exception e) {
}finally{
FileUtil.close(bos);
}
}/***@paramargs*/
public static voidmain(String[] args) {
SplitFile split= new SplitFile("E:/xp/20130502/test/学员设置(20130502).xls","E:/xp/20130502",51);//System.out.println(split.size);//split.split();
split.merge("E:/xp/20130502/test1.xls");
}
}
SplitFile
160
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
