Java笔记(22)：IO流(04)

Posted 2020-09-22 花醉红尘

1、登录注册案例IO版实现

在笔记17中的登录注册代码中，只需要修改注册登录的实现类

 1 package cn.itcast.dao.impl;
 2 
 3 import java.io.BufferedReader;
 4 import java.io.BufferedWriter;
 5 import java.io.File;
 6 import java.io.FileNotFoundException;
 7 import java.io.FileReader;
 8 import java.io.FileWriter;
 9 import java.io.IOException;
10 
11 import cn.itcast.dao.UserDao;
12 import cn.itcast.pojo.User;
13 
14 /**
15  * 这是用户操作的具体实现类(IO版)
16  * 
17  * @author 风清扬
18  * @version V1.1
19  * 
20  */
21 public class UserDaoImpl implements UserDao {
22     // 为了保证文件一加载就创建
23     private static File file = new File("user.txt");
24 
25     static {
26         try {
27             file.createNewFile();
28         } catch (IOException e) {
29             System.out.println("创建文件失败");
30             // e.printStackTrace();
31         }
32     }
33 
34     @Override
35     public boolean isLogin(String username, String password) {
36         boolean flag = false;
37 
38         BufferedReader br = null;
39         try {
40             // br = new BufferedReader(new FileReader("user.txt"));
41             br = new BufferedReader(new FileReader(file));
42             String line = null;
43             while ((line = br.readLine()) != null) {
44                 // 用户名=密码
45                 String[] datas = line.split("=");
46                 if (datas[0].equals(username) && datas[1].equals(password)) {
47                     flag = true;
48                     break;
49                 }
50             }
51         } catch (FileNotFoundException e) {
52             System.out.println("用户登录找不到信息所在的文件");
53             // e.printStackTrace();
54         } catch (IOException e) {
55             System.out.println("用户登录失败");
56             // e.printStackTrace();
57         } finally {
58             if (br != null) {
59                 try {
60                     br.close();
61                 } catch (IOException e) {
62                     System.out.println("用户登录释放资源失败");
63                     // e.printStackTrace();
64                 }
65             }
66         }
67 
68         return flag;
69     }
70 
71     @Override
72     public void regist(User user) {
73         /*
74          * 为了让注册的数据能够有一定的规则，我就自己定义了一个规则： 用户名=密码
75          */
76         BufferedWriter bw = null;
77         try {
78             // bw = new BufferedWriter(new FileWriter("user.txt"));
79             // bw = new BufferedWriter(new FileWriter(file));
80             // 为了保证数据是追加写入，必须加true
81             bw = new BufferedWriter(new FileWriter(file, true));
82             bw.write(user.getUsername() + "=" + user.getPassword());
83             bw.newLine();
84             bw.flush();
85         } catch (IOException e) {
86             System.out.println("用户注册失败");
87             // e.printStackTrace();
88         } finally {
89             if (bw != null) {
90                 try {
91                     bw.close();
92                 } catch (IOException e) {
93                     System.out.println("用户注册释放资源失败");
94                     // e.printStackTrace();
95                 }
96             }
97         }
98     }
99 }

2、数据输入输出流的概述和讲解

 1 package cn.itcast_01;
 2 
 3 import java.io.DataInputStream;
 4 import java.io.DataOutputStream;
 5 import java.io.FileInputStream;
 6 import java.io.FileOutputStream;
 7 import java.io.IOException;
 8 
 9 /*
10  * 可以读写基本数据类型的数据
11  * 数据输入流：DataInputStream
12  *             DataInputStream(InputStream in)
13  * 数据输出流：DataOutputStream
14  *             DataOutputStream(OutputStream out) 
15  */
16 public class DataStreamDemo {
17     public static void main(String[] args) throws IOException {
18         // 写
19         // write();
20 
21         // 读
22         read();
23     }
24 
25     private static void read() throws IOException {
26         // DataInputStream(InputStream in)
27         // 创建数据输入流对象
28         DataInputStream dis = new DataInputStream(
29                 new FileInputStream("dos.txt"));
30 
31         // 读数据
32         byte b = dis.readByte();
33         short s = dis.readShort();
34         int i = dis.readInt();
35         long l = dis.readLong();
36         float f = dis.readFloat();
37         double d = dis.readDouble();
38         char c = dis.readChar();
39         boolean bb = dis.readBoolean();
40 
41         // 释放资源
42         dis.close();
43 
44         System.out.println(b);
45         System.out.println(s);
46         System.out.println(i);
47         System.out.println(l);
48         System.out.println(f);
49         System.out.println(d);
50         System.out.println(c);
51         System.out.println(bb);
52     }
53 
54     private static void write() throws IOException {
55         // DataOutputStream(OutputStream out)
56         // 创建数据输出流对象
57         DataOutputStream dos = new DataOutputStream(new FileOutputStream(
58                 "dos.txt"));
59 
60         // 写数据了
61         dos.writeByte(10);
62         dos.writeShort(100);
63         dos.writeInt(1000);
64         dos.writeLong(10000);
65         dos.writeFloat(12.34F);
66         dos.writeDouble(12.56);
67         dos.writeChar(‘a‘);
68         dos.writeBoolean(true);
69 
70         // 释放资源
71         dos.close();
72     }
73 }

3、内存操作流的概述和讲解

 1 package cn.itcast_02;
 2 
 3 import java.io.ByteArrayInputStream;
 4 import java.io.ByteArrayOutputStream;
 5 import java.io.IOException;
 6 
 7 /*
 8  * 内存操作流：用于处理临时存储信息的，程序结束，数据就从内存中消失。
 9  * 字节数组：
10  *         ByteArrayInputStream
11  *         ByteArrayOutputStream
12  * 字符数组：
13  *         CharArrayReader
14  *         CharArrayWriter
15  * 字符串：
16  *         StringReader
17  *         StringWriter
18  */
19 public class ByteArrayStreamDemo {
20     public static void main(String[] args) throws IOException {
21         // 写数据
22         // ByteArrayOutputStream()
23         ByteArrayOutputStream baos = new ByteArrayOutputStream();
24 
25         // 写数据
26         for (int x = 0; x < 10; x++) {
27             baos.write(("hello" + x).getBytes());
28         }
29 
30         // 释放资源
31         // 通过查看源码我们知道这里什么都没做，所以根本需要close()
32         // baos.close();
33 
34         // public byte[] toByteArray()
35         byte[] bys = baos.toByteArray();
36 
37         // 读数据
38         // ByteArrayInputStream(byte[] buf)
39         ByteArrayInputStream bais = new ByteArrayInputStream(bys);
40 
41         int by = 0;
42         while ((by = bais.read()) != -1) {
43             System.out.print((char) by);
44         }
45 
46         // bais.close();
47     }
48 }

4、打印流概述和PrintWriter作为Writer的子类使用

 1 package cn.itcast_03;
 2 
 3 import java.io.IOException;
 4 import java.io.PrintWriter;
 5 
 6 /*
 7  * 打印流
 8  * 字节流打印流    PrintStream
 9  * 字符打印流    PrintWriter
10  * 
11  * 打印流的特点：
12  *         A:只有写数据的，没有读取数据。只能操作目的地，不能操作数据源。
13  *         B:可以操作任意类型的数据。
14  *         C:如果启动了自动刷新，能够自动刷新。
15  *         D:该流是可以直接操作文本文件的。
16  *             哪些流对象是可以直接操作文本文件的呢?
17  *             FileInputStream
18  *             FileOutputStream
19  *             FileReader
20  *             FileWriter
21  *             PrintStream
22  *             PrintWriter
23  *             看API,查流对象的构造方法，如果同时有File类型和String类型的参数，一般来说就是可以直接操作文件的。
24  * 
25  *             流：
26  *                 基本流：就是能够直接读写文件的
27  *                 高级流：在基本流基础上提供了一些其他的功能
28  */
29 public class PrintWriterDemo {
30     public static void main(String[] args) throws IOException {
31         // 作为Writer的子类使用
32         PrintWriter pw = new PrintWriter("pw.txt");
33 
34         pw.write("hello");
35         pw.write("world");
36         pw.write("java");
37         
38         pw.close();
39     }
40 }

5、PrintWriter实现自动刷新和换行

 1 package cn.itcast_03;
 2 
 3 import java.io.FileWriter;
 4 import java.io.IOException;
 5 import java.io.PrintWriter;
 6 
 7 /*
 8  * 1:可以操作任意类型的数据。
 9  *         print()
10  *         println()
11  * 2:启动自动刷新
12  *         PrintWriter pw = new PrintWriter(new FileWriter("pw2.txt"), true);
13  *         还是应该调用println()的方法才可以
14  *         这个时候不仅仅自动刷新了，还实现了数据的换行。
15  * 
16  *         println()
17  *        其实等价于于：
18  *        bw.write();
19  *        bw.newLine();        
20  *        bw.flush();
21  */
22 public class PrintWriterDemo2 {
23     public static void main(String[] args) throws IOException {
24         // 创建打印流对象
25         // PrintWriter pw = new PrintWriter("pw2.txt");
26         PrintWriter pw = new PrintWriter(new FileWriter("pw2.txt"), true);
27 
28         // write()是搞不定的，怎么办呢?
29         // 我们就应该看看它的新方法
30         // pw.print(true);
31         // pw.print(100);
32         // pw.print("hello");
33 
34         pw.println("hello");
35         pw.println(true);
36         pw.println(100);
37 
38         pw.close();
39     }
40 }

练习：打印流改进复制文本文件案例

 1 package cn.itcast_03;
 2 
 3 import java.io.BufferedReader;
 4 import java.io.BufferedWriter;
 5 import java.io.FileReader;
 6 import java.io.FileWriter;
 7 import java.io.IOException;
 8 import java.io.PrintWriter;
 9 
10 /*
11  * 需求：DataStreamDemo.java复制到Copy.java中
12  * 数据源：
13  *         DataStreamDemo.java -- 读取数据 -- FileReader -- BufferedReader
14  * 目的地：
15  *         Copy.java -- 写出数据 -- FileWriter -- BufferedWriter -- PrintWriter
16  */
17 public class CopyFileDemo {
18     public static void main(String[] args) throws IOException {
19         // 以前的版本
20         // 封装数据源
21         // BufferedReader br = new BufferedReader(new FileReader(
22         // "DataStreamDemo.java"));
23         // // 封装目的地
24         // BufferedWriter bw = new BufferedWriter(new FileWriter("Copy.java"));
25         //
26         // String line = null;
27         // while ((line = br.readLine()) != null) {
28         // bw.write(line);
29         // bw.newLine();
30         // bw.flush();
31         // }
32         //
33         // bw.close();
34         // br.close();
35 
36         // 打印流的改进版
37         // 封装数据源
38         BufferedReader br = new BufferedReader(new FileReader(
39                 "DataStreamDemo.java"));
40         // 封装目的地
41         PrintWriter pw = new PrintWriter(new FileWriter("Copy.java"), true);
42         
43         String line = null;
44         while((line=br.readLine())!=null){
45             pw.println(line);
46         }
47         
48         pw.close();
49         br.close();
50     }
51 }

 6、随机访问流概述和写出数据

 1 package cn.itcast_05;
 2 
 3 import java.io.IOException;
 4 import java.io.RandomAccessFile;
 5 
 6 /*
 7  * 随机访问流：
 8  *         RandomAccessFile类不属于流，是Object类的子类。
 9  *         但它融合了InputStream和OutputStream的功能。
10  *         支持对文件的随机访问读取和写入。
11  * 
12  * public RandomAccessFile(String name,String mode)：第一个参数是文件路径，第二个参数是操作文件的模式。
13  *         模式有四种，我们最常用的一种叫"rw",这种方式表示我既可以写数据，也可以读取数据 
14  */
15 public class RandomAccessFileDemo {
16     public static void main(String[] args) throws IOException {
17         // write();
18         read();
19     }
20 
21     private static void read() throws IOException {
22         // 创建随机访问流对象
23         RandomAccessFile raf = new RandomAccessFile("raf.txt", "rw");
24 
25         int i = raf.readInt();
26         System.out.println(i);
27         // 该文件指针可以通过 getFilePointer方法读取，并通过 seek 方法设置。
28         System.out.println("当前文件的指针位置是：" + raf.getFilePointer());
29 
30         char ch = raf.readChar();
31         System.out.println(ch);
32         System.out.println("当前文件的指针位置是：" + raf.getFilePointer());
33 
34         String s = raf.readUTF();
35         System.out.println(s);
36         System.out.println("当前文件的指针位置是：" + raf.getFilePointer());
37 
38         // 我不想重头开始了，我就要读取a，怎么办呢?
39         raf.seek(4);
40         ch = raf.readChar();
41         System.out.println(ch);
42     }
43 
44     private static void write() throws IOException {
45         // 创建随机访问流对象
46         RandomAccessFile raf = new RandomAccessFile("raf.txt", "rw");
47 
48         // 怎么玩呢?
49         raf.writeInt(100);
50         raf.writeChar(‘a‘);
51         raf.writeUTF("中国");
52 
53         raf.close();
54     }
55 }

7、合并流读取两个文件的内容复制到一个文件中

 1 package cn.itcast_06;
 2 
 3 import java.io.BufferedOutputStream;
 4 import java.io.FileInputStream;
 5 import java.io.FileOutputStream;
 6 import java.io.IOException;
 7 import java.io.InputStream;
 8 import java.io.SequenceInputStream;
 9 
10 /*
11  * 以前的操作：
12  * a.txt -- b.txt
13  * c.txt -- d.txt
14  * 
15  * 现在想要：
16  * a.txt+b.txt -- c.txt
17  */
18 public class SequenceInputStreamDemo {
19     public static void main(String[] args) throws IOException {
20         // SequenceInputStream(InputStream s1, InputStream s2)
21         // 需求：把ByteArrayStreamDemo.java和DataStreamDemo.java的内容复制到Copy.java中
22         InputStream s1 = new FileInputStream("ByteArrayStreamDemo.java");
23         InputStream s2 = new FileInputStream("DataStreamDemo.java");
24         SequenceInputStream sis = new SequenceInputStream(s1, s2);
25         BufferedOutputStream bos = new BufferedOutputStream(
26                 new FileOutputStream("Copy.java"));
27 
28         // 如何写读写呢，其实很简单，你就按照以前怎么读写，现在还是怎么读写
29         byte[] bys = new byte[1024];
30         int len = 0;
31         while ((len = sis.read(bys)) != -1) {
32             bos.write(bys, 0, len);
33         }
34 
35         bos.close();
36         sis.close();
37     }
38 }

8、合并流读取多个文件的内容复制到一个文件中

 1 package cn.itcast_06;
 2 
 3 import java.io.BufferedOutputStream;
 4 import java.io.FileInputStream;
 5 import java.io.FileOutputStream;
 6 import java.io.IOException;
 7 import java.io.InputStream;
 8 import java.io.SequenceInputStream;
 9 import java.util.Enumeration;
10 import java.util.Vector;
11 
12 /*
13  * 以前的操作：
14  * a.txt -- b.txt
15  * c.txt -- d.txt
16  * e.txt -- f.txt
17  * 
18  * 现在想要：
19  * a.txt+b.txt+c.txt -- d.txt
20  */
21 public class SequenceInputStreamDemo2 {
22     public static void main(String[] args) throws IOException {
23         // 需求：把下面的三个文件的内容复制到Copy.java中
24         // ByteArrayStreamDemo.java,CopyFileDemo.java,DataStreamDemo.java
25 
26         // SequenceInputStream(Enumeration e)
27         // 通过简单的回顾我们知道了Enumeration是Vector中的一个方法的返回值类型。
28         // Enumeration<E> elements()
29         Vector<InputStream> v = new Vector<InputStream>();
30         InputStream s1 = new FileInputStream("ByteArrayStreamDemo.java");
31         InputStream s2 = new FileInputStream("CopyFileDemo.java");
32         InputStream s3 = new FileInputStream("DataStreamDemo.java");
33         v.add(s1);
34         v.add(s2);
35         v.add(s3);
36         Enumeration<InputStream> en = v.elements();
37         SequenceInputStream sis = new SequenceInputStream(en);
38         BufferedOutputStream bos = new BufferedOutputStream(
39                 new FileOutputStream("Copy.java"));
40 
41         // 如何写读写呢，其实很简单，你就按照以前怎么读写，现在还是怎么读写
42         byte[] bys = new byte[1024];
43         int len = 0;
44         while ((len = sis.read(bys)) != -1) {
45             bos.write(bys, 0, len);
46         }
47 
48         bos.close();
49         sis.close();
50     }
51 }

9、序列化流和反序列化流的概述和使用

 1 package cn.itcast_07;
 2 
 3 import java.io.Serializable;
 4 
 5 /*
 6  * NotSerializableException:未序列化异常
 7  * 
 8  * 类通过实现 java.io.Serializable 接口以启用其序列化功能。未实现此接口的类将无法使其任何状态序列化或反序列化。
 9  * 该接口居然没有任何方法，类似于这种没有方法的接口被称为标记接口。
10  * 
11  * java.io.InvalidClassException: 
12  * cn.itcast_07.Person; local class incompatible: 
13  * stream classdesc serialVersionUID = -2071565876962058344, 
14  * local class serialVersionUID = -8345153069362641443
15  * 
16  * 为什么会有问题呢?
17  *         Person类实现了序列化接口，那么它本身也应该有一个标记值。
18  *         这个标记值假设是100。
19  *         开始的时候：
20  *         Person.class -- id=100
21  *         wirte数据： oos.txt -- id=100
22  *         read数据: oos.txt -- id=100    
23  * 
24  *         现在：
25  *         Person.class -- id=200
26  *         wirte数据： oos.txt -- id=100
27  *         read数据: oos.txt -- id=100
28  * 我们在实际开发中，可能还需要使用以前写过的数据，不能重新写入。怎么办呢?
29  * 回想一下原因是因为它们的id值不匹配。
30  * 每次修改java文件的内容的时候,class文件的id值都会发生改变。
31  * 而读取文件的时候，会和class文件中的id值进行匹配。所以，就会出问题。
32  * 但是呢，如果我有办法，让这个id值在java文件中是一个固定的值，这样，你修改文件的时候，这个id值还会发生改变吗?
33  * 不会。现在的关键是我如何能够知道这个id值如何表示的呢?
34  * 不用担心，你不用记住，也没关系，点击鼠标即可。
35  * 你难道没有看到黄色警告线吗?
36  * 
37  * 我们要知道的是：
38  *         看到类实现了序列化接口的时候，要想解决黄色警告线问题，就可以自动产生一个序列化id值。
39  *         而且产生这个值以后，我们对类进行任何改动，它读取以前的数据是没有问题的。
40  * 
41  * 注意：
42  *         我一个类中可能有很多的成员变量，有些我不想进行序列化。请问该怎么办呢?
43  *         使用transient关键字声明不需要序列化的成员变量
44  */
45 public class Person implements Serializable {
46     private static final long serialVersionUID = -2071565876962058344L;
47 
48     private String name;
49 
50     // private int age;
51 
52     private transient int age;
53 
54     // int age;
55 
56     public Person() {
57         super();
58     }
59 
60     public Person(String name, int age) {
61         super();
62         this.name = name;
63         this.age = age;
64     }
65 
66     public String getName() {
67         return name;
68     }
69 
70     public void setName(String name) {
71         this.name = name;
72     }
73 
74     public int getAge() {
75         return age;
76     }
77 
78     public void setAge(int age) {
79         this.age = age;
80     }
81 
82     @Override
83     public String toString() {
84         return "Person [name=" + name + ", age=" + age + "]";
85     }
86 }

 1 package cn.itcast_07;
 2 
 3 import java.io.FileInputStream;
 4 import java.io.FileOutputStream;
 5 import java.io.IOException;
 6 import java.io.ObjectInputStream;
 7 import java.io.ObjectOutputStream;
 8 
 9 /*
10  * 序列化流：把对象按照流一样的方式存入文本文件或者在网络中传输。对象 -- 流数据(ObjectOutputStream)
11  * 反序列化流:把文本文件中的流对象数据或者网络中的流对象数据还原成对象。流数据 -- 对象(ObjectInputStream)
12  */
13 public class ObjectStreamDemo {
14     public static void main(String[] args) throws IOException,
15             ClassNotFoundException {
16         // 由于我们要对对象进行序列化，所以我们先自定义一个类
17         // 序列化数据其实就是把对象写到文本文件
18         // write();
19 
20         read();
21     }
22 
23     private static void read() throws IOException, ClassNotFoundException {
24         // 创建反序列化对象
25         ObjectInputStream ois = new ObjectInputStream(new FileInputStream(
26                 "oos.txt"));
27 
28         // 还原对象
29         Object obj = ois.readObject();
30 
31         // 释放资源
32         ois.close();
33 
34         // 输出对象
35         System.out.println(obj);
36     }
37 
38     private static void write() throws IOException {
39         // 创建序列化流对象
40         ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(
41                 "oos.txt"));
42 
43         // 创建对象
44         Person p = new Person("林青霞", 27);
45 
46         // public final void writeObject(Object obj)
47         oos.writeObject(p);
48 
49         // 释放资源
50         oos.close();
51     }
52 }

10、Properties的概述和作为Map集合的使用

 1 package cn.itcast_08;
 2 
 3 import java.util.Properties;
 4 import java.util.Set;
 5 
 6 /*
 7  * Properties:属性集合类。是一个可以和IO流相结合使用的集合类。
 8  * Properties 可保存在流中或从流中加载。属性列表中每个键及其对应值都是一个字符串。 
 9  * 
10  * 是Hashtable的子类，说明是一个Map集合。
11  */
12 public class PropertiesDemo {
13     public static void main(String[] args) {
14         // 作为Map集合的使用
15         // 下面这种用法是错误的，一定要看API，如果没有<>，就说明该类不是一个泛型类,在使用的时候就不能加泛型
16         // Properties<String, String> prop = new Properties<String, String>();
17 
18         Properties prop = new Properties();
19 
20         // 添加元素
21         prop.put("it002", "hello");
22         prop.put("it001", "world");
23         prop.put("it003", "java");
24 
25         // System.out.println("prop:" + prop);
26 
27         // 遍历集合
28         Set<Object> set = prop.keySet();
29         for (Object key : set) {
30             Object value = prop.get(key);
31             System.out.println(key + "---" + value);
32         }
33     }
34 }

11、Properties的load()和store()功能

 1 package cn.itcast_08;
 2 
 3 import java.util.Properties;
 4 import java.util.Set;
 5 
 6 /*
 7  * 特殊功能：
 8  * public Object setProperty(String key,String value)：添加元素
 9  * public String getProperty(String key):获取元素
10  * public Set<String> stringPropertyNames():获取所有的键的集合
11  */
12 public class PropertiesDemo2 {
13     public static void main(String[] args) {
14         // 创建集合对象
15         Properties prop = new Properties();
16 
17         // 添加元素
18         prop.setProperty("张三", "30");
19         prop.setProperty("李四", "40");
20         prop.setProperty("王五", "50");
21 
22         // public Set<String> stringPropertyNames():获取所有的键的集合
23         Set<String> set = prop.stringPropertyNames();
24         for (String key : set) {
25             String value = prop.getProperty(key);
26             System.out.println(key + "---" + value);
27         }
28     }
29 }
30 
31 /*
32  * class Hashtalbe<K,V> { public V put(K key,V value) { ... } }
33  * 
34  * class Properties extends Hashtable { public V setProperty(String key,String
35  * value) { return put(key,value); } }
36  */

12、Properties的load()和store()功能

 1 package cn.itcast_08;
 2 
 3 import java.io.FileReader;
 4 import java.io.FileWriter;
 5 import java.io.IOException;
 6 import java.io.Reader;
 7 import java.io.Writer;
 8 import java.util.Properties;
 9 
10 /*
11  * 这里的集合必须是Properties集合：
12  * public void load(Reader reader):把文件中的数据读取到集合中
13  * public void store(Writer writer,String comments):把集合中的数据存储到文件
14  * 
15  * 单机版游戏：
16  *         进度保存和加载。
17  *         三国群英传，三国志，仙剑奇侠传...
18  * 
19  *         吕布=1
20  *         方天画戟=1
21  */
22 public class PropertiesDemo3 {
23     public static void main(String[] args) throws IOException {
24         // myLoad();
25 
26         myStore();
27     }
28 
29     private static void myStore() throws IOException {
30         // 创建集合对象
31         Properties prop = new Properties();
32 
33         prop.setProperty("林青霞", "27");
34         prop.setProperty("武鑫", "30");
35         prop.setProperty("刘晓曲", "18");
36         
37         //public void store(Writer writer,String comments):把集合中的数据存储到文件
38         Writer w = new FileWriter("name.txt");
39         prop.store(w, "helloworld");
40         w.close();
41     }
42 
43     private static void myLoad() throws IOException {
44         Properties prop = new Properties();
45 
46         // public void load(Reader reader):把文件中的数据读取到集合中
47         // 注意：这个文件的数据必须是键值对形式
48         Reader r = new FileReader("prop.txt");
49         prop.load(r);
50         r.close();
51 
52         System.out.println("prop:" + prop);
53     }
54 }

练习：判断文件中是否有指定的键如果有就修改值的案例

 1 package cn.itcast_08;
 2 
 3 import java.io.FileReader;
 4 import java.io.FileWriter;
 5 import java.io.IOException;
 6 import java.io.Reader;
 7 import java.io.Writer;
 8 import java.util.Properties;
 9 import java.util.Set;
10 
11 /*
12  * 我有一个文本文件(user.txt)，我知道数据是键值对形式的，但是不知道内容是什么。
13  * 请写一个程序判断是否有“lisi”这样的键存在，如果有就改变其实为”100”
14  * 
15  * 分析：
16  *         A:把文件中的数据加载到集合中
17  *         B:遍历集合，获取得到每一个键
18  *         C:判断键是否有为"lisi"的，如果有就修改其值为"100"
19  *         D:把集合中的数据重新存储到文件中
20  */
21 public class PropertiesTest {
22     public static void main(String[] args) throws IOException {
23         // 把文件中的数据加载到集合中
24         Properties prop = new Properties();
25         Reader r = new FileReader("user.txt");
26         prop.load(r);
27         r.close();
28 
29         // 遍历集合，获取得到每一个键
30         Set<String> set = prop.stringPropertyNames();
31         for (String key : set) {
32             // 判断键是否有为"lisi"的，如果有就修改其值为"100"
33             if ("lisi".equals(key)) {
34                 prop.setProperty(key, "100");
35                 break;
36             }
37         }
38 
39         // 把集合中的数据重新存储到文件中
40         Writer w = new FileWriter("user.txt");
41         prop.store(w, null);
42         w.close();
43     }
44 }

练习：如何让猜数字小游戏只能玩5次案例

 1 package cn.itcast_08;
 2 
 3 import java.util.Scanner;
 4 
 5 /**
 6  * 这是猜数字小游戏
 7  * 
 8  * @author 风清扬
 9  * @version V1.1
10  * 
11  */
12 public class GuessNumber {
13     private GuessNumber() {
14     }
15 
16     public static void start() {
17         // 产生一个随机数
18         int number = (int) (Math.random() * 100) + 1;
19 
20         // 定义一个统计变量
21         int count = 0;
22 
23         while (true) {
24             // 键盘录入一个数据
25             Scanner sc = new Scanner(System.in);
26             System.out.println("请输入数据(1-100)：");
27             int guessNumber = sc.nextInt();
28 
29             count++;
30 
31             // 判断
32             if (guessNumber > number) {
33                 System.out.println("你猜的数据" + guessNumber + "大了");
34             } else if (guessNumber < number) {
35                 System.out.println("你猜的数据" + guessNumber + "小了");
36             } else {
37                 System.out.println("恭喜你，" + count + "次就猜中了");
38                 break;
39             }
40         }
41     }
42 }

13、NIO的介绍和JDK7下NIO的一个案例

 1 package cn.itcast_09;
 2 
 3 import java.io.IOException;
 4 import java.nio.charset.Charset;
 5 import java.nio.file.Files;
 6 import java.nio.file.Paths;
 7 import java.util.ArrayList;
 8 
 9 /*
10  * nio包在JDK4出现，提供了IO流的操作效率。但是目前还不是大范围的使用。
11  * 有空的话了解下，有问题再问我。
12  * 
13  * JDK7的之后的nio：
14  * Path:路径
15  * Paths:有一个静态方法返回一个路径
16  *         public static Path get(URI uri)
17  * Files:提供了静态方法供我们使用
18  *         public static long copy(Path source,OutputStream out):复制文件
19  *         public static Path write(Path path,Iterable<? extends CharSequence> lines,Charset cs,OpenOption... options)
20  */
21 public class NIODemo {
22     public static void main(String[] args) throws IOException {
23         // public static long copy(Path source,OutputStream out)
24         // Files.copy(Paths.get("ByteArrayStreamDemo.java"), new
25         // FileOutputStream(
26         // "Copy.java"));
27 
28         ArrayList<String> array = new ArrayList<String>();
29         array.add("hello");
30         array.add("world");
31         array.add("java");
32         Files.write(Paths.get("array.txt"), array, Charset.forName("GBK"));
33     }
34 }

--品尝过的失落 消化成温暖情歌 等着你伤心时候点播