你真的会用Java io流吗？

public class TestArgs {

public static void main(String[] args) {

for (int i = 0; i < args.length; i++) {

System.out.println("args[" + i + "] is <" + args[i] + ">");

}

}

}

运行命令：java Java C VB

运行结果：

args[0] is <Java>

args[1] is <C>

args[2] is <VB>

java.lang.System
public final class System extends Object{
 static PrintStream err;//标准错误流（输出）
 static InputStream in;//标准输入(键盘输入流)
 static PrintStream out;//标准输出流(显示器输出流)
}

import java.io.*;
public class StandardInputOutput {
 public static void main(String args[]) {
 int b;
 try {
 System.out.println("please Input:");
 while ((b = System.in.read()) != -1) {
 System.out.print((char) b);
 }
 } catch (IOException e) {
 System.out.println(e.toString());
 }
 }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
 
public class StandardInputOutput {
 public static void main(String args[]) {
 String s;
 // 创建缓冲区阅读器从键盘逐行读入数据
 InputStreamReader ir = new InputStreamReader(System.in);
 BufferedReader in = new BufferedReader(ir);
 System.out.println("Unix系统: ctrl-d 或 ctrl-c 退出" 
 + "\nWindows系统: ctrl-z 退出");
 try {
 // 读一行数据，并标准输出至显示器
 s = in.readLine();
 // readLine()方法运行时若发生I/O错误，将抛出IOException异常
 while (s != null) {
 System.out.println("Read: " + s);
 s = in.readLine();
 }
 // 关闭缓冲阅读器
 in.close();
 } catch (IOException e) { // Catch any IO exceptions.
 e.printStackTrace();
 }
 }
}

System.out.println(File.separator);//输出 \
System.out.println(File.pathSeparator);//输出 ;

//不使用 Java 提供的分隔符字段，注意：这样写只能在 Windows 平台有效
 File f1 = new File("D:\\IO\\a.txt");或者是D:/IO/a.txt
 //使用 Java 提供的分隔符
 File f2 = new File("D:"+File.separator+"IO"+File.separator+"a.txt");
 System.out.println(f1);//输出 D:\IO\a.txt
 System.out.println(f2);//输出 D:\IO\a.txt
 
 //File(File parent, String child)
 //从父抽象路径名和子路径名字符串创建新的 File实例。
 File f3 = new File("D:");
 File f4 = new File(f3,"IO");
 System.out.println(f4); //D:\IO
 
 //File(String pathname)
 //通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例。
 File f5 = new File("D:"+File.separator+"IO"+File.separator+"a.txt");
 System.out.println(f5); //D:\IO\a.txt
 
 //File(String parent, String child)
 //从父路径名字符串和子路径名字符串创建新的 File实例。
 File f6 = new File("D:","IO\\a.txt");
 System.out.println(f6); //D:\IO\a.txt

//File(File parent, String child)
 //从父抽象路径名和子路径名字符串创建新的 File实例。
 File dir = new File("D:"+File.separator+"IO");
 File file = new File(dir,"a.txt");
 
 //判断dir 是否存在且表示一个目录
 if(!(dir.exists()||dir.isDirectory())){
 //如果 dir 不存在，则创建这个目录
 dir.mkdirs();
 //根据目录和文件名，创建 a.txt文件
 file.createNewFile();
 
 }
 //返回由此抽象路径名表示的文件或目录的名称。这只是路径名称序列中的最后一个名字。如果路径名的名称序列为空，则返回空字符串。
 System.out.println(file.getName()); //a.txt
 //返回此抽象路径名的父null的路径名字符串，如果此路径名未命名为父目录，则返回null。
 System.out.println(file.getParent());//D:\IO
 //将此抽象路径名转换为路径名字符串。结果字符串使用default name-separator character以名称顺序分隔名称。
 System.out.println(file.getPath()); //D:\IO\a.txt

public static void getFileList(File file){
 //第一级子目录
 File[] files = file.listFiles();
 for(File f:files){
 //打印目录和文件
 System.out.println(f);
 if(f.isDirectory()){
 getFileList(f);
 }
 }
 }
public static void main(String[] args) throws Exception {
 File f = new File("D:"+File.separator+"WebStormFile");
 getFileList(f);
}

public abstract class InputStream
 extends Object
 implements Closeable

//1、创建目标对象，输入流表示那个文件的数据保存到程序中。不写盘符，默认该文件是在该项目的根目录下
 //a.txt 保存的文件内容为：AAaBCDEF
 File target = new File("io"+File.separator+"a.txt");
 //2、创建输入流对象
 InputStream in = new FileInputStream(target);
 //3、具体的 IO 操作（读取 a.txt 文件中的数据到程序中）
 /**
 * 注意：读取文件中的数据，读到最后没有数据时，返回-1
 * int read():读取一个字节，返回读取的字节
 * int read(byte[] b):读取多个字节,并保存到数组 b 中，从数组 b 的索引为 0 的位置开始存储，返回读取了几个字节
 * int read(byte[] b,int off,int len):读取多个字节，并存储到数组 b 中，从数组b 的索引为 0 的位置开始，长度为len个字节
 */
 //int read():读取一个字节，返回读取的字节
 int data1 = in.read();//获取 a.txt 文件中的数据的第一个字节
 System.out.println((char)data1); //A
 //int read(byte[] b):读取多个字节保存到数组b 中
 byte[] buffer = new byte[10];
 in.read(buffer);//获取 a.txt 文件中的前10 个字节，并存储到 buffer 数组中
 System.out.println(Arrays.toString(buffer)); //[65, 97, 66, 67, 68, 69, 70, 0, 0, 0]
 System.out.println(new String(buffer)); //AaBCDEF[][][]
 
 //int read(byte[] b,int off,int len):读取多个字节，并存储到数组 b 中,从索引 off 开始到 len
 in.read(buffer, 0, 3);
 System.out.println(Arrays.toString(buffer)); //[65, 97, 66, 0, 0, 0, 0, 0, 0, 0]
 System.out.println(new String(buffer)); //AaB[][][][][][][]
 //4、关闭流资源
 in.close();

public abstract class OutputStream
 extends Object
 implements Closeable, Flushable

//1、创建目标对象，输出流表示把数据保存到哪个文件。不写盘符，默认该文件是在该项目的根目录下
 File target = new File("io"+File.separator+"a.txt");
 //2、创建文件的字节输出流对象,第二个参数是 Boolean 类型，true 表示后面写入的文件追加到数据后面，false 表示覆盖
 OutputStream out = new FileOutputStream(target,true);
 //3、具体的 IO 操作(将数据写入到文件 a.txt 中)
 /**
 * void write(int b):把一个字节写入到文件中
 * void write(byte[] b):把数组b 中的所有字节写入到文件中
 * void write(byte[] b,int off,int len):把数组b 中的从 off 索引开始的 len 个字节写入到文件中
 */
 out.write(65); //将 A 写入到文件中
 out.write("Aa".getBytes()); //将 Aa 写入到文件中
 out.write("ABCDEFG".getBytes(), 1, 5); //将 BCDEF 写入到文件中
 //经过上面的操作，a.txt 文件中数据为 AAaBCDEF
 
 //4、关闭流资源
 out.close();
 System.out.println(target.getAbsolutePath());

/**
 * 将 a.txt 文件 复制到 b.txt 中
 */
 //1、创建源和目标
 File srcFile = new File("io"+File.separator+"a.txt");
 File descFile = new File("io"+File.separator+"b.txt");
 //2、创建输入输出流对象
 InputStream in = new FileInputStream(srcFile);
 OutputStream out = new FileOutputStream(descFile);
 //3、读取和写入操作
 byte[] buffer = new byte[10];//创建一个容量为 10 的字节数组，存储已经读取的数据
 int len = -1;//表示已经读取了多少个字节，如果是 -1，表示已经读取到文件的末尾
 while((len=in.read(buffer))!=-1){
 //打印读取的数据
 System.out.println(new String(buffer,0,len));
 //将 buffer 数组中从 0 开始，长度为 len 的数据读取到 b.txt 文件中
 out.write(buffer, 0, len);
 }
 //4、关闭流资源
 out.close();
 in.close();

public abstract class Writer
　　extends Object
　　implements Appendable, Closeable, Flushable

//1、创建源
 File srcFile = new File("io"+File.separator+"a.txt");
 //2、创建字符输出流对象
 Writer out = new FileWriter(srcFile);
 //3、具体的 IO 操作
 /***
 * void write(int c):向外写出一个字符
 * void write(char[] buffer):向外写出多个字符 buffer
 * void write(char[] buffer,int off,int len):把 buffer 数组中从索引 off 开始到 len个长度的数据写出去
 * void write(String str):向外写出一个字符串
 */
 //void write(int c):向外写出一个字符
 out.write(65);//将 A 写入 a.txt 文件中
 //void write(char[] buffer):向外写出多个字符 buffer
 out.write("Aa帅锅".toCharArray());//将 Aa帅锅 写入 a.txt 文件中
 //void write(char[] buffer,int off,int len)
 out.write("Aa帅锅".toCharArray(),0,2);//将 Aa 写入a.txt文件中
 //void write(String str):向外写出一个字符串
 out.write("Aa帅锅");//将 Aa帅锅 写入 a.txt 文件中
 
 //4、关闭流资源
 /***
 * 注意如果这里有一个 缓冲的概念，如果写入文件的数据没有达到缓冲的数组长度，那么数据是不会写入到文件中的
 * 解决办法：手动刷新缓冲区 flush()
 * 或者直接调用 close() 方法，这个方法会默认刷新缓冲区
 */
 out.flush();
 out.close();

public abstract class Reader
　　extends Object
　　implements Readable, Closeable

//1、创建源
 File srcFile = new File("io"+File.separator+"a.txt");
 //2、创建字符输出流对象
 Reader in = new FileReader(srcFile);
 //3、具体的 IO 操作
 /***
 * int read():每次读取一个字符，读到最后返回 -1
 * int read(char[] buffer):将字符读进字符数组,返回结果为读取的字符数
 * int read(char[] buffer,int off,int len):将读取的字符存储进字符数组 buffer，返回结果为读取的字符数，从索引 off 开始，长度为 len
 *
 */
 //int read():每次读取一个字符，读到最后返回 -1
 int len = -1;//定义当前读取字符的数量
 while((len = in.read())!=-1){
 //打印 a.txt 文件中所有内容
 System.out.print((char)len);
 }
 
 //int read(char[] buffer):将字符读进字符数组
 char[] buffer = new char[10]; //每次读取 10 个字符
 while((len=in.read(buffer))!=-1){
 System.out.println(new String(buffer,0,len));
 }
 
 //int read(char[] buffer,int off,int len)
 while((len=in.read(buffer,0,10))!=-1){
 System.out.println(new String(buffer,0,len));
 }
 //4、关闭流资源
 in.close();

/**
 * 将 a.txt 文件 复制到 b.txt 中
 */
 //1、创建源和目标
 File srcFile = new File("io"+File.separator+"a.txt");
 File descFile = new File("io"+File.separator+"b.txt");
 //2、创建字符输入输出流对象
 Reader in = new FileReader(srcFile);
 Writer out = new FileWriter(descFile);
 //3、读取和写入操作
 char[] buffer = new char[10];//创建一个容量为 10 的字符数组，存储已经读取的数据
 int len = -1;//表示已经读取了多少个字节，如果是 -1，表示已经读取到文件的末尾
 while((len=in.read(buffer))!=-1){
 out.write(buffer, 0, len);
 }
 
 //4、关闭流资源
 out.close();
 in.close();

//1、创建目标对象，输入流表示那个文件的数据保存到程序中。不写盘符，默认该文件是在该项目的根目录下
 //a.txt 保存的文件内容为：AAaBCDEF
 File target = new File("io"+File.separator+"a.txt");
 //2、创建输入流对象
 InputStream in = new FileInputStream(target);
 //3、具体的 IO 操作（读取 a.txt 文件中的数据到程序中）
 /**
 * 注意：读取文件中的数据，读到最后没有数据时，返回-1
 * int read():读取一个字节，返回读取的字节
 * int read(byte[] b):读取多个字节,并保存到数组 b 中，从数组 b 的索引为 0 的位置开始存储，返回读取了几个字节
 * int read(byte[] b,int off,int len):读取多个字节，并存储到数组 b 中，从数组b 的索引为 0 的位置开始，长度为len个字节
 */
 //int read():读取一个字节，返回读取的字节
 int data1 = in.read();//获取 a.txt 文件中的数据的第一个字节
 System.out.println((char)data1); //A
 //int read(byte[] b):读取多个字节保存到数组b 中
 byte[] buffer = new byte[10];//这里我们定义了一个 长度为 10 的字节数组，用来存储读取的数据
 in.read(buffer);//获取 a.txt 文件中的前10 个字节，并存储到 buffer 数组中
 System.out.println(Arrays.toString(buffer)); //[65, 97, 66, 67, 68, 69, 70, 0, 0, 0]
 System.out.println(new String(buffer)); //AaBCDEF[][][]
 
 //int read(byte[] b,int off,int len):读取多个字节，并存储到数组 b 中,从索引 off 开始到 len
 in.read(buffer, 0, 3);
 System.out.println(Arrays.toString(buffer)); //[65, 97, 66, 0, 0, 0, 0, 0, 0, 0]
 System.out.println(new String(buffer)); //AaB[][][][][][][]
 //4、关闭流资源
 in.close();

//字节缓冲输入流
 BufferedInputStream bis = new BufferedInputStream(
 new FileInputStream("io"+File.separator+"a.txt"));
 //定义一个字节数组，用来存储数据
 byte[] buffer = new byte[1024];
 int len = -1;//定义一个整数，表示读取的字节数
 while((len=bis.read(buffer))!=-1){
 System.out.println(new String(buffer,0,len));
 }
 //关闭流资源
 bis.close();<br><br>
 
 //字节缓冲输出流
 BufferedOutputStream bos = new BufferedOutputStream(
 new FileOutputStream("io"+File.separator+"a.txt"));
 bos.write("ABCD".getBytes());
 bos.close();

//字符缓冲输入流
 BufferedReader br = new BufferedReader(
 new FileReader("io"+File.separator+"a.txt"));
 char[] buffer = new char[10];
 int len = -1;
 while((len=br.read(buffer))!=-1){
 System.out.println(new String(buffer,0,len));
 }
 br.close();
 
 //字符缓冲输出流
 BufferedWriter bw = new BufferedWriter(
 new FileWriter("io"+File.separator+"a.txt"));
 bw.write("ABCD");
 bw.close();

/**
 * 将 a.txt 文件 复制到 b.txt 中
 */
 //1、创建源和目标
 File srcFile = new File("io"+File.separator+"a.txt");
 File descFile = new File("io"+File.separator+"b.txt");
 //2、创建字节输入输出流对象
 InputStream in = new FileInputStream(srcFile);
 OutputStream out = new FileOutputStream(descFile);
 //3、创建转换输入输出对象
 Reader rd = new InputStreamReader(in);
 Writer wt = new OutputStreamWriter(out);
 //3、读取和写入操作
 char[] buffer = new char[10];//创建一个容量为 10 的字符数组，存储已经读取的数据
 int len = -1;//表示已经读取了多少个字符，如果是 -1，表示已经读取到文件的末尾
 while((len=rd.read(buffer))!=-1){
 wt.write(buffer, 0, len);
 }
 //4、关闭流资源
 rd.close();
 wt.close();

//字节数组输出流：程序---》内存
 ByteArrayOutputStream bos = new ByteArrayOutputStream();
 //将数据写入到内存中
 bos.write("ABCD".getBytes());
 //创建一个新分配的字节数组。其大小是此输出流的当前大小，缓冲区的有效内容已被复制到其中。
 byte[] temp = bos.toByteArray();
 System.out.println(new String(temp,0,temp.length));
 
 byte[] buffer = new byte[10];
 ///字节数组输入流：内存---》程序
 ByteArrayInputStream bis = new ByteArrayInputStream(temp);
 int len = -1;
 while((len=bis.read(buffer))!=-1){
 System.out.println(new String(buffer,0,len));
 }
 
 //这里不写也没事，因为源码中的 close()是一个空的方法体
 bos.close();
 bis.close();

//字符数组输出流
 CharArrayWriter caw = new CharArrayWriter();
 caw.write("ABCD");
 //返回内存数据的副本
 char[] temp = caw.toCharArray();
 System.out.println(new String(temp));
 
 //字符数组输入流
 CharArrayReader car = new CharArrayReader(temp);
 char[] buffer = new char[10];
 int len = -1;
 while((len=car.read(buffer))!=-1){
 System.out.println(new String(buffer,0,len));
 }

//字符串输出流,底层采用 StringBuffer 进行拼接
 StringWriter sw = new StringWriter();
 sw.write("ABCD");
 sw.write("帅锅");
 System.out.println(sw.toString());//ABCD帅锅
 
 //字符串输入流
 StringReader sr = new StringReader(sw.toString());
 char[] buffer = new char[10];
 int len = -1;
 while((len=sr.read(buffer))!=-1){
 System.out.println(new String(buffer,0,len));//ABCD帅锅
 }

//定义字节输入合并流
 SequenceInputStream seinput = new SequenceInputStream(
 new FileInputStream("io/a.txt"), new FileInputStream("io/b.txt"));
 byte[] buffer = new byte[10];
 int len = -1;
 while((len=seinput.read(buffer))!=-1){
 System.out.println(new String(buffer,0,len));
 }
 
 seinput.close();