Java之IO流

//读取一个字节并以整数的形式返回（0~255）
//如果返回-1就说明已经到了输入流的末尾
int read() throws IOException
//读取一系列字节并存储到一个数组buffer
//返回实际读取的字节数，如果读取前已到输入流的末尾，则返回-1
int read(byte[] buffer) throws IOException
//读取length个字节
//并存储到一个字节数组buffer，从length位置开始
//返回实际读取的字节数，如果读取前以到输入流的末尾返回-1.
int read(byte[] buffer,int offset,int length) throws IOException
//关闭流释放内存资源
void close() throws IOException
//跳过n个字节不读，返回实际跳过的字节数
long skip(long n) throws IOException

 1   package com.kuang.chapter;
 2         import java.io.*;
 3 public class TestFileInputStream {
 4     public static void main(String args[]) {
 5         int b = 0;// 使用变量b来装调用read()方法时返回的整数
 6         FileInputStream in = null;
 7 // 使用FileInputStream流来读取有中文的内容时，读出来的是乱码，因为使用
 8         InputStream流里面的read()方法读取内容时是一个字节一个字节地读取的，而一个汉字是占用两个
 9         字节的，所以读取出来的汉字无法正确显示。
10 // FileReader in = null;
11 // 使用FileReader流来读取内容时，中英文都可以正确显示，因为Reader流里面的
12         read()方法是一个字符一个字符地读取的，这样每次读取出来的都是一个完整的汉字，这样就可以正确
13         显示了。
14         try {
15             in = new FileInputStream("E:\\教学\\班级
16                     \\Test\\Lesson2\\src\\com\\kuang\\chapter\\Student.java");
17 // in = new FileReader("E:\\教学\\班级
18                     \\Test\\Lesson2\\src\\com\\kuang\\chapter\\Student.java");
19         } catch (FileNotFoundException e) {
20             System.out.println("系统找不到指定文件！");
21             System.exit(-1);// 系统非正常退出
22         }
23         long num = 0;// 使用变量num来记录读取到的字符数
24 // 调用read()方法时会抛异常，所以需要捕获异常
25         try {
26             while ((b = in.read()) != -1) {
27 // 调用int read() throws Exception方法时，返回的是一个int类型的整
28                 数
29 // 循环结束的条件就是返回一个值-1，表示此时已经读取到文件的末尾了。
30 // System.out.print(b+"\t");//如果没有使用“(char)b”进行转换，那
31                 么直接打印出来的b就是数字，而不是英文和中文了
32                 System.out.print((char) b);
33 // “char(b)”把使用数字表示的汉字和英文字母转换成字符输入
34                 num++;
35             }
36             in.close();// 关闭输入流
37             System.out.println();
38             System.out.println("总共读取了" + num + "个字节的文件");
39         } catch (IOException e1) {
40             System.out.println("文件读取错误！");
41         }
42     }
43 }

 1 //向输出流中写入一个字节数据，该字节数据为参数b的低8位
 2 void write(int b) throws IOException
 3 //将一个字节类型的数组中的数据写入输出流
 4 void write(byte[] b) throws IOException
 5 //将一个字节类型的数组中的从指定位置（off）开始的len个字节写入到输出流
 6 void write(byte[] b,int off,int len) throws IOException
 7 //关闭流释放内存资源
 8 void close() throws IOException
 9 //将输出流中缓冲的数据全部写出到目的地
10 void flush() throws IOException

 1 package com.kuang.chapter;
 2         import java.io.*;
 3 public class TestFileOutputStream {
 4     public static void main(String args[]) {
 5         int b = 0;
 6         FileInputStream in = null;
 7         FileOutputStream out = null;
 8         try {
 9             in = new FileInputStream("E:\\教学\\班级
10                     \\Test\\Lesson2\\src\\com\\kuang\\chapter\\Student.java");
11                     out = new FileOutputStream("E:\\教学\\班级
12                             \\Test\\Lesson2\\src\\com\\kuang\\chapter\\StudentNew.java");
13 // 指明要写入数据的文件，如果指定的路径中不存在StudentNew.java这样的文
14                             件，则系统会自动创建一个
15             while ((b = in.read()) != -1) {
16                 out.write(b);
17 // 调用write(int c)方法把读取到的字符全部写入到指定文件中去
18             }
19             in.close();
20             out.close();
21         } catch (FileNotFoundException e) {
22             System.out.println("文件读取失败");
23             System.exit(-1);// 非正常退出
24         } catch (IOException e1) {
25             System.out.println("文件复制失败！");
26             System.exit(-1);
27         }
28         System.out
29                 .println("Student.StudentNew.java里面");
30     }
31 }

 1 //读取一个字节并以整数的形式返回（0~255）
 2 //如果返回-1就说明已经到了输入流的末尾
 3 int read() throws IOException
 4 //读取一系列字节并存储到一个数组buffer
 5 //返回实际读取的字节数，如果读取前已到输入流的末尾，则返回-1
 6 int read(byte[] buffer) throws IOException
 7 //读取length个字节
 8 //并存储到一个字节数组buffer，从length位置开始
 9 //返回实际读取的字节数，如果读取前以到输入流的末尾返回-1.
10 int read(byte[] buffer,int offset,int length) throws IOException
11 //关闭流释放内存资源
12 void close() throws IOException
13 //跳过n个字节不读，返回实际跳过的字节数
14 long skip(long n) throws IOException

 1 //向输出流中写入一个字节数据，该字节数据为参数b的低16位
 2 void write(int b) throws IOException
 3 //将一个字节类型的数组中的数据写入输出流
 4 void write(byte[] b) throws IOException
 5 //将一个字节类型的数组中的从指定位置（off）开始的len个字节写入到输出流
 6 void write(byte[] b,int off,int len) throws IOException
 7 //关闭流释放内存资源
 8 void close() throws IOException
 9 //将输出流中缓冲的数据全部写出到目的地
10 void flush() throws IOException

 1 package com.kuang.chapter;
 2         /*使用FileWriter（字符流）向指定文件中写入数据写入数据时以1个字符为单位进行写入*/
 3         import java.io.*;
 4 public class TestFileWriter{
 5     public static void main(String args[]){
 6 /*使用FileWriter输出流从程序把数据写入到Uicode.dat文件中
 7 使用FileWriter流向文件写入数据时是一个字符一个字符写入的*/
 8         FileWriter fw = null;
 9         try{
10             fw = new FileWriter("E:\\教学\\班级
11                     \\Test\\Lesson2\\src\\com\\kuang\\chapter\\StudentNew.java");
12 //字符的本质是一个无符号的16位整数
13 //字符在计算机内部占用2个字节
14 //这里使用for循环把0～60000里面的所有整数都输出
15 //这里相当于是把全世界各个国家的文字都0～60000内的整数的形式来表示
16             for(int c=0;c<=60000;c++){
17                 fw.write(c);
18 //使用write(int c)把0～60000内的整数写入到指定文件内
19 //调用write()方法时，我认为在执行的过程中应该使用了“(char)c”进行强制
20                 转换，即把整数转换成字符来显示
21 //因为打开写入数据的文件可以看到，里面显示的数据并不是0～60000内的整
22                 数，而是不同国家的文字的表示方式
23             }
24 /*使用FileReader(字符流)读取指定文件里面的内容
25 读取内容时是以一个字符为单位进行读取的*/
26             int b = 0;
27             long num = 0;
28             FileReader fr = null;
29             fr = new FileReader("E:\\教学\\班级
30                     \\Test\\Lesson2\\src\\com\\kuang\\chapter\\StudentNew.java");
31             while((b = fr.read())!= -1){
32                 System.out.print((char)b + "\t");
33                 num++;
34             }
35             System.out.println();
36             System.out.println("总共读取了"+num+"个字符");
37         }catch(Exception e){
38             e.printStackTrace();
39         }
40     }
41 }

BufferedReader(Reader in)
BufferedReader(Reader in,int sz) //sz 为自定义缓冲区的大小
BufferedWriter(Writer out)
BufferedWriter(Writer out,int sz)
BufferedInputStream(InputStream in)
BufferedInputStream(InputStream in,int size)
BufferedOutputStream(InputStream in)
BufferedOutputStream(InputStream in,int size)

 1  package com.kuang.chapter;
 2             import java.io.*;
 3 public class TestBufferStream {
 4     public static void main(String args[]) {
 5         FileInputStream fis = null;
 6         try {
 7             fis = new FileInputStream("E:\\教学\\班级
 8                     \\Test\\Lesson2\\src\\com\\kuang\\chapter\\Student.java");
 9 // 在FileInputStream节点流的外面套接一层处理流BufferedInputStream
10                     BufferedInputStream bis = new BufferedInputStream(fis);
11             int c = 0;
12             System.out.println((char) bis.read());
13             System.out.println((char) bis.read());
14             bis.mark(100);// 在第100个字符处做一个标记
15             for (int i = 0; i <= 10 && (c = bis.read()) != -1; i++) {
16                 System.out.print((char) c);
17             }
18             System.out.println();
19             bis.reset();// 重新回到原来标记的地方
20             for (int i = 0; i <= 10 && (c = bis.read()) != -1; i++) {
21                 System.out.print((char) c);
22             }
23             bis.close();
24         } catch (FileNotFoundException e) {
25             e.printStackTrace();
26         } catch (Exception e1) {
27             e1.printStackTrace();
28         }
29     }
30 }

 1   package com.kuang.chapter;
 2         import java.io.*;
 3 public class TestBufferStream{
 4     public static void main(String args[]){
 5         try{
 6             BufferedWriter bw = new BufferedWriter(new FileWriter("E:\\教学
 7                     \\班级\\Test\\Lesson2\\src\\com\\kuang\\chapter\\Student.txt"));
 8 //在节点流FileWriter的外面再套一层处理流BufferedWriter
 9                     String s = null;
10             for(int i=0;i<100;i++){
11                 s = String.valueOf(Math.random());//“Math.random()”将会生成一
12                 系列介于0～1之间的随机数。
13 // static String valueOf(double d)这个valueOf()方法的作用就是把
14                 一个double类型的数转换成字符串
15 //valueOf()是一个静态方法，所以可以使用“类型.静态方法名”的形式来调用
16                 bw.write(s);//把随机数字符串写入到指定文件中
17                 bw.newLine();//调用newLine()方法使得每写入一个随机数就换行显示
18             }
19             bw.flush();//调用flush()方法清空缓冲区
20             BufferedReader br = new BufferedReader(new FileReader("E:\\教学
21                     \\班级\\Test\\Lesson2\\src\\com\\kuang\\chapter\\Student.txt"));
22 //在节点流FileReader的外面再套一层处理流BufferedReader
23             while((s = br.readLine())!=null){
24 //使用BufferedReader处理流里面提供String readLine()方法读取文件中
25                 的数据时是一行一行读取的
26 //循环结束的条件就是使用readLine()方法读取数据返回的字符串为空值后则表
27                 示已经读取到文件的末尾了。
28                 System.out.println(s);
29             }
30             bw.close();
31             br.close();
32         }catch(Exception e){
33             e.printStackTrace();
34         }
35     }
36 }

InputStream isr = new InputStreamReader（System.in，"ISO8859-1"）

 1 import java.io.*;
 2 public class TestTransform1 {
 3     public static void main(String args[]) {
 4         try {
 5             OutputStreamWriter osw = new OutputStreamWriter(
 6 
 7             osw.write("MircosoftsunIBMOracleApplet");// 把字符串写入到指定的文件
 8             中去
 9             System.out.println(osw.getEncoding());// 使用getEncoding()方法取得
10             当前系统的默认字符编码
11             osw.close();
12             osw = new OutputStreamWriter(new FileOutputStream(
13                     "D:\\java\\char.txt", true), "ISO8859_1");
14 // 如果在调用FileOutputStream的构造方法时没有加入true，那么新加入的字符
15             串就会替换掉原来写入的字符串，在调用构造方法时指定了字符的编码
16             osw.write("MircosoftsunIBMOracleApplet");// 再次向指定的文件写入字符
17             串，新写入的字符串加入到原来字符串的后面
18             System.out.println(osw.getEncoding());
19             osw.close();
20         } catch (Exception e) {
21             e.printStackTrace();
22         }
23     }
24 }

 1 import java.io.*;
 2 public class TestTransform2{
 3     public static void main(String args[]){
 4         try{
 5             InputStreamReader isr = new InputStreamReader(System.in);
 6 //System.in这里的in是一个标准的输入流，用来接收从键盘输入的数据
 7             BufferedReader br = new BufferedReader(isr);
 8             String s = null;
 9             s = br.readLine();//使用readLine()方法把读取到的一行字符串保存到字符串
10             变量s中去
11             while(s != null){
12                 System.out.println(s.toUpperCase());//把保存在内存s中的字符串打
13                 印出来
14                         s = br.readLine();//在循环体内继续接收从键盘的输入
15                 if(s.equalsIgnoreCase("exit")){
16 //只要输入exit循环就结束，就会退出
17                     break;
18                 }
19             }
20         }catch(Exception e){
21             e.printStackTrace();
22         }
23     }
24 }

1 DataInputStream （InputStream in）
2 DataOutputStream （OutputStream out）

 1 package com.kuang.chapter;
 2         import java.io.*;
 3 public class TestDataStream{
 4     public static void main(String args[]){
 5         ByteArrayOutputStream baos = new ByteArrayOutputStream();
 6 //在调用构造方法时，首先会在内存里面创建一个ByteArray字节数组
 7         DataOutputStream dos = new DataOutputStream(baos);
 8 //在输出流的外面套上一层数据流，用来处理int，double类型的数
 9         try{
10             dos.writeDouble(Math.random());//把产生的随机数直接写入到字节数组
11             ByteArray中
12             dos.writeBoolean(true);//布尔类型的数据在内存中就只占一个字节
13             ByteArrayInputStream bais = new
14                     ByteArrayInputStream(baos.toByteArray());
15             System.out.println(bais.available());
16             DataInputStream dis = new DataInputStream(bais);
17             System.out.println(dis.readDouble());//先写进去的就先读出来，调用
18             readDouble()方法读取出写入的随机数
19             System.out.println(dis.readBoolean());//后写进去的就后读出来，这里面
20             的读取顺序不能更改位置，否则会打印出不正确的结果
21             dos.close();
22             bais.close();
23         }catch(Exception e){
24             e.printStackTrace();
25         }
26     }
27 }

PrintWriter（Writer out）
PrintWriter（Writer out，boolean autoFlush）
PrintWriter（OutputStream out）
PrintWriter（OutputStream out，boolean autoFlush）
PrintStream（OutputStream out）
PrintStream（OutputStream out，boolean autoFlush）

 1 /*这个小程序是重新设置打印输出的窗口，
 2  * 把默认在命令行窗口输出打印内容设置成其他指定的打印显示窗口
 3  */
 4 import java.io.*;
 5 public class TestPrintStream{
 6     public static void main(String args[]){
 7         PrintStream ps = null;
 8         try{
 9             FileOutputStream fos = new FileOutputStream("E:\\教学\\班级
10                     \\Test\\Lesson2\\src\\com\\kuang\\chapter\\log.txt");
11                     ps = new PrintStream(fos);//在输出流的外面套接一层打印流，用来控制打印
12             输出
13             if(ps != null){
14                 System.setOut(ps);//这里调用setOut()方法改变了输出窗口，以前写
15                 System.out.print()默认的输出窗口就是命令行窗口.
16 //但现在使用System.setOut(ps)将打印输出窗口改成了由ps指定的文件里
17                 面，通过这样设置以后，打印输出时都会在指定的文件内打印输出
18 //在这里将打印输出窗口设置到了log.txt这个文件里面，所以打印出来的内容会
19                 在log.txt这个文件里面看到
20             }
21             for(char c=0;c<=1000;c++){
22                 System.out.print(c+"\t");//把世界各国的文字打印到log.txt这个文件
23                 中去
24             }
25         }catch(Exception e){
26             e.printStackTrace();
27         }
28     }
29 }

 1 package com.kuang.chapter;
 2         import java.io.*;
 3 public class TestObjectIo {
 4     public static void main(String args[]) {
 5         T t = new T();
 6         t.k = 8;// 把k的值修改为8
 7         try {
 8             FileOutputStream fos = new FileOutputStream(
 9                     "E:\\教学\\班级
10                     \\Test\\Lesson2\\src\\com\\kuang\\chapter\\TestObjectIo.txt");
11                     ObjectOutputStream oos = new ObjectOutputStream(fos);
12 // ObjectOutputStream流专门用来处理Object的，在fos流的外面套接
13             ObjectOutputStream流就可以直接把一个Object写进去
14             oos.writeObject(t);// 直接把一个t对象写入到指定的文件里面
15             oos.flush();
16             oos.close();
17             FileInputStream fis = new FileInputStream(
18                     "E:\\教学\\班级
19                     \\Test\\Lesson2\\src\\com\\kuang\\chapter\\TestObjectIo.txt");
20                     ObjectInputStream ois = new ObjectInputStream(fis);
21 // ObjectInputStream专门用来读一个Object的
22             T tRead = (T) ois.readObject();
23 // 直接把文件里面的内容全部读取出来然后分解成一个Object对象，并使用强制转换
24             成指定类型T
25             System.out.print(tRead.i + "\t" + tRead.j + "\t" + tRead.d +
26                     "\t"
27                     + tRead.k);
28             ois.close();
29         } catch (Exception e) {
30             e.printStackTrace();
31         }
32     }
33 }
34 /*
35 * 凡是要将一个类的对象序列化成一个字节流就必须实现Serializable接口
36 * Serializable接口中没有定义方法，Serializable接口是一个标记性接口，用来给类作标记，
37 只是起到一个标记作用。
38 * 这个标记是给编译器看的，编译器看到这个标记之后就可以知道这个类可以被序列化 如果想把某个
39 类的对象序列化，就必须得实现Serializable接口
40 */
41 class T implements Serializable {
42     // Serializable的意思是可以被序列化的
43     int i = 10;
44     int j = 9;
45     double d = 2.3;
46     int k = 15;
47 // transient int k = 15;
48 // 在声明变量时如果加上transient关键字，那么这个变量就会被当作是透明的，即不存在。
49 }