--------------------- android培训、java培训、java学习型技术博客、期待与您交流！ -------------------
1 对象序列化
ObjectOutputStram和ObjectInputStream
被操作的对象要实现Serializable(标记接口)
概述：
将堆内存中的对象存入硬盘，保留对象中的数据，称之为对象的持久化（或序列化）
特有方法：
1、write(int val) ---> 写入一个字节（最低八位）
2、writeInt(int vale) ---> 吸入一个32为int值
使用步骤：
说明：serialVersion
a、给类一个可被编译器识别的的序列号，在编译类时，会分配一个long型UID，通过序列号，将类存入硬盘中，并序列化，即持久化。序列号根据成员算出的。静态不能被序列化。如果非静态成员也无需序列化，可以用transien修饰。
b、接口Serializable中没有方法，称之为标记接口
1、写入流对象：
1）创建对象写入流，与文件关联，即传入目的
2）通过写入writeObject()方法，将对象作为参数传入，即可写入文件
2、读取流对象
1）创建对象读取流，与文件关联，即传入源
2）通过writeObject()方法，读取文件中的对象，并返回这个对象
例子：
例子：[java] view plaincopy
1 /*
2 对象的序列化
3 */
4
5 import java.io.*;
6 //对象序列化测试
7 class ObjectStreamDemo
8 {
9 public static void main(String[] args) throws Exception
10 {
11 //对象写入流
12 writeObj();
13 //对象读取流
14 readObj();
15 }
16 //定义对象读取流
17 public static void readObj()throws Exception
18 {
19 //ObjectInputStream对细节对象进行操作
20 //创建对象读取流
21 ObjectInputStream ois = new ObjectInputStream(new FileInputStream("obj.txt"));
22 //通过读取文件数据，返回对象
23 Person p = (Person)ois.readObject();
24
25 System.out.println(p);
26 //最终关闭流对象
27 ois.close();
28 }
29 //定义对象写入流
30 public static void writeObj()throws IOException
31 {
32 //创建对象写入流
33 ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("obj.txt"));
34 //写入对象数据
35 oos.writeObject(new Person("lisi0",399,"kr"));
36 //关闭流资源
37 oos.close();
38 }
39 }
[java] view plaincopy
40 /*
41 没有方法的接口通常称为标记
42 */
43
44 import java.io.*;
45 //创建Person类，实现序列化
46 class Person implements Serializable
47 {
48 //定义自身的序列化方式
49 public static final long serialVersionUID = 42L;
50 //定义私有属性
51 private String name;
52 //age被transient修饰后就不能被序列化了，保证其值只在堆内存中存在，而不再文本文件中存在
53 transient int age;
54 //静态成员变量不能被序列化
55 static String country = "cn";
56 //构造Person类
57 Person(String name,int age,String country)
58 {
59 this.name = name;
60 this.age = age;
61 this.country = country;
62 }
63 //覆写toString方法
64 public String toString()
65 {
66 return name+":"+age+":"+country;
67 }
68 }
2 管道流
概述：
1、管道流：PipedInputStream和PipedOutputStream
2、管道流输入输出可以直接进行连接，通过结合线程使用。
3、PipedInputStream和PipedOutputStream是涉及到多线程技术的IO流对象。
使用步骤：
1、要先创建一个读和写的两个类，实现Runnable接口，因为是两个不同的线程，覆盖run方法，注意，需要在内部抛异常
2、创建两个管道流，并用connect()方法将两个流连接
3、创建读写对象，并传入两个线程内，并start执行
例子：
lisd[java] view plaincopy
69 /*
70 管道流技术，涉及多线程技术
71 */
72
73 import java.io.*;
74 //创建Read类，实现run方法
75 class Read implements Runnable
76 {
77 private PipedInputStream in;
78
79 Read(PipedInputStream in)
80 {
81 this.in = in;
82 }
83 //实现run方法
84 public void run()
85 {
86 try
87 {
88 byte[] buf = new byte[1024];
89 //读取写入的数据
90 System.out.println("读取前。。没有数据阻塞");
91 int len = in.read(buf);
92 System.out.println("读到数据。。阻塞结束");
93
94
95
96 String s= new String(buf,0,len);
97
98 System.out.println(s);
99
100 in.close();
101
102 }
103 catch (IOException e)
104 {
105 throw new RuntimeException("管道读取流失败");
106 }
107 }
108 }
109 //创建Write类
110 class Write implements Runnable
111 {
112 private PipedOutputStream out;
113 //Write构造函数
114 Write(PipedOutputStream out)
115 {
116 this.out = out;
117 }
118 //实现run方法
119 public void run()
120 {
121 try
122 {
123 //写入数据
124 System.out.println("开始写入数据，等待6秒后。");
125 Thread.sleep(6000);
126 out.write("piped lai la".getBytes());
127 out.close();
128 }
129 catch (Exception e)
130 {
131 throw new RuntimeException("管道输出流失败");
132 }
133 }
134 }
135
136 class PipedStreamDemo
137 {
138 public static void main(String[] args) throws IOException
139 {
140 //创建管道流对象
141 PipedInputStream in = new PipedInputStream();
142 PipedOutputStream out = new PipedOutputStream();
143 //将读取流（输入流）和写入流（输出流）关联起来
144 in.connect(out);
145
146 Read r = new Read(in);
147 Write w = new Write(out);
148 //创建读写对象，并创建线程对象
149 new Thread(r).start();
150 new Thread(w).start();
151
152
153 }
154 }
3 RandomAccessFile 类
概述：
1、RandomAccessFile称之为随机访问文件的类，自身具备读写方法。
2、该类不算是IO体系中的子类，而是直接继承Object，但是它是IO包成员，因为它具备读写功能，内部封装了一个数组，且通过指针对数组的元素进行操作，同时可通过seek改变指针的位置。
3、可以完成读写的原理：内部封装了字节输入流
4、构造函数：RandomAccessFile(File file,String mode)，可已从它的构造函数中看出，该类只能操作文件（也有字符串），而且操作文件还有模式。
模式传入值：”r“：以只读方式打开；”rw“：打开以便读写
如果模式为只读，则不会创建文件，会去读一个已存在的文件，若文件不存在，则会出现异常，如果模式为rw，且该对象的构造函数要操作的文件不存在，会自动创建，如果存在，则不会覆盖，也可通过seek方法修改。
5.RandomAccessFile的最大的作用是实现多线程的下载
特有方法：
1、seek(int n)：设置指针，可以将指针设置到前面或后面
2、skipBytes(int n)：跳过指定字节数，不可往前跳
使用步骤：
1、创建RandomAccessFile对象
2、将数据写入到指定文件中
3、读取数据，读入到指定文件中
注意：要想取得后面的数据，需要调用数组指针，通过改变角标位置，取出相应的数据
a.调整对象的指针：seek()
b.跳过指定字节数
例子：
例子[java] view plaincopy
155 class RandomAccessFileDemo
156 {
157 public static void main(String[] args) throws IOException
158 {
159 //writeFile_2();
160 //readFile();
161
162 //System.out.println(Integer.toBinaryString(258));
163
164 }
165
166 public static void readFile()throws IOException
167 {
168 //"r"代表模式，只读
169 RandomAccessFile raf = new RandomAccessFile("ran.txt","r");
170
171 //seek和skipBytes的区别是：skipBytes不能往回跳，seek可以前后的跳，可以随意改变指针。
172
173 //调整对象中指针。
174 //raf.seek(8*1);
175
176 //跳过指定的字节数
177 raf.skipBytes(8);
178
179 byte[] buf = new byte[4];
180
181 raf.read(buf);
182
183 String name = new String(buf);
184
185 int age = raf.readInt();
186
187
188 System.out.println("name="+name);
189 System.out.println("age="+age);
190
191 raf.close();
192
193
194 }
195
196 public static void writeFile_2()throws IOException
197 {
198 RandomAccessFile raf = new RandomAccessFile("ran.txt","rw");
199 raf.seek(8*0);
200 raf.write("周期".getBytes());
201 raf.writeInt(103);
202
203 raf.close();
204 }
205
206 public static void writeFile()throws IOException
207 {
208 RandomAccessFile raf = new RandomAccessFile("ran.txt","rw");
209
210 raf.write("李四".getBytes());
211 raf.writeInt(97);
212 raf.write("王五".getBytes());
213 raf.writeInt(99);
214
215 raf.close();
216 }
217 }
4 操作基本数据类型的流对象
概述：
1、操作基本数据类型的流对象：DataInputStream和DataOutputStream
2、这两个读写对象，可用于操作基本数据类型的流对象，包含读写各种基本数据类型的方法
特有方法：
返回值类型 读 写
int型 writeInt(int n) int readInt()
boolean型 writeBoolean(boolean b) boolean readBoolean()
double型 writeDouble(double d) double readDouble()
[java] view plaincopy例子：
218 import java.io.*;
219 class DataStreamDemo
220 {
221 public static void main(String[] args) throws IOException
222 {
223 //writeData();
224 //readData();
225
226 //writeUTFDemo();
227
228 // OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("gbk.txt"),"gbk");
229 //
230 // osw.write("你好");
231 // osw.close();
232
233 // readUTFDemo();
234
235 }
236 public static void readUTFDemo()throws IOException
237 {
238 DataInputStream dis = new DataInputStream(new FileInputStream("utf.txt"));
239
240 String s = dis.readUTF();
241
242 System.out.println(s);
243 dis.close();
244 }
245
246
247
248 public static void writeUTFDemo()throws IOException
249 {
250 DataOutputStream dos = new DataOutputStream(new FileOutputStream("utfdate.txt"));
251
252 dos.writeUTF("你好");
253
254 dos.close();
255 }
256
257 public static void readData()throws IOException
258 {
259 DataInputStream dis = new DataInputStream(new FileInputStream("data.txt"));
260
261 int num = dis.readInt();
262 boolean b = dis.readBoolean();
263 double d = dis.readDouble();
264
265 System.out.println("num="+num);
266 System.out.println("b="+b);
267 System.out.println("d="+d);
268
269 dis.close();
270 }
271 public static void writeData()throws IOException
272 {
273 DataOutputStream dos = new DataOutputStream(new FileOutputStream("data.txt"));
274
275 dos.writeInt(234);
276 dos.writeBoolean(true);
277 dos.writeDouble(9887.543);
278
279 dos.close();
280
281 ObjectOutputStream oos = null;
282 oos.writeObject(new O());
283
284
285 }
286 }
5 操作数组和字符串的流对象
概述：操作字节数组的对象：ByteArrayInputStream和ByteArrayOutputStream
1、这个对象并没有调用底层资源，所以不用关闭流资源
2、存入的是缓冲区，并未用到键盘和硬盘灯，所以不需要抛任何IO异常
3、对象中封装了数组
4、构造函数：
1）ByteArrayInputStream：在构造函数的时候，需要接受数据源，而且数据源是一个字节数据。
2）ByteArrayOutputStream：在构造函数的时候，不用定义数据目的，因为该对象中已经在内部封装了可变长度的字节数组，这就是数据的目的地
5、因为两个流对象都是操作的是数据，并没有使用系统资源，所以不用进行close关闭。
6、其实就是用流的思想操作数组
7、特有方法：writeTo(OutputStream out) 这个方法用到了字节输出流，有异常存在，需要抛IO异常
对应的字符数组和字符串：
字符数组流对象：CharArrayReader和CharArrayWriter
字符串流对象： StringReader和StringWriter
例子：
[java] view plaincopy
287 /*
288 用于操作字节数组的流对象。
289
290 ByteArrayInputStream ：在构造的时候，需要接收数据源，。而且数据源是一个字节数组。
291
292 ByteArrayOutputStream： 在构造的时候，不用定义数据目的，因为该对象中已经内部封装了可变长度的字节数组。
293 这就是数据目的地。
294
295 因为这两个流对象都操作的数组，并没有使用系统资源。
296 所以，不用进行close关闭。
297 在流操作规律讲解时：
298 源设备，
299 键盘 System.in，硬盘 FileStream，内存 ArrayStream。
300 目的设备：
301 控制台 System.out，硬盘FileStream，内存 ArrayStream。
302 用流的读写思想来操作数据。
[java] view plaincopy
303 toString()方法是将字节缓冲区的数据转化成字符串
304
305 */
306 import java.io.*;
307 class ByteArrayStream
308 {
309 public static void main(String[] args)
310 {
311 //数据源。在内存当中
312 ByteArrayInputStream bis = new ByteArrayInputStream("ABCDEFD".getBytes());
313
314 //数据目的 也在内存当中
315 ByteArrayOutputStream bos = new ByteArrayOutputStream();
316
317 int by = 0;
318 //读取和写入数据
319 while((by=bis.read())!=-1)
320 {
321 bos.write(by);
322 }
323
324 System.out.println(bos.size());
325 System.out.println(bos.toString());
326
327 try
328 {
329 //方法，此处抛异常，所以上面需要抛出去
330 baos.writeTo(new FileOutputStream("a.txt"));
331 }
332 catch (IOException e)
333 {
334 throw new RuntimeException("写入文件失败");
335 }
336
337 }
338 }
6 字符编码
概述：
1、字符流的出现为了方便操作字符，更重要的是加入了编码的转换，即转换流。
2、通过子类进行转换
3、在两个对象进行构造时，可加入编码表
4、可传入编码表的有：
1）转换流：InuputStreamReader和OutputStreamWriter
2）打印流：PrintStream和PrintWriter，只有输出流
5.编码表的由来
1)计算机只能识别二进制数据，早期由来是电信号。
2)为了方便应用计算机，让它可以识别各个国家的文字。
3)就将各个国家的文字用数字来表示，并一一对应，形成一张表。
这就是编码表
6、常见的编码表：
1）ASCII：美国标准信息交换码表。用一个字节的7位表示
2）IOS8859-1：拉丁码表；欧洲码表。用一个字节的8位表示
3）GB2312：中国的中文编码表
4）GBK：中国的中文编码表升级，融合了更多的中文文字字符。打头的是两个高位为1的两个字节编码。为负数
5）Unicode：国际标准码，融合了多种文字
6）UTF-8：最多用三个字节表示一个字符的编码表，包括：一位、两位、三位表示的字符
UTF-8有自己的字节码：
一个字节：0开头
两个字节：字节一 ---> 110 位数：10 ~ 6
字节二 ---> 10 位数：5 ~ 0
三个字节：字节一 ---> 110 位数：15 ~ 12
字节二 ---> 10 位数：11 ~ 6
字节三 ---> 10 位数：5 ~ 0
例子：
[java] view plaincopy
339 import java.io.*;
340 class EncodeStream
341 {
342 public static void main(String[] args) throws IOException
343 {
344 //writeText();
345 readText();
346 }
347
348 public static void readText()throws IOException
349 {
350 InputStreamReader isr = new InputStreamReader(new FileInputStream("utf.txt"),"gbk");
351
352 //定义数组长度
353 char[] buf = new char[10];
354 int len = isr.read(buf);
355
356 String str = new String(buf,0,len);
357
358 System.out.println(str);
359
360 isr.close();
361 }
362 public static void writeText()throws IOException
363 {
364 OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("utf.txt"),"UTF-8");
365
366 osw.write("你好");
367
368 osw.close();
369 }
370
371 }
编码和解码：
1、编码：字符串变成字节数组
解码：字节数组变成字符串
2、转换：
1）默认字符集：
String ---> byte[] ：srt.getBytes()
byte[] ---> String ：new String(byte[])
2）指定字符集：
String ---> byte[] ：srt.getBytes(charsetName)
byte[] ---> String ：new String(byte[],charsetName)
例子：
[java] view plaincopy
372 import java.util.*;
373 class EncodeDemo
374 {
375 public static void main(String[] args)throws Exception
376 {
377 String s = "哈哈";
378
379 //对s进行编码
380 byte[] b1 = s.getBytes("GBK");
381 //把数组变成字符串
382 System.out.println(Arrays.toString(b1));
383 String s1 = new String(b1,"utf-8");
384 System.out.println("s1="+s1);
385
386 //对s1进行iso8859-1编码。
387 byte[] b2 = s1.getBytes("utf-8");
388 System.out.println(Arrays.toString(b2));
389
390 String s2 = new String(b2,"gbk");
391
392 System.out.println("s2="+s2);
393
394
395
396 }
397 }
对于编码和解码的字符集转换:
1、如果编码失败，解码就没意义了。
2、如果编码成功，解码出来的是乱码，，则需对乱码通过再次编码（用解错码的编码表），然后再通过正确的编码表解码。针对于IOS8859-1是通用的。
3、如果用的是GBK编码，UTF-8解码，那么再通过2的方式，就不能成功了，因为UTF-8也支持中文，在UTF-8解的时候，会将对应的字节数改变，所以不会成功。
'' 联通"产生的乱码问题：
1)关于联通两个字在记事本为什么会显示乱码问题的总结
联通按照gbk的编码进行存储，但是这两个字的二进制是11000001 10101010
正好符合utf-8的编码规范进行解码，直接去查UTF-8的码表进行解码
2)“联通”二字这样的情况，还有别的，比如“透支”二字。
假设你保存文档时选择另存为，编码格式选择UTF-8，那么你再打开那个文本文档时就不会发生乱码了。
例子：
[java] view plaincopy
398 class EncodeDemo2
399 {
400 public static void main(String[] args) throws Exception
401 {
402 String s = "联通";
403 byte[] by = s.getBytes("gbk");
404
405 for(byte b : by)
406 {
407 System.out.println(Integer.toBinaryString(b&255));
408 }
409
410
411 System.out.println("Hello World!");
412 }
413 }
练习
有五个学生，每个学生有3门课的成绩，
从键盘输入以上数据（包括姓名，三门课成绩），
输入的格式：如：zhagnsan，30，40，60计算出总成绩，
并把学生的信息和计算出的总分数高低顺序存放在磁盘文件"stud.txt"中。
步骤：
1，描述学生对象。
2，定义一个可操作学生对象的工具类。
思想：
1，通过获取键盘录入一行数据，并将该行中的信息取出封装成学生对象。
2，因为学生有很多，那么就需要存储，使用到集合。因为要对学生的总分排序。
所以可以使用TreeSet。
3，将集合的信息写入到一个文件中。
下面给出详细的代码和注释：
[java] view plaincopy
414 import java.io.*;
415 import java.util.*;
416 //定义学生类
417 class Student implements Comparable<Student>
418 {
419 //定义私有属性
420 private String name;
421 private int ma,cn,en;
422 private int sum;
423 //构造Student函数，初始化
424 Student(String name,int ma,int cn,int en)
425 {
426 this.name = name;
427 this.ma = ma;
428 this.cn = cn;
429 this.en = en;
430 sum = ma + cn + en;
431 }
432 //覆写compareTo方法，按学生总成绩排序
433 public int compareTo(Student s)
434 {
435 int num = new Integer(this.sum).compareTo(new Integer(s.sum));
436 if(num==0)
437 return this.name.compareTo(s.name);
438 return num;
439 }
440 //获取学生信息
441 public String getName()
442 {
443 return name;
444 }
445 public int getSum()
446 {
447 return sum;
448 }
449 //覆写hasdCode()和equals()方法，排除相同的两个学生
450 public int hashCode()
451 {
452 return name.hashCode()+sum*78;
453
454 }
455 public boolean equals(Object obj)
456 {
457 if(!(obj instanceof Student))
458 throw new ClassCastException("类型不匹配");
459 Student s = (Student)obj;
460
461 return this.name.equals(s.name) && this.sum==s.sum;
462 }
463 //定义学生信息显示格式
464 public String toString()
465 {
466 return "student["+name+", "+ma+", "+cn+", "+en+"]";
467 }
468 }
469 //工具类，将键盘录入的输入存入集合，并将集合的元素写入文件中
470 class StudentInfoTool
471 {
472 //按照默认的比较方式
473 //无比较器的学生集合
474 public static Set<Student> getStudents()throws IOException
475 {
476 return getStudents(null);
477 }
478 //按照指定比较器的比较方式
479 //具备比较器的学生集合
480 public static Set<Student> getStudents(Comparator<Student> cmp)throws IOException
481 {
482 //读取键盘的录入，记牢固
483 BufferedReader bufr =
484 new BufferedReader(new InputStreamReader(System.in));
485
486 String line = null;
487
488 Set<Student> stus = null;
489 //选择集合是否有比较器
490 if(cmp==null)
491 stus = new TreeSet<Student>();
492 else
493 stus = new TreeSet<Student>(cmp);
494 //循环读取键盘录入的数据
495 while((line=bufr.readLine())!=null)
496 {
497 if("over".equals(line))
498 break;
499 //对读取的数据进行分割并存入集合
500 String[] info = line.split(",");
501
502 //Integer.parseInt是将字符转换成整形数据
503 Student stu = new Student(info[0],Integer.parseInt(info[1]),
504 Integer.parseInt(info[2]),
505 Integer.parseInt(info[3]));
506
507
508 stus.add(stu);
509 }
510
511 bufr.close();
512
513 return stus;
514 }
515
516 //将集合中的数据写入到文件中去
517 public static void write2File(Set<Student> stus)throws IOException
518 {
519 // 创建写入流对象,向文件中系写入数据
520 BufferedWriter bufw = new BufferedWriter(new FileWriter("stuinfo.txt"));
521 //循环写入数据
522 for(Student stu : stus)
523 {
524 //bufw.write(stu.toString()+"\t");是为什么？？？
525 //\t为制表符
526 bufw.write(stu.toString()+"\t");
527 bufw.write(stu.getSum()+"");
528 bufw.newLine();
529 bufw.flush();
530 }
531
532 bufw.close();
533
534 }
535 }
536
537 class StudentInfoTest
538 {
539 public static void main(String[] args) throws IOException
540 {
541 //强行逆转排序比较器 ，反转比较器，将成绩从大到小排
542 Comparator<Student> cmp = Collections.reverseOrder();
543 //将录入的学生信息存入集合
544 Set<Student> stus = StudentInfoTool.getStudents(cmp);
545 //将信息写入指定文件中
546 StudentInfoTool.write2File(stus);
547 }
548 }
总结：
1 对象的序列化和反序列化
|-- 将对象中的数据，永久性存储到硬盘上，序列化
|-- java.io.ObjectOutputStream
|-- 将对象中的数据，从硬盘中读取出来，反序列化
|-- java.io.ObjectInputStream
|-- 静态不能被序列化，静态成员不属于对象，属于类，对象的共享数据
|-- 关键字 transient 表示这个成员不能被序列化
2 管道流
|-- 是字节流的子类
|-- 管道流需要进行连接
|-- 读取管道流和写出管道流分别用不同的线程去控制
|-- 读取流会等待希写出管道流，不会引发线程死锁，不会抛出读取异常
3 打印流-- 只操作数据目的，不操作数据源
|-- PrintStream 字节流
|-- File对象
|-- 字节输出流
|-- 字符串
|-- PrintWriter 字符流
|-- File对象
|-- 字节输出流
|-- 字符串
|-- 字符输出流
|-- 使用打印流的自动刷新
|-- 构造方法，ture
|-- printf() println() format()
|-- 在做JAVAEE开发时，服务端程序，将数据写回到客户端，用的就是PrintWriter
|-- 这个流不需要你创建，已经建好了 Tomcat服务程序运行，直接拿这个对象用就OK了
|-- PrintWriter out = response.getWriter();
|-- out.print();
4 键盘读取流
|-- static InputStream System.in
|-- read()方法一次读一个不行，台麻烦
|-- BufferedReader中的readLine方法读取一行内容
在这总结下流的操作规律
操作规律：
●操作文本文件
|--选择字符流 Reader 和 Writer 体系
|--需要高效 使用 BufferedReader 和 BufferedWriter
●非文本文件
|--选择字节流 InputStream 和 OutputStream 体系
|--需要高效 BufferedInputStream 和 BufferedOutputStream
|--操作文件类型不确定时
|--用字节流
|--操作数据的来源
●硬盘文本文件
|--Reader 和 Writer 体系
|--需要高效 BufferedReader 和 BufferedWriter
●用户控制台
|--字节输入流 InputStream
|--方便于操作 使用 InputStreamReader
|--需要高效 BufferedInputStream
|--操作数据的目的
|--硬目的盘文本文件
●Writer
|--高效 BufferedWriter
|--硬盘文件不确定
|--字节输出流 OutputStream
|--高效 BufferedOutputStream
●目的控制台
|--字节数出流 OutputStream
|--方便于操作 OutputStreamWriter
|--高效 BufferedOutputStream
总结：
1 文本文件 用字符流
2 不确定用字节流
3 高效用缓冲技术
4 控制台用转换流
534
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
