转化流 InputSteamReader和OutputStreamWriter
对象流 ObjectInputStream和ObjectOutputStream
随机访问RandomAccessFile RandomAccessFile
File f = new File("D:\\test\\abc\\tt.txt");//这个时候对象f就是tt.txt文件
File f4 = new File("D:\\test\\abc");//这个目录
// File f2 = new File("D:/test/abc/tt.txt");
// File f3 = new File("D:" + File.separator + "test\\abc\\tt.txt");
// File f1 = new File("D:\\test","abc\\tt.txt");//这个f1也是tt.txt文件，这种实验相对比较少
//注意，\在文件中是路径的分隔符，但是在java编程中一个\的意思是转移符，在java中\\或者/才是文件的分隔符
//也可以File.separator作为文件分隔符
System.out.println(f.getName());//获取文件名
System.out.println(f4.getName());//获取文当前的文件名称
File f5 = new File("src/day12/Test.java");//使用相对路径来创建file对象
System.out.println(f5.getPath());//获取文件或者文件夹的路径，就是new file时候写的路径
System.out.println(f5.getAbsolutePath());//获取当前文件的绝对路径
System.out.println(f5);
System.out.println(f5.getAbsoluteFile());//返回一个用当前的文件的绝对路径构建的file对象
System.out.println(f5.getParent());//返回当前文件或者文件夹的父级路径
// f.renameTo(new File("D:\\test\\abc\\tt1.txt"));//给文件或文件夹重命名
File f6 = new File("D:\\test\\abc1");
System.out.println(f6.exists());//判断文件或者文件夹是否存在
File f7 = new File("D:\\test\\abc\\tt1.txt");
System.out.println(f7.canWrite());//判断文件是否可写
System.out.println(f7.canRead());//判断文件是否可读
System.out.println(f7.isFile());//判断当前的file对象是不是文件
System.out.println(f7.isDirectory());//判断当前的file对象是不是文件夹或者目录
System.out.println(f7.lastModified());//获取文件的最后修改时间，返回的是一个毫秒数
System.out.println(f7.length());//返回文件的长度，单位是字节数
File f8 = new File("D:\\test\\abc\\tt2.txt");
System.out.println(f8.exists());//判断文件是否存在
if(!f8.exists()){
try {
f8.createNewFile();//创建新的文件
} catch (IOException e) {
e.printStackTrace();
}
}
f8.delete();//删除文件
File f9 = new File("D:\\test\\abc\\cc");
// File f9 = new File("D:\\test\\abc\\cc\\dd");
f9.mkdir();//创建单层目录，如果使用这一方法来创建多层目录，就得一层一层的执行mkdir()
File f10 = new File("D:\\test\\abc\\a\\b\\c");
f10.mkdirs();//这个方法是直接用来创建多层目录
File f11 = new File("D:\\test");
String[] fl = f11.list();//返回的是当前文件夹的子集的名称，包括目录和文件
for(String s : fl){
System.out.println(s);
}
File[] fs = f11.listFiles();//返回的是当前文件夹的子集的file对象，包括目录和文件
for(File ff : fs){
System.out.println(ff);
}
递归
import java.io.File;
public class Test11 {
public static void main(String[] args) {
//遍历d盘下的test文件，把test文件夹下所有的目录与文件全部遍历出来，不论层级有多深，要全部遍历出来
//这个使用递归的方式来实现
File f = new File("D:\\test");
new Test11().test(f);
}
/**
* 递归遍历文件
* @param file
*/
public void test(File file){
if(file.isFile()){
System.out.println(file.getAbsolutePath() + " 是文件");
}else{
System.out.println(file.getAbsolutePath() + " 是文件夹");
//如果是文件夹，这个文件夹里就可能有子文件夹或者文件
File[] fs = file.listFiles();//获取当前文件夹下的子文件夹或者文件的file对象
if(fs != null && fs.length > 0){
for(File ff : fs){
test(ff);//递归
// if(ff.isFile()){
// System.out.println(ff.getAbsolutePath() + " 是文件");
// }else{
// System.out.println(ff.getAbsolutePath() + " 是文件夹");
// File[] fs1 = ff.listFiles();
// if(fs1 != null && fs1.length > 0){
// for(File ff1 : fs1){
//
// }
// }
// }
}
}
}
}
}
Java IO原理
输入input：读取外部数据（磁盘、光盘等存储设备的数据）到程序（内存）中。
l
输出
output
：
将程序（内存）数据输出到磁盘、光盘等存储设备中
不论输入输出，都是指的计算机
流的分类
IO 流体系
文件字节输入流FileInputStream
* 在读取文件时，必须保证该文件已存在，否则出异常
public static void testFileInputStream(){
try {
FileInputStream in = new FileInputStream("D:/test/abc/tt1.txt");
byte[] b = new byte[10];//设置一个byte数组接收读取的文件的内容
int len = 0;//设置一个读取数据的长度
// in.read(b);//in.read方法有一个返回值，返回值是读取的数据的长度，如果读取到最后一个数据，还会向后读一个，这个时候返回值就是-1
//也就意味着当in.read的返回值是-1的时候整个文件就读取完毕了
while((len = in.read(b)) != -1){
System.out.println(new String(b,0,len));
//new String(b,0,len),参数1是缓冲数据的数组，参数2是从数组的那个位置开始转化字符串，参数3是总共转化几个字节
}
in.close();//注意。流在使用完毕之后一段要关闭
} catch (Exception e) {
e.printStackTrace();
}
} 文件字节输出流FileOutputStream
* 在写入一个文件时，如果目录下有同名文件将被覆盖
public static void testFileOutputStream(){
try {
FileOutputStream out = new FileOutputStream("D:/test/abc/tt4.txt");//指定行tt4输出数据
String str = "knsasjadkajsdkjsa";
out.write(str.getBytes());//把数据写到内存
out.flush();//把内存中的数据刷写到硬盘
out.close();//关闭流
} catch (Exception e) {
e.printStackTrace();
}
}复制文件到指定位置
/**
* 复制文件到指定位置
* @param inPath 源文件路径
* @param outPanth 复制到的文件夹位置
*/
public static void copyFile(String inPath, String outPanth){
try {
FileInputStream in = new FileInputStream(inPath);//读取的源文件
FileOutputStream out = new FileOutputStream(outPanth);//复制到哪里
byte[] b = new byte[100];
int len = 0;
while((len = in.read(b)) != -1){
//参数1是写的缓冲数组，
//参数2是从数组的那个位置开始，参数3是获取的数组的总长度
out.write(b, 0, len);
}
out.flush();//把写到内存的数据刷到硬盘
out.close();
in.close();
} catch (Exception e) {
e.printStackTrace();
}
}
结果
Test1.testFileInputStream();
// Test1.testFileOutputStream();
// Test1.copyFile("D:/test/abc/tt1.txt","D:/test/abc/cc/tt1.txt");
Test1.copyFile("D:/test/abc/img.png","D:/test/abc/cc/img.png");注意：文件字节流非常通用，可以用来操作字符的文档，还可以操作任何的其他类型文件（图片，压缩包等等），引用字节流直接使用二进制
文件字符流
定义文件路径时，注意：可以用“/”或者“\\”。
在写入一个文件时，如果目录下有同名文件将被覆盖。
在读取文件时，必须保证该文件已存在，否则出异常。
public class Test2 {
public static void main(String[] args) {
Test2.testFileReader("D:/test/abc/tt1.txt");
//在写入一个文件时，如果目录下有同名文件将被覆盖。
// Test2.testFileWriter("!!!!!!!", "D:/test/abc/tt5.txt");
// Test2.copyFile("D:/test/abc/tt5.txt", "D:/test/abc/cc/tt5.txt");
}
/**
* 文件字符输入流FileReader
* 在读取文件时，必须保证该文件已存在，否则出异常
* @param inPath
*/
public static void testFileReader(String inPath){
try {
FileReader fr = new FileReader(inPath);//创建文件字符输入流的对象
char[] c = new char[10];//创建临时存数据的字符数组
int len = 0;//定义一个输入流的读取长度
while((len = fr.read(c)) != -1){
System.out.println(new String(c, 0, len));
}
fr.close();//关闭流
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 文件字符输出流FileWriter
* 在写入一个文件时，如果目录下有同名文件将被覆盖
* @param text 输出的内容
* @param outPath 输出的文件
*/
public static void testFileWriter(String text,String outPath){
try {
FileWriter fw = new FileWriter(outPath);
fw.write(text);//写到内存中
fw.flush();//把内存的数据刷到硬盘
fw.close();//关闭流
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 字符流完成拷贝文件,字符流只适合操作内容是字符文件
* @param inPaht
* @param outPath
*/
public static void copyFile(String inPaht, String outPath){
try {
FileReader fr = new FileReader(inPaht);
FileWriter fw = new FileWriter(outPath);
char[] c = new char[100];
int len = 0;
while((len = fr.read(c)) != -1){//读取数据
fw.write(c,0,len);//写数据到内存
}
fw.flush();
fw.close();
fr.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
缓冲流
缓冲字节流
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
/**
* 缓冲字节流
*/
public class Test {
public static void main(String[] args) {
try {
// Test.testBufferedInputStream();
// Test.testBufferedOutputStream();
Test.copyFile();
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 缓冲字节输入流
* BufferedInputStream
* @throws Exception
*/
public static void testBufferedInputStream() throws Exception{
//文件字节输入流对象
FileInputStream in = new FileInputStream("D:\\testdemo\\demo\\src\\day13\\tt.txt");
//把文件字节输入流放到缓冲字节输入流对象
BufferedInputStream br = new BufferedInputStream(in);
byte[] b = new byte[10];
int len = 0;
while((len = br.read(b)) != -1){
System.out.println(new String(b,0,len));
}
//关闭流的时候，本着一个最晚开的最早关，依次关
br.close();
in.close();
}
/**
* 缓冲字节输出流
* BufferedOutputStream
*/
public static void testBufferedOutputStream() throws Exception{
//创建字节输出流对象
FileOutputStream out = new FileOutputStream("D:\\testdemo\\demo\\src\\day13\\tt1.txt");
//把字节输出流对象放到缓冲字节输出流中
BufferedOutputStream bo = new BufferedOutputStream(out);
String s = "hello world";
bo.write(s.getBytes());//写到内存中
bo.flush();//刷到硬盘上
//关闭流的时候，本着一个最晚开的最早关，依次关
bo.close();
out.close();
}
/**
* 缓冲流实现文件的复制
*/
public static void copyFile() throws Exception{
//缓冲输入流
BufferedInputStream br = new BufferedInputStream(new FileInputStream("D:\\testdemo\\demo\\src\\day13\\tt1.txt"));
//缓冲输出流
BufferedOutputStream bo = new BufferedOutputStream(new FileOutputStream("D:\\testdemo\\demo\\src\\day13\\tt2.txt"));
byte[] b = new byte[1024];
int len = 0;//设置一个没出读取到的数据的长度，直到br.read方法执行到最后（比如说文件中只有hello world，执行到最后一个就读取d的后面，这个时候返回值就是-1）
while((len = br.read(b)) != -1){
bo.write(b, 0, len);//写到内存
}
bo.flush();//刷到硬盘
bo.close();
br.close();
}
}
缓冲字符流
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
/**
* 缓冲字符流
*
*/
public class Test1 {
public static void main(String[] args) {
try {
// Test1.testBufferedReader();
// Test1.testBufferedWriter();
Test1.copyFile();
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 缓冲字符输入流
* BufferedReader
*/
public static void testBufferedReader() throws Exception{
FileReader r = new FileReader("D:\\testdemo\\demo\\src\\day13\\tt.txt");
BufferedReader br = new BufferedReader(r);
char[] c = new char[100];
int len = 0;
while((len = br.read(c)) != -1){//br.read(c)读到文件的最后一个字符的下一位，返回值就是-1
System.out.println(new String(c, 0, len));
}
br.close();
r.close();
}
/**
* 缓冲字符输出流
* BufferedWriter
*/
public static void testBufferedWriter() throws Exception{
FileWriter fw = new FileWriter("D:\\testdemo\\demo\\src\\day13\\tt3.txt");
BufferedWriter bw = new BufferedWriter(fw);
String s = "hello world!!!!";
bw.write(s);
bw.flush();
bw.close();
fw.close();
}
/**
* 缓冲字符流复制文件
*/
public static void copyFile() throws Exception{
BufferedReader br = new BufferedReader(new FileReader("D:\\testdemo\\demo\\src\\day13\\tt3.txt"));
BufferedWriter bw = new BufferedWriter(new FileWriter("D:\\testdemo\\demo\\src\\day13\\tt4.txt"));
char[] c = new char[100];
int len = 0;
while((len = br.read(c)) != -1){
bw.write(c, 0, len);
}
bw.flush();
bw.close();
br.close();
}
}
转化流
转换流提供了在字节流和字符流之间的转换
Java API提供了两个转换流：
InputStreamReader和OutputStreamWriter
字节流中的数据都是字符时，转成字符流操作更高效。
InputStreamReader
用于将字节流中读取到的字节按指定字符集解码成字符。需要和InputStream“套接”。
构造方法
InputStreamReader(InputStream in)
public InputSreamReader(InputStream in,String charsetName)
如： Reader isr = new InputStreamReader(System.in,"ISO5334_1");
OutputStreamWriter
用于将要写入到字节流中的字符按指定字符集编码成字节。 需要和OutputStream“套接”。
构造方法
public OutputStreamWriter(OutputStream out)
public OutputSreamWriter(OutputStream out,String charsetName)
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
/**
* 转换流
* 可以把字节流转换为字符流
* 当字节流中的数据都是字符的时候，使用转换流转为字符流处理效率更高
*/
public class Test2 {
public static void main(String[] args) {
//所有的文件都是有编码格式
//对于我们来说，TXT和java文件一般来讲有三种编码
//ISO8859-1，西欧编码，是纯粹英文编码，不适应汉字
//GBK和UTF-8，这两编码是适用于重要和英文
//我们一般使用UTF-8编码
try {
// Test2.testInputStreamReader();
Test2.testOutputStreamWriter();
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 转换字节输入流为字符输入流
* 注意，在转换字符流的时候，设置的字符集编码要与读取的文件的数据的编码一致
* 不然就会出现乱码
* InputStreamReader
*/
public static void testInputStreamReader() throws Exception{
FileInputStream fs = new FileInputStream("D:\\testdemo\\demo\\src\\day13\\tt5.txt");
//把字节流转换为字符流
InputStreamReader in = new InputStreamReader(fs,"GBK");//参数1是字节流，参数2是编码
// InputStreamReader in = new InputStreamReader(fs,"UTF-8");//参数1是字节流，参数2是编码
char[] c = new char[100];
int len = 0;
while((len = in.read(c)) != -1){
System.out.println(new String(c,0,len));
}
in.close();
fs.close();
}
/**
* 转换字节输出流为字符输出流
* 注意，在转换字符流的时候，设置的字符集编码要与读取的文件的数据的编码一致
* 不然就会出现乱码
* OutputStreamWriter
*/
public static void testOutputStreamWriter() throws Exception{
FileOutputStream out = new FileOutputStream("D:\\testdemo\\demo\\src\\day13\\tt6.txt");
// OutputStreamWriter os = new OutputStreamWriter(out, "UTF-8");
OutputStreamWriter os = new OutputStreamWriter(out, "GBK");
os.write("你好你好");
os.flush();
os.close();
out.close();
}
}
标准输入输出流
package day13;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.InputStreamReader;
/**
* 标准输入和输出流
*
*/
public class Test3 {
public static void main(String[] args) {
try {
// Test3.testSystemIn();
Test3.write2TXT();
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 标准的输入流
* @throws Exception
*/
public static void testSystemIn() throws Exception{
//创建一个接收键盘输入数据的输入流
InputStreamReader is = new InputStreamReader(System.in);
//把输入流放到缓冲流里
BufferedReader br = new BufferedReader(is);
String str = "";//定义一个临时接收数据的字符串
while((str = br.readLine()) != null){
System.out.println(str);
}
br.close();
is.close();
}
/**
* 把控制台输入的内容写到指定的TXT文件中，当接收到字符串over，就结束程序的运行
*/
public static void write2TXT() throws Exception{
//创建一个接收键盘输入数据的输入流
InputStreamReader is = new InputStreamReader(System.in);
//把输入流放到缓冲流里
BufferedReader br = new BufferedReader(is);
BufferedWriter out = new BufferedWriter(new FileWriter("D:\\testdemo\\demo\\src\\day13\\tt7.txt"));
String line = "";
while((line = br.readLine()) != null){
if(line.equals("over")){
break;
}
//读取的每一行都写到指定的TXT文件
out.write(line);
}
out.flush();
out.close();
br.close();
is.close();
}
}
打印流
在整个IO包中，打印流是输出信息最方便的类。
PrintStream(字节打印流)和PrintWriter(字符打印流)提供了一系列重载的print和println方法，用于多种数据类型的输出
PrintStream和PrintWriter的输出不会抛出异常
PrintStream和PrintWriter有自动flush功能
System.out返回的是PrintStream的实例
数据流
为了方便地操作Java语言的基本数据类型的数据，可以使用数据流。
数据流有两个类：(用于读取和写出基本数据类型的数据）
DataInputStream 和 DataOutputStream
分别“套接”在 InputStream 和 OutputStream 节点流上
DataInputStream中的方法
boolean readBoolean() byte readByte()
char readChar() float readFloat()
double readDouble() short readShort()
long readLong() int readInt()
String readUTF() void readFully(byte[] b)
DataOutputStream中的方法
将上述的方法的read改为相应的write即可。
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
/**
* 数据流，专门用来做基本数据类型的读写的
*/
public class Test4 {
public static void main(String[] args) {
try {
// Test4.testDataOutputStream();
Test4.testDataInputStream();
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 数据输出流
* 用数据输出流写到文件的中的基本数据类型的数据，是乱码的，不能直接辨认出来，需要数据输入流来读取
* DataOutputStream
*/
public static void testDataOutputStream() throws Exception{
DataOutputStream out = new DataOutputStream(new FileOutputStream("D:/testdemo/demo/src/day13/tt8.txt"));
// out.writeBoolean(true);
out.writeDouble(1.35d);
// out.writeInt(100);
out.flush();
out.close();
}
/**
* 数据输入流
* 用数据输出流写到文件的中的基本数据类型的数据，是乱码的，不能直接辨认出来，需要数据输入流来读取
* 用数据输入流读取数据输出流写到文件中的数据时，要保证使用和当时写的数据类型一致的类型来读取
* 也就是说，如果写的时候是writeDouble，读的时候就得是readDouble
* DataInputStream
*/
public static void testDataInputStream() throws Exception{
DataInputStream in = new DataInputStream(new FileInputStream("D:/testdemo/demo/src/day13/tt8.txt"));
System.out.println(in.readDouble());
in.close();
}
}
对象流
若某个类实现了 Serializable 接口，该类的对象就是可序列化的：
创建一个 ObjectOutputStream
调用 ObjectOutputStream 对象的 writeObject(对象) 方法输出可序列化对象。注意写出一次，操作flush()
反序列化
创建一个 ObjectInputStream
调用 readObject() 方法读取流中的对象
强调：如果某个类的字段不是基本数据类型或 String 类型，而是另一个引用类型，那么这个引用类型必须是可序列化的，否则拥有该类型的 Field 的类也不能序列化
/**
* 可以序列化与反序列化的对象
*/
public class Person implements Serializable{
/**
* 一个表示序列化版本标识符的静态变量
* 用来表明类的不同版本间的兼容性
*/
private static final long serialVersionUID = 1L;
public String name;
public int age;
}import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
/**
* 序列化与反序列化
* 注意：对象的序列化与反序列化使用的类要严格一致，包名，类名，类机构等等所有都要一致
*/
public class Test5 {
public static void main(String[] args) {
try {
// Test5.testSerialize();
Test5.testDeserialize();
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 对象的序列化
*/
public static void testSerialize() throws Exception{
//定义对象的输出流，把对象的序列化之后的流放到指定的文件中
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("D:/testdemo/demo/src/day13/tt9.txt"));
Person p = new Person();
p.name = "zhangsan";
p.age = 11;
out.writeObject(p);
out.flush();//刷写数据到硬盘
out.close();
}
/**
* 对象的反序列化
*/
public static void testDeserialize() throws Exception{
//创建对象输入流对象，从指定的文件中把对象序列化后的流读取出来
ObjectInputStream in = new ObjectInputStream(new FileInputStream("D:/testdemo/demo/src/day13/tt9.txt"));
Object obj = in.readObject();
Person p = (Person)obj;
//这个时候序列化与反序列化使用的类不是一个类分别是day13.Person和day13.test.Person
//这个时候反序列化就有异常day13.Person cannot be cast to day13.test.Person
// day13.test.Person p = (day13.test.Person)obj;
System.out.println(p.name);
System.out.println(p.age);
in.close();
}
}随机访问RandomAccessFile
RandomAccessFile 类支持 “随机访问” 的方式，程序可以直接跳到文件的任意 地方来读、写文件
支持只访问文件的部分内容
可以向已存在的文件后追加内容
RandomAccessFile 对象包含一个记录指针，用以标示当前读写处的位置。
RandomAccessFile 类对象可以自由移动记录指针：
long getFilePointer()：获取文件记录指针的当前位置
void seek(long pos)：将文件记录指针定位到 pos 位置
构造器
public RandomAccessFile(File file, String mode)
public RandomAccessFile(String name, String mode)
创建 RandomAccessFile 类实例需要指定一个 mode 参数，该参数指定 RandomAccessFile 的访问模式：
r: 以只读方式打开
rw：打开以便读取和写入
rwd:打开以便读取和写入；同步文件内容的更新
rws:打开以便读取和写入；同步文件内容和元数据的更新
import java.io.RandomAccessFile;
/**
* 文件的随机读写
* 程序可以直接跳到文件的任意 地方来读、写文件
*
*/
public class Test6 {
public static void main(String[] args) {
try {
// Test6.testRandomAccessFileRead();
Test6.testRandomAccessFileWrite();
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 随机读文件
*/
public static void testRandomAccessFileRead() throws Exception{
//RandomAccessFile的构造有两个参数，参数1是读写的文件的路径
//参数2是指定 RandomAccessFile 的访问模式
//r: 以只读方式打开
//rw：打开以便读取和写入
//rwd:打开以便读取和写入；同步文件内容的更新
//rws:打开以便读取和写入；同步文件内容和元数据的更新
//最常用是r和rw
RandomAccessFile ra = new RandomAccessFile("D:/testdemo/demo/src/day13/tt10.txt", "r");
// ra.seek(0);//设置读取文件内容的起始点
ra.seek(8);//通过设置读取文件内容的起始点，来达到从文件的任意位置读取
byte[] b = new byte[1024];
int len = 0;
while((len = ra.read(b)) != -1){
System.out.println(new String(b, 0, len));
}
ra.close();
}
/**
* 随机写
*/
public static void testRandomAccessFileWrite() throws Exception{
RandomAccessFile ra = new RandomAccessFile("D:/testdemo/demo/src/day13/tt10.txt", "rw");
// ra.seek(0);//设置写的起始点，0代表从开头写
//注意：如果是在文件开头或者中间的某个位置开始写的话，就会用写的内容覆盖掉等长度的原内容
ra.seek(ra.length());//设置写的起始点,ra.length()代表从文件的最后结尾写，也就是文件的追加
ra.write("你好".getBytes());
ra.close();
}
流是用来处理数据的。
•
处理数据时，一定要先明确数据源，与数据目的地
数据源可以是文件，可以是键盘。
数据目的地可以是文件、显示器或者其他设备。
•
而流只是在帮助数据进行传输
,
并对传输的数据进行处理，比如过滤处理、转换处理等
259
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
