java--IO流（2）--黑马程序员

时间：2015-08-06 23:56:52 阅读：254 评论：0 收藏：0 [点我收藏+]

标签：

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

IO流（2）

主要内容：《FileInputStream类、带缓冲的字节流、String类中的编码和解码、转换流、字符流类、带缓冲的字符流、数据输入输出流、byte数组缓冲流、打印流、随机访问流、序列化流和反序列化流、Properties 》

1.FileInputStream类

字节流：
　　输出流：OutputStream
　　 |--FileOutputStream:
　　输入流：InputStream
　　 |--FileInputStream:
　　
　　构造方法：
　　 FileInputStream(File file)
　　 FileInputStream(String name)
　　
读取的方法：
　　 public int read()：一次读取一个字节。当读到文件末尾，返回-1
　　 public int read(byte[] b)：一次读取一个字节数组；

 1 public class Demo {
 2     public static void main(String[] args) throws IOException {
 3         //文件必须存在，否则抛出异常；
 4     //    FileInputStream in = new FileInputStream("134.txt");
 5         //可以使用File先判断
 6         File file = new File("output.txt");
 7         if(!file.exists()){
 8             file.createNewFile();
 9         }
10         FileInputStream in = new FileInputStream(file);
11         
12         //一次读一个字节
13         /*
14         int n = in.read();
15         while(n != -1){
16             System.out.println("读取的字节：" + n);
17             System.out.println("转换为字符：" + (char)n);
18             n = in.read();
19         }*/
20         //下面一种变形--以后我们会常用；
21         int n = 0;
22         while((n = in.read()) != -1){
23             System.out.println("读取的字节：" + n);
24             System.out.println("转换为字符：" + (char)n);
25         }
26         //释放资源
27         in.close();
28         
29     
30         
31         
32     }
33 }
34

2.字节流复制文本文件案例

 1 public class Demo {
 2     public static void main(String[] args) throws IOException {
 3         //1.获取输入流；
 4         FileInputStream in = new FileInputStream("D:\\aaaa.txt");
 5         //2.获取输出流；
 6         FileOutputStream out = new FileOutputStream("aaaa_copy.txt");//将会新建这个文件
 7         //3.循环读取，一次读取一个字节，同时一次写入一个字节
 8         int n = 0;
 9         while((n = in.read()) != -1){
10             out.write(n);
11         }
12         //4.释放资源
13         in.close();
14         out.close();
15         System.out.println("复制完毕！");
16         
17         
18     }
19 }

3.字节流_一次读取一个字节数组

字节流：
输入流：FileInputStream:
int read():一次读取一个字节
int read(byte[] b):一次读取一个字节数组；

 1 public class Demo {
 2     public static void main(String[] args) throws IOException {
 3         //1.实例化一个输入流
 4         FileInputStream in = new FileInputStream("D:\\bbb.txt");
 5         //2.一次读取一个字节数组；
 6         byte[] byteArray = new byte[5];
 7         //一次读取一个字节数组
 8         System.out.println("*******************************");
 9     //    int n = in.read(byteArray);//一次读取的字节数。
10         
11         //使用循环
12         //方式一：
13         /*
14         while(n != -1){
15             
16             //一个字节一个字节的打印；
17 //            for(byte b : byteArray){
18 //                System.out.print((char)b);
19 //            }
20             //将byte[]数组转换为字符串：使用String的构造方法
21         //    String str = new String(byteArray);
22             String str = new String(byteArray,0,n);
23             System.out.println("内容：" + str);//打印换行；
24             n = in.read(byteArray);
25         }
26         */
27         
28         //方式二：常用
29         int n = 0;
30         while((n = in.read(byteArray)) != -1){
31             String str = new String(byteArray,0,n);
32             System.out.println("读取的内容：" + str);
33         }
34         
35         //释放资源
36         in.close();
37         
38         
39     }
40 }

4.带缓冲的字节流_BufferedOutputStresam

字节流：
输出流：OutputStream:
　　 |--FileOutputStream(学)
　　 |--FilterOutputStream(没学)
　　 |--BufferedOutputStream(学)
输入流：InputStream:
　　 |--FileInputStream(学)
　　 |--FilterInputStream(没学)
　　|--BufferedInputStream(学);
　　　　
BufferedOutputStream：内部使用构造方法提供OutputStream类型的对象去操作底层流输出。BufferedOutputStream类本身只提供了一些"缓冲"的一些功能；
构造方法：
　　 BufferedOutputStream(OutputStream out) 创建一个新的缓冲输出流，以将数据写入指定的底层输出流。
　　BufferedOutputStream(OutputStream out, int size) 创建一个新的缓冲输出流，以将具有指定缓冲区大小的数据写入指定的底层输出流。
成员方法：
　　没有

 1 public class Demo {
 2     public static void main(String[] args) throws IOException {
 3         // 1.构造一个BufferedOutputStream
 4         BufferedOutputStream out = new BufferedOutputStream(
 5                                     new FileOutputStream("bufferdOutput.txt"));
 6         
 7         //分开写
 8         /*
 9         FileOutputStream fileOut = new FileOutputStream("aa.txt");
10         BufferedOutputStream bufOut = new BufferedOutputStream(fileOut);
11         */
12         //2.写入文件
13         out.write("你好Java".getBytes());
14         out.write("Hello".getBytes());
15         out.write("Worlddddddddd".getBytes());
16         
17         //3.刷新缓冲区
18         
19     //    out.flush();
20         
21         //4.释放资源
22         out.close();//先flush()，再close()
23     }
24 }

5.带缓冲的字节流_BufferedInputStresam

BufferedInputStream读取数据

构造方法：
　　 BufferedInputStream(InputStream in) 创建一个 BufferedInputStream 并保存其参数，即输入流 in，以便将来使用。
　　 BufferedInputStream(InputStream in, int size)创建具有指定缓冲区大小的 BufferedInputStream 并保存其参数，即输入流 in，以便将来使用。
读取方法：
　　无，都是从父类继承的；

 1 public class Demo {
 2     public static void main(String[] args) throws IOException{
 3         //1.实例化一个带缓冲的输入流
 4         BufferedInputStream in = new BufferedInputStream(new FileInputStream("bufferdOutput.txt"));
 5         //2.一次读取一个字节
 6         /*int n = 0;
 7         while((n = in.read()) != -1){
 8             System.out.println((char) n);
 9         }*/
10         byte[] byteArray = new byte[10];
11         int n = 0;
12         while((n = in.read(byteArray)) != -1){
13             System.out.println(new String(byteArray,0,n));
14         }
15         //3.释放资源
16         in.close();
17     }
18 }

6.String类中的编码和解码

编码：把看得懂的，变为看不懂的；
　　 String --> getBytes():使用平台默认的字符集(编码表)；
　　 getBytes(String charset):使用指定的字符集编码；
解码：把看不懂的，变为看得懂的：
　 String的构造方法：

当我们写入文件时，如果需要显示到屏幕，最好指定编码方式：
保证写入时的编码和读取时的解码保持一致即可。

 1 public class Demo {
 2     public static void main(String[] args) throws UnsupportedEncodingException {
 3         String str = "abc";
 4         byte[] byteArray = str.getBytes();//GBK编码
 5         System.out.println("GBK编码长度：" + byteArray.length);//3
 6         byteArray = str.getBytes("UTF-8");
 7         System.out.println("UTF-8编码长度：" + byteArray.length);//3
 8         
 9         str = "你";
10         byteArray = str.getBytes();//GBK编码
11         System.out.println("GBK编码长度：" + byteArray.length);//2
12         byteArray = str.getBytes("UTF-8");
13         System.out.println("UTF-8编码长度：" + byteArray.length);//3
14         
15         //解码
16         str = "你好吗";
17         byteArray = str.getBytes();//使用GBK编码
18         
19         //使用GBK解码
20         String s2 = new String(byteArray,"UTF-8");
21         System.out.println("s2 = " + s2);
22         
23         
24         
25     }
26 }

7.转换流_输出流

转换流--输出流：
字节流：
　　输出流：OutputStream
　　输入流：InputStream
字符流：
　　输出流：Writer
　　　　 |-OutputStreamWriter：将字节输出流转换为字符输出流；
　　输入流：Reader
　　　　|--InputStreamReader:将字节流的输入流，转换为字符的输入流；
　　
构造方法：这也是转换流的作用：可以将"字节流"转换为"字符流"
　　 public OutputStreamWriter(OutputStream out)
　　 public OutputStreamWriter(OutputStream out,String charsetName)
　　
写入的方法：
　　public void write(int c)：写入一个字符；
　　 public void write(char[] cbuf)：写入一个字符数组
　　 public void write(char[] cbuf,int off,int len)：写入一个字符数组的一部分
　　 public void write(String str)：写入一个字符串
　　 public void write(String str,int off,int len)：写入一个字符串的一部分；

 1 public class Demo {
 2     public static void main(String[] args) throws IOException {
 3         OutputStreamWriter out = new OutputStreamWriter(new FileOutputStream("demo13_1.txt"));//GBK
 4         OutputStreamWriter out2 = new OutputStreamWriter(new FileOutputStream("demo13_2.txt"),"UTF-8");
 5         
 6         //写入的方法
 7         //1.public void write(int c)
 8         int n = 98;
 9         out.write(n);
10         
11         //2.public void write(char[] cbuf)
12         char[] charArray = {‘a‘,‘b‘,‘c‘,‘你‘,‘好‘};
13         out.write(charArray);
14         
15         //3.public void write(char[] cbuf,int off,int len)
16         //写入"你好"：
17         out.write(charArray,3,2);
18         
19         //4.public void write(String str)
20         
21         out.write("Java我爱你！");
22         
23         //5.public void write(String str,int off,int len)
24         //写入："我爱你"
25         String str = "Java我爱你！";
26         out.write(str,4,4);
27         
28         //释放资源
29         out.close();
30         
31     }
32 }

8.转换流_输入流

InputStreamReader：
InputStreamReader(InputStream in) ：创建一个使用默认字符集的 InputStreamReader。
InputStreamReader(InputStream in, String charsetName) ：创建使用指定字符集的 InputStreamReader。

成员方法：
　　 int read() ：读取单个字符。
　　 int read(char[] cbuf) 将字符读入数组。

 1 public class Demo {
 2     public static void main(String[] args) throws IOException{
 3         //1.构造一个输入流，转换流
 4         InputStreamReader in = new InputStreamReader(new FileInputStream("demo13_1.txt"));
 5         //2.读取数据：
 6         //1.int read()：读取单个字符
 7         int n = in.read();
 8         while(n != -1){
 9             System.out.println("n = " + n);
10             System.out.println("读取的字符：" + (char)n);
11             n = in.read();
12         }
13         
14         //方式二：
15         /*int n = 0;
16         while((n = in.read()) != -1){
17             System.out.println((char)n);
18         }*/
19         
20         //2.int read(char[] cbuf) :读取一个字符数组
21         /*char[] charArray = new char[4];
22         int n = 0;
23         while((n = in.read(charArray)) != -1){
24             System.out.println("n = " + n);
25             //char[]数组转换为字符串；
26             String str = new String(charArray,0,n);
27             System.out.println(str);
28         }*/
29         
30         
31         
32         
33         //释放资源
34         in.close();
35         
36         
37     }
38 }

9.转换流_5种输出的方式_2种输入的方式

OutputStreamWriter:
write(int n):输出一个字符；
write(char[] c):输出一个char[]数组；
write(char[] c ,int off, int len):输出一个char[]数组的一部分；
write(String str):输出一个字符串

2种输入的方式：
InputStreanReader:
int read():一次读取一个字符
int read(char[] c):一次读取一个字符数组；

10.字符流类

字节流：
　　输出流：OutputStream
　　输入流：InputStream
字符流：
　　输出流：Writer:
　　　 |--OutputStreamWriter(转换流 )
　　    |--FileWriter(基本字符流)
　　
输入流：Reader:
　　 |--InputStreamReader:(转换流)
　　   |--FileReader(基本字符流)

FileWriter:
构造方法：

　　· FileWriter(File file)根据给定的 File 对象构造一个 FileWriter 对象。
　　  FileWriter(File file, boolean append) ：根据给定的 File 对象构造一个 FileWriter 对象。
　　 FileWriter(String fileName) ：根据给定的文件名构造一个 FileWriter 对象。
　　  FileWriter(String fileName, boolean append) ：根据给定的文件名以及指示是否附加写入数据的 boolean 值来构造 FileWriter

成员方法：
无，都是继承的：5种写的方法；
-----------------------------------------------------------------------------------
FileReader:

构造方法：
FileReader(File file)：在给定从中读取数据的 File 的情况下创建一个新 FileReader。
FileReader(String fileName) ：在给定从中读取数据的文件名的情况下创建一个新 FileReader。
成员方法：
无，都是继承的：2种读的方法；

复制文本文件：
1.输入流：FileReader;
2.输出流：FileWriter;

 1 public class Demo {
 2     public static void main(String[] args) throws IOException{
 3         FileReader in = new FileReader("D:\\ccc.txt");
 4         FileWriter out = new FileWriter("demo17_copy_2.txt");
 5         
 6         //一次读、写一个字符
 7     /*    int n = 0;
 8         while((n = in.read()) != -1){
 9             out.write(n);
10         }
11         */
12         //一次读、写一个字符数组
13         char[] charArray = new char[1024];
14         int n = 0;
15         while((n = in.read(charArray)) != -1){
16             out.write(charArray,0,n);
17         }
18         //释放资源
19         in.close();
20         out.close();
21         
22         System.out.println("复制完毕！");
23         
24     }
25 }

11.带缓冲的字符流_BufferedWriter

Writer:
　　|--BufferedWriter:

构造方法：
　　 BufferedWriter(Writer out)：创建一个使用默认大小输出缓冲区的缓冲字符输出流。
　　BufferedWriter(Writer out, int sz)：创建一个使用给定大小输出缓冲区的新缓冲字符输出流。
　　
写的方法：
　　无。全是继承的：5种写的方法：

特有的方法：
　　 void newLine():输出一个换行符；

 1 public class Demo {
 2     public static void main(String[] args) throws IOException{
 3         //构造一个带缓冲的输出流
 4         BufferedWriter out = new BufferedWriter(new FileWriter("fileWriter.txt"));
 5         out.write("你好");
 6         out.newLine();//输出一个换行符；
 7         out.write("Java");
 8         out.close();
 9         
10     }
11 }

12.带缓冲的字符流_BufferedReader

Reader:
|--BufferedReader:

构造方法：
BufferedReader(Reader in)：创建一个使用默认大小输入缓冲区的缓冲字符输入流。
BufferedReader(Reader in, int sz) ：创建一个使用指定大小输入缓冲区的缓冲字符输入流。

读的方法：
1.继承了父类的读的方法：2种需要掌握：(一次读一个字符，一次读一个字符数组)
2.String readLine():一次读取一行文本(不带换行符)。

 1 public class Demo {
 2     public static void main(String[] args) throws IOException{
 3         //1.构造一个带缓冲的输入流
 4         BufferedReader in = new BufferedReader(new FileReader("fileWriter.txt"));
 5         
 6         //2.一次读取一行数据
 7         String row = null;
 8         while((row = in.readLine()) != null){
 9             System.out.println(row);
10         }
11         //3.释放资源
12         in.close();
13         
14         
15     }
16 }

13.数据输入输出流

InputStream:
　　 |--FilterInputStream:
　　 |--DataInputStream:
OutputStream:
　　|--FilterOutputStream:
　　 |--DataOutputStream:

数据输入、输出流：
　　 DataOutputStream:数据输出流允许应用程序以适当方式将基本 Java 数据类型写入输出流中。然后，应用程序可以使用数据输入流将数据读入。
　　 DataInputStream:数据输入流允许应用程序以适当方式将基本 Java 数据类型写入输出流中。然后，应用程序可以使用数据输出流将数据读入。

 1 public class Demo {
 2     public static void main(String[] args) throws IOException{
 3         //1.数据输出流
 4         DataOutputStream out = new DataOutputStream(new FileOutputStream("demo07.txt"));
 5         //2.输出基本数据类型；
 6         byte v1 = 20;
 7         out.writeByte(v1);
 8         short v2 = 30;
 9         out.writeShort(v2);
10         int v3 = 40;
11         out.writeInt(v3);
12         long v4 = 50;
13         out.writeLong(v4);
14         char v5 = ‘你‘;
15         out.writeChar(v5);
16         boolean v6 = true;
17         out.writeBoolean(v6);
18         float v7 = 3.14F;
19         out.writeFloat(v7);
20         double v8 = 3.14159;
21         out.writeDouble(v8);
22         
23         out.close();
24         System.out.println("写入完毕");
25         
26         //读取信息
27         DataInputStream in = new DataInputStream(new FileInputStream("demo07.txt"));
28         byte vv1 = in.readByte();
29         short vv2 = in.readShort();
30         int vv3 = in.readInt();
31         long vv4 = in.readLong();
32         char vv5 = in.readChar();
33         boolean vv6 = in.readBoolean();
34         float vv7 = in.readFloat();
35         double vv8 = in.readDouble();
36         
37         System.out.println("byte = " + vv1);
38         System.out.println("short = " + vv2);
39         System.out.println("int = " + vv3);
40         System.out.println("long = " + vv4);
41         System.out.println("char = " + vv5);
42         System.out.println("boolean = " + vv6);
43         System.out.println("float = " + vv7);
44         System.out.println("double = " + vv8);
45         
46         in.close();
47         
48         
49     }
50 }

14.内存操作流_byte数组缓冲流

操作字节数组
　　 ByteArrayInputStream:从内存读取:不需要close();
　　 ByteArrayOutputStream：向内存写入：不需要close();

 1 public class Demo {
 2     public static void main(String[] args) throws IOException {
 3         FileInputStream in = new FileInputStream("D:\\ccc.txt");
 4         //一次读取一个字节数组
 5         byte[] byteArray = new byte[1024];
 6         int n = 0;
 7         //定义一个字节数组的缓存区；
 8         ByteArrayOutputStream byteOut = new ByteArrayOutputStream();
 9         
10         while((n = in.read(byteArray)) != -1){
11             //以前，要么显示出来，要么写入到另一个文件中；
12             //现在，啥也不做，
13             //将已读取的byteArray中的数据写入到缓存区
14             byteOut.write(byteArray, 0, n);//输出到内存；
15         }
16         in.close();
17         
18         //从缓冲区取；
19         //1.获取byte[]数组
20         byte[] b2 = byteOut.toByteArray();
21         
22         //输出到另一个文件
23         /*FileOutputStream out = new FileOutputStream("demo08.txt");
24         out.write(b2);*/
25         //使用ByteArrayInputStream分批读取
26         ByteArrayInputStream byteIn = new ByteArrayInputStream(b2);//Byte数组缓冲区的输入流
27         FileOutputStream out = new FileOutputStream("demo08.txt");
28         //一次读取一个字节
29         n = 0;
30         while((n = byteIn.read()) != -1){
31             out.write(n);
32         }
33         //释放资源
34         out.close();
35         System.out.println("完毕！");
36         
37     }
38 }

15.打印流

Writer:
　　 |--PrintWriter(字符打印流)
OutputStream:
　　|--FilterOutputStream:
　　|--PrintStream(字节打印流)
　　
打印流的特点：
　　 1.只能操作目的地，不能操作数据。(只有输出流，没有输入流)
　　 2.可以操作任意类型的数据。(基本数据类型和引用数据类型)
　　 3.如果启动了自动刷新，能够自动刷新。
　　 4.可以操作文件的流

16.PrintWriter实现自动刷新和换行

PrintWriter实现自动刷新和换行

构造方法：
　　PrintWriter(OutputStream out, boolean autoFlush) ：通过现有的 OutputStream 创建新的 PrintWriter。
　　 PrintWriter(Writer out, boolean autoFlush)：创建新 PrintWriter。
　　
　　如果启用了自动刷新，则只有在调用 println、printf 或 format 的其中一个方法时才可能完成此操作。

 1 public class Demo {
 2     public static void main(String[] args) throws IOException {
 3         PrintWriter out = new PrintWriter(new FileWriter("demo11.txt"),true);
 4         
 5         //write方法，即使启动了自动刷新，也不会自动刷新缓冲区。
 6         /*
 7         out.write("你好");
 8         out.write("java");
 9         */
10         
11         out.println("你好");
12         out.println("java");//write() + newLine() + flush()
13         
14         
15         
16     }
17 }

17.标准输入输出流概述和输出语句的本质_PrintStream

标准输入、输出流：

System.in：InputStream(字节流)
System.out：PrintStream(字节流)

 1 public class Demo {
 2     public static void main(String[] args) {
 3         InputStream in = System.in;
 4         System.out.println(in);//BufferedInputStream
 5         
 6         PrintStream out = System.out;
 7         System.out.println(out);//PrintStream
 8         
 9         out.println("大家好！");
10         
11         System.out.println("大家好");
12         
13         int[] intArray = {1,32,4,325,43,5};
14         out.println(intArray);//println(Object obj);
15         
16         char[] charArray = {‘a‘,‘b‘,‘c‘,‘你‘};
17         out.println(charArray);//println(char[] charArray);
18         
19         
20     }
21 }

18.三种方式实现键盘录入

三种方式实现键盘录入

1.Scanner:
2.main方法有个形参；
3.标准输入流：System.in

 1 public class Demo {
 2     public static void main(String[] args) throws IOException {
 3         //2.main方法有个形参；
 4         for (int i = 0; i < args.length; i++) {
 5             System.out.println("参数 " + i + " :" + args[i]);
 6         }
 7         
 8         //3.标准输入流：System.in
 9         InputStream in = System.in;//BufferedInputStream
10         /*
11         int n = in.read();//一次读取一个字节；
12         System.out.println("你输入的是：" + (char)n);
13         */
14         
15         //字节流-->转换流 -->字符流：
16         //InputStream --> InputStreamReader --> BufferedReader
17         
18         //已经有了字节流，现在构造一个"转换流"
19         InputStreamReader isr = new InputStreamReader(in);
20         //通过"转换流"，构造一个"字符流"
21         BufferedReader bufIn = new BufferedReader(isr);
22         
23         //一次读取一个字符；
24         /*int n = bufIn.read();
25         System.out.println("你输入的字符是：" + (char)n);*/
26         //一次取一个字符数组
27         /*char[] charArray = new char[2];
28         int n = bufIn.read(charArray);
29         System.out.println("字符数组的内容：" + Arrays.toString(charArray));*/
30         //一次读取一行；
31         String row = bufIn.readLine();
32         System.out.println("一次读取一行数据：" + row);
33         
34     }
35 }

19.随机访问流概述和写出数据

随机访问流概述和写出数据
java.io.RandomAccessFile:

RandomAccessFile类不属于流，是Object类的子类。但它融合了InputStream和OutputStream的功能。支持对随机访问文件的读取和写入。

构造方法:
RandomAccessFile(File file, String mode) 创建从中读取和向其中写入（可选）的随机访问文件流，该文件由 File 参数指定。
RandomAccessFile(String name, String mode) :创建从中读取和向其中写入（可选）的随机访问文件流，该文件具有指定名称。
形参：
mode:
值含意
"r" 以只读方式打开。调用结果对象的任何 write 方法都将导致抛出 IOException。
"rw" 打开以便读取和写入。如果该文件尚不存在，则尝试创建该文件。

成员方法：
1.writeXxxx();
2.readXxxx();
3.public long getFilePointer():获取文件指针；
4.public void seek(long pos)：设置文件指针；

 1 public class Demo {
 2     public static void main(String[] args) throws IOException{
 3         /*RandomAccessFile raf = new RandomAccessFile("demo16.txt","rw");
 4         
 5         //写入
 6         raf.writeInt(20);
 7         raf.writeChar(‘a‘);
 8         raf.writeUTF("你好");
 9         
10         //释放资源
11         raf.close();
12         System.out.println("写入完毕！");
13         */
14         //读取文件内容
15         RandomAccessFile raf = new RandomAccessFile("demo16.txt","r");
16         System.out.println("指针：" + raf.getFilePointer());//0
17         int v1 = raf.readInt();
18         System.out.println("指针：" + raf.getFilePointer());//4
19         char v2 = raf.readChar();
20         System.out.println("指针：" + raf.getFilePointer());//6
21         String v3 = raf.readUTF();//先读2个字节；
22         System.out.println("指针：" + raf.getFilePointer());//之前6 + 2 + 6 : 14
23         System.out.println("int = " + v1);
24         System.out.println("char = " + v2);
25         System.out.println("String = " + v3);
26         
27         //将指针设为4
28         raf.seek(4);
29         char v4 = raf.readChar();
30         System.out.println("移动指针后读取一个字符：" + v4);
31         
32     }
33 }

20.序列化流和反序列化流的概述和使用

1.序列化：我们可以将一个"对象"存储到一个文件中，或者通过网络传输给另一个电脑；
这个过程就叫：序列化；

从文件中读取一个"对象"信息，从网络接收到一个对象，这时需要将"被序列化的对象"还原为
程序中的对象，这个过程就叫：反序列化；

2.序列化：
ObjectOutputStream：
成员方法：
writeObject(Object obj):
注意：
　　 1. 被序列化的对象必须实现：Serializable接口
　　 Serializable接口：没有任何方法，这种接口叫做：标记接口；
　　2. 被序列化的对象，显示的添加一个字段：serialVersionUID = 值;
　　反序列化：
　　 ObjectInputStream:
　　成员方法：
　　 Object readObject() ：

 1 public class Demo {
 2     public static void main(String[] args) throws IOException, ClassNotFoundException {
 3         /*Student stu = new Student("刘德华",20,"香港");
 4         
 5         //序列化：ObjectOutputStream
 6         ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("demo17.txt"));
 7         //序列化一个对象： writeObject(Object obj)  
 8         out.writeObject(stu);
 9         
10         out.close();*/
11         
12         //反序列化
13         ObjectInputStream in = new ObjectInputStream(new FileInputStream("demo17.txt"));
14         
15         Object obj = in.readObject();
16         Student stu2 = (Student)obj;
17         
18         System.out.println("obj = " + obj);
19         System.out.println(stu2.getName() + "," + stu2.getAge());
20     }
21 }

 1 import java.io.Serializable;
 2 
 3 public class Student implements Serializable{
 4     
 5     private static final long serialVersionUID = 2L;
 6     private String name;
 7     private int age;
 8     private String address;
 9     private char sex;
10     
11     public Student() {
12         super();
13     }
14     public Student(String name, int age,String address,char sex) {
15         super();
16         this.name = name;
17         this.age = age;
18         this.address = address;
19         this.sex = sex;
20     }
21     public String getName() {
22         return name;
23     }
24     public void setName(String name) {
25         this.name = name;
26     }
27     public int getAge() {
28         return age;
29     }
30     public void setAge(int age) {
31         this.age = age;
32     }
33     
34     
35 }

21.Properties的概述和作为Map集合的使用

java.util.Map:
　　 |--Hashtable:
　　 |--Properties:
　　 1.此类不支持泛型；

 1 public class Demo {
 2     public static void main(String[] args) {
 3         Properties pro = new Properties();
 4         pro.put("it001", "贾玲");
 5         pro.put("it002", "沙溢");
 6         pro.put("it003", "瞿颖");
 7         pro.put("it004", "李菁");
 8         
 9         Set<Object> keySet = pro.keySet();
10         for(Object key : keySet){
11             System.out.println(key + "\t" + pro.get(key));
12         }
13     }
14 }

22.Properties操作配置文件

一般的程序都需要配置文件，记录：用于的一些配置信息；

要读取配置文件，使用字符流是可以的。但是由于配置文件有固定的格式：名 = 值；
所以Java就提供了一种双列的集合:Properties类，并且内部，添加了一些读取、写入文件的一些方法。

操作配置文件的方法：
public void load(Reader reader)：读取。直接存储到本集合内部；
public void store(Writer writer,String comments)：写入。将集合内部的所有键值对，写到配置文件中；

 1 public class Demo {
 2     public static void main(String[] args)  throws IOException{
 3         //写入：
 4         /*Properties pro = new Properties();
 5         
 6         //填充集合
 7         pro.setProperty("疲劳", "100");
 8         pro.setProperty("血量", "100");
 9         pro.setProperty("金币", "500000");
10         pro.setProperty("等级", "80");
11         
12         //写入到配置文件
13         FileWriter out = new FileWriter("demo21.properties");
14         
15         pro.store(out, "Properties测试：");
16         
17         out.close();
18         System.out.println("写入完毕！");
19         */
20         
21         //读取。一次读取全部内容到一个Properties对象中
22         Properties pro = new Properties();
23         FileReader in = new FileReader("demo21.properties");
24         pro.load(in);
25         in.close();
26         
27         //遍历集合
28         Set<String> keySet = pro.stringPropertyNames();
29         for(String key : keySet){
30             System.out.println(key + " = " + pro.getProperty(key));
31         }
32         
33         
34     }
35     
36 }

java--IO流（2）--黑马程序员

标签：

原文地址：http://www.cnblogs.com/linmusen/p/4709273.html

踩

(0)

评论一句话评论（0）

分享档案

更多>

2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)

周排行