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 }
--品尝过的失落 消化成温暖情歌 等着你伤心时候点播
时间： 2024-10-27 06:48:40