java使用转换流复制_Java对IO中每个流的理解心得，字符流字节流，转换流复制，对象流，分割流【诗书画唱】...

写一下你对IO流的心得，对于每个流的理解

如果我们把水当做文件，把水工厂当做file类，将运输用的大小水管当做inputstream，outputstream，reader，writer，再把瓢子，盘，水桶等容器当做数组，char等。file类是可以放很多很多的水的大仓库，通过inputstream，outputstream，reader，writer这四个节点流(=水管)，将水运输到社区，最后，用不同容器(=数组，char)将水装出来用。

字节流：一次读入或读出是8位二进制

字符流：一次读入或读出是16位二进制

JDK 中后缀是 Stream 是字节流；后缀是 Reader，Writer 是字符流

节点流：直接与数据源相连，读入或写出

处理流：与节点流一块使用，在节点流的基础上，再套接一层

常用的流对文件进行操作：FileInputStream(字节输入流)、FileOutputStream(字节输出流)、FileReader(字符输入流)、FileWriter(字符输出流)

对管道进行操作：PipedInputStream(字节输入流)、PipedOutStream(字节输出流)、PipedReader(字符输入流)、PipedWriter(字符输出流)

字节/字符数组：ByteArrayInputStream、ByteArrayOutputStream、CharArrayReader、CharArrayWriter

Buffered 缓冲流：BufferedInputStream、BufferedOutputStream、BufferedReader、BufferedWriter

字节转化成字符流：InputStreamReader、OutputStreamWriter

数据流：DataInputStream、DataOutputStream

打印流：PrintStream、PrintWriter

对象流：ObjectInputStream、ObjectOutputStream

序列化流：SequenceInputStream

使用字符流(就是用上BufferedReader等)复制一个文本文件

//字节流:

//FileInputStream：字节输入流

//FileOutputStream:字节输出流

//字节流是可以读取任何文件，每次读取的时候是1字节

//缓冲流(包装流):

//BufferedReader:字符输入缓冲流

//BufferedWriter:字符输出缓冲流

//BufferedInputStream:字节输入缓冲流

//BufferedOutputStream:字节输出缓冲流

//为了提高读写流的效率，引入了缓冲机制，

//进行批量的读写，提高了读写的效率。

//Buffered包装类用于加快了读写内容的速度转换流:

//两个功能:1.将输入的字节转换为字符

//2.进行编码转换

//InputStreamReader:字节输入转换流

//OutputStreamWriter:字节输出转换流

package all;

import java.io.*;

public class copy {

public static void main(String[] args) throws IOException {

File old = new File("xiangDui.txt");

File copy = new File("xiangDuiCopy.txt");

CopyFangFa(old,copy);

}

public static void CopyFangFa(File old,File copy)

throws IOException {

//用FileInputStream等来创建字节输入输出流对象：

FileInputStream byteInput = new FileInputStream(old);

FileOutputStream byteOut = new FileOutputStream(copy);

//复制过程用字节数组和write写入来实现：

//用每次读取1024的字节的话，执行所花的时间就会变得更少。

int len;

byte[] byteArray = new byte[1024];

while ((len = byteInput.read(byteArray)) != -1) {

byteOut.write(byteArray, 0, len);

}

//用close，关闭，之后可释放资源：

byteOut.close();

byteInput.close();

}

}

使用字节流(FileInputStream等)复制一个图片

package IO;

import java.io.*;

public class copyImg {

public static void main(String[] args) throws Exception {

File oldFile=new File("7.jpg");

BufferedInputStream CharInput=

new BufferedInputStream(

new FileInputStream(oldFile));

BufferedOutputStream CharOut=

new BufferedOutputStream(new FileOutputStream("7Copy.jpg"));

byte[] byteArray=new byte[1024];

int length=0;

while((length=CharInput.read(byteArray))!=-1){

CharOut.write(byteArray,0,length);

}

CharOut.flush();

CharOut.close();

CharInput.close();

System.out.println("复制成功！");

}}

使用缓冲流复制一个文件夹和里面的所有文件

package all;

import java.io.*;

public class copyWenJianjia {

public static void copyAllFanFa(File oldFile, File copyFile)

throws Exception{

//用isDirectory判断原来的老的文件是否是文件夹

if (oldFile.isDirectory()) {

// 被复制的文件没复制成功，不存在，就创建文件夹

if (!copyFile.exists()) {

copyFile.mkdir();

}

// 将文件夹下的文件存入文件数组StringArray(字符串数组)

String[] StringArray = oldFile.list();

for (String File : StringArray) {

//用new等创建文件夹下的子目录，src：路径或目录

File oldFileSrc = new File(oldFile, File);

File copyFileSrc = new File(copyFile, File);

// 个人的理解：在自身方法中调用自身的方法，

//                  这样的话调用一次方法，就是调用了

//                  很多次正在循环执行的方法

//                  直到文件等遍历完了，就是将文件进行下一层循环。

copyAllFanFa(oldFileSrc, copyFileSrc);

}

} else {

// 创建FileInputStream(文件输入字节流)

//        :  用于读取文件内容，源文件

FileInputStream byteInput = new FileInputStream(oldFile);

// 创建FileOutputStream(文件输出的字节流)

//              ，用于将读取到的文件内容

//              写到另一个磁盘文件中，复制目标文件等

FileOutputStream byteOut =

new FileOutputStream(copyFile);

int len = -1;

byte[] byteArray = new byte[1024];

while (true) {

// 从FileInputStream(文件输入流)

//     中读取数据。每执行一次,数据读到字节数组b中

len = byteInput.read(byteArray, 0, 256);

if (len == -1) {

break;

}

//                  System.out.println(byteArray.toString());

byteOut.write(byteArray);

}

//              byteOut.write("\r\n".getBytes()); // 换行

byteInput.close();

byteOut.close();

}

}

public static void main(String[] args)

throws Exception{

copyAllFanFa(new File("NewFile"),new File("NewCopyFile"));

}

}

使用转换流复制一个文件夹下的所有txt文件，将文件的编码格式转换为utf-8

package all;

import java.io.*;

public class copyAlltxt {

public static void copyAllFanFa(File oldFile, File copyFile)

throws Exception{

if (oldFile.isDirectory()) {

if (!copyFile.exists()) {

copyFile.mkdir();

}

String[] StringArray = oldFile.list();

for (String File : StringArray) {

File oldFileSrc = new File(oldFile, File);

File copyFileSrc = new File(copyFile, File);

copyAllFanFa(oldFileSrc, copyFileSrc);

}

} else {

FileInputStream byteInput =

new FileInputStream(oldFile);

InputStreamReader byteChangeInput=

new InputStreamReader(byteInput,"UTF-8");

//      InputStreamReader:字节输入转换流(个人的理解：

//      把一些内容转格式后保存。)

FileOutputStream byteOut =

new FileOutputStream(copyFile);

char[] charArray=new char[100];

int len;

byte[] byteArray= new byte[1024];

while((len=byteChangeInput.read(charArray))!=-1){

byteOut.write(byteArray);

}

byteChangeInput.close();

byteInput.close();

byteOut.close();

}

}

public static void main(String[] args)

throws Exception{

copyAllFanFa(new File("NewFile"),new File("NewCopyFile"));

}

}

使用分割流复制一个文本文件

//字节流:

//FileInputStream：字节输入流

//FileOutputStream:字节输出流

//字节流是可以读取任何文件，每次读取的时候是1字节

//缓冲流(包装流):

//BufferedReader:字符输入缓冲流

//BufferedWriter:字符输出缓冲流

//BufferedInputStream:字节输入缓冲流

//BufferedOutputStream:字节输出缓冲流

//为了提高读写流的效率，引入了缓冲机制，

//进行批量的读写，提高了读写的效率。

//Buffered包装类用于加快了读写内容的速度转换流:

//两个功能:1.将输入的字节转换为字符

//2.进行编码转换

//InputStreamReader:字节输入转换流

//OutputStreamWriter:字节输出转换流

package fenGeLiu;

import java.io.*;

public class copy {

public static void main(String[] args) throws IOException {

File old = new File("xiangDui.txt");

File copy = new File("xiangDuiCopy.txt");

CopyFangFa(old,copy);

}

public static void CopyFangFa(File old,File copy)

throws IOException {

//用FileInputStream等来创建字节输入输出流对象：

RandomAccessFile byteInput=new RandomAccessFile(old,"r");

//r：是固定不可变的“key”一般的，代表read的部分

RandomAccessFile byteOut=new RandomAccessFile(copy,"rw");

//rw：是固定不可变的“key”一般的，代表read后的write的部分

//——————————————————

//FileInputStream byteInput = new FileInputStream(old);

//

//FileOutputStream byteOut = new FileOutputStream(copy);

//——————————————————————

//复制过程用字节数组和write写入来实现：

//用每次读取1024的字节的话，执行所花的时间就会变得更少。

int len;

byte[] byteArray = new byte[1024];

while ((len = byteInput.read(byteArray)) != -1) {

byteOut.write(byteArray, 0, len);

}

//用close，关闭，之后可释放资源：

byteOut.close();

byteInput.close();

}

}

使用对象流保存一个对象的信息

package fenGeLiu;

import java.io.*;

import java.util.Date;

public class baoLiuOneObject {

public static void main(String[] args) throws Exception{

student duiXiang1=new student(666,"诗书画唱三连关注",100.0f);

File File=new File("new.txt");

FileOutputStream FileOutput=new FileOutputStream(File);

ObjectOutputStream ObjectOutput

=new ObjectOutputStream(FileOutput);

ObjectOutput.writeObject(duiXiang1);

ObjectOutput.writeObject(null);

ObjectOutput.close();

System.out.println("存储成功");

//下面是打印所有的存在new.txt的文件的对象的内容：

//File File=new File("new.txt");

//传入字节输入流：

FileInputStream byteInputAll=new FileInputStream(File);

//duiXiangInput【“拼音+英文”的自己的命名】(对象输入流)。

ObjectInputStream duiXiangInput

=new ObjectInputStream(byteInputAll);

Object duiXiang="";

while((duiXiang=duiXiangInput.readObject())!=null){

System.out.println(duiXiang.toString());

}

duiXiangInput.close();

}

}

class student implements Serializable{

int bianHao;

String name;

//transient float chengJi;

float chengJi;

//这里用transient来让成绩(chengJi)不参与序列化,

//就是后面用toString方法返回的时候，

//不会打印出传入的真实成绩放的内容。

public student(int bianHao, String name, float chengJi) {

this.bianHao = bianHao;

this.name = name;

this.chengJi = chengJi;

}

@Override

public String toString() {

return "编号：" +

bianHao + ", 姓名：" + name + ", 成绩("

+ "若该变量数据类型前"

+ "\n设置为transient，就不能打印传入的内容"

+ "\n出来的成绩默认为0.0)：" +chengJi+ "\n";

}

}