------------------------------------day22 总结--------------------------------------
1:登录注册IO版本案例(掌握)
要求，对着写一遍。
cn.itcast.pojo User
cn.itcast.dao UserDao
cn.itcast.dao.impl UserDaoImpl(实现我不管)
cn.itcast.game GuessNumber
cn.itcast.test UserTest
2:数据操作流(操作基本类型数据的流)(理解)
(1)可以操作基本类型的数据
(2)流对象名称
DataInputStream
DataOutputStream
3:内存操作流(理解)
(1)有些时候我们操作完毕后，未必需要产生一个文件，就可以使用内存操作流。
(2)三种
A:ByteArrayInputStream,ByteArrayOutputStream
B:CharArrayReader,CharArrayWriter
C:StringReader,StringWriter
4:打印流(掌握)
(1)字节打印流，字符打印流
(2)特点：
A:只操作目的地,不操作数据源
B:可以操作任意类型的数据
C:如果启用了自动刷新，在调用println()方法的时候，能够换行并刷新
D:可以直接操作文件
问题：哪些流可以直接操作文件呢?
看API，如果其构造方法能够同时接收File和String类型的参数，一般都是可以直接操作文件的
(3)复制文本文件
BufferedReader br = new BufferedReader(new FileReader(“a.txt”));
PrintWriter pw = new PrintWriter(new FileWriter(“b.txt”),true);
String line = null;
while((line=br.readLine())!=null) {
pw.println(line);
}
pw.close();
br.close();
5:标准输入输出流(理解)
(1)System类下面有这样的两个字段
in 标准输入流
out 标准输出流
(2)三种键盘录入方式
A:main方法的args接收参数
B:System.in通过BufferedReader进行包装
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
C:Scanner
Scanner sc = new Scanner(System.in);
(3)输出语句的原理和如何使用字符流输出数据
A:原理
System.out.println(“helloworld”);
PrintStream ps = System.out;
ps.println("helloworld");
B:把System.out用字符缓冲流包装一下使用
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
6:随机访问流(理解)
(1)可以按照文件指针的位置写数据和读数据。
(2)案例：
A:写数据
B:读数据
C:获取和改变文件指针的位置
7:合并流(理解)
(1)把多个输入流的数据写到一个输出流中。
(2)构造方法：
A:SequenceInputStream(InputStream s1, InputStream s2)
B:SequenceInputStream(Enumeration<? extends InputStream> e)
8:序列化流(理解)
(1)可以把对象写入文本文件或者在网络中传输
(2)如何实现序列化呢?
让被序列化的对象所属类实现序列化接口。
该接口是一个标记接口。没有功能需要实现。
(3)注意问题：
把数据写到文件后，在去修改类会产生一个问题。
如何解决该问题呢?
在类文件中，给出一个固定的序列化id值。
而且，这样也可以解决黄色警告线问题
(4)面试题：
什么时候序列化?
如何实现序列化?
什么是反序列化?
9:Properties(理解)
(1)是一个集合类，Hashtable的子类
(2)特有功能
A:public Object setProperty(String key,String value)
B:public String getProperty(String key)
C:public Set stringPropertyNames()
(3)和IO流结合的方法
把键值对形式的文本文件内容加载到集合中
public void load(Reader reader)
public void load(InputStream inStream)
把集合中的数据存储到文本文件中
public void store(Writer writer,String comments)
public void store(OutputStream out,String comments)
(4)案例：
A:根据给定的文件判断是否有键为"lisi"的，如果有就修改其值为100
B:写一个程序实现控制猜数字小游戏程序不能玩超过5次
10:NIO(了解)
(1)JDK4出现的NIO，对以前的IO操作进行了优化，提供了效率。但是大部分我们看到的还是以前的IO
(2)JDK7的NIO的使用
Path:路径
Paths:通过静态方法返回一个路径
Files:提供了常见的功能
复制文本文件
把集合中的数据写到文本文件
----------------------------------知识点1-------------------------------------
package cn.itcast_01;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/*
-
DataInputStream:
-
DataInputStream(InputStream in)使用指定的底层 InputStream 创建一个 DataInputStream。DataOutputStream:
DataOutputStream(OutputStream out)创建一个新的数据输出流，将数据写入指定基础输出流。 -
*/
public class DateStreamDemo {
public static void main(String[] args) throws IOException {
// 写
//write();// 读 read();}
private static void read() throws IOException{
// DataInputStream(InputStream in)使用指定的底层 InputStream 创建一个 DataInputStream。
DataInputStream dis = new DataInputStream(new FileInputStream(“dos.txt”));// 读取数据 /* * 注意错误点：不能采用字节流普通的读取方法，一次读取一个字节数组 * 应该采用与写入数据对应的readInt(),readByte()方法读取数据 * */ // int len =0; // byte [] bys = new byte [1024]; // while((len=dis.read(bys)) !=-1){ // System.out.println(new String(bys,0,len)); // } // 读取数据 int x = dis.readInt(); byte b = dis.readByte(); char c = dis.readChar(); float f = dis.readFloat(); double d = dis.readDouble(); // 释放资源 dis.close(); System.out.println(x); System.out.println(b); System.out.println(c); System.out.println(f); System.out.println(d);}
private static void write() throws IOException{
// DataOutputStream(OutputStream out)
// 创建数据输出流对象
DataOutputStream dos = new DataOutputStream(new FileOutputStream(“dos.txt”));// 写入数据 dos.writeInt(10); dos.writeByte(1); dos.writeChar('a'); dos.writeFloat(12.243F); dos.writeDouble(12.345); dos.writeBoolean(true); // 释放资源 dos.close();}
}
----------------------------------知识点2-------------------------------------
package cn.itcast_02;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
/*
-
内存操作流：用于处理临时存储信息的，程序结束，数据就从内存中消失
-
操作字节数组
ByteArrayInputStream
ByteArrayOutputStream
操作字符数组
CharArrayReader
CharArrayWrite
操作字符串
StringReader
StringWriter -
*/
public class ByteArrayStreamDemo {
public static void main(String[] args) throws IOException {
// 写数据
// ByteArrayOutputStream()
ByteArrayOutputStream baos= new ByteArrayOutputStream();// 创建字节数组 for(int x=0;x<10;x++){ baos.write(("我爱中国"+x).getBytes()); //baos.write("\n\r"); } // 释放资源 // 通过源码，我们发现里面为空，故无意义 // baos.close(); // public byte[] toByteArray() byte [] bys = baos.toByteArray(); // 读数据 // ByteArrayInputStream(byte[] buf) ByteArrayInputStream bais = new ByteArrayInputStream(bys); // 一次读一个字节数组 // int len =0; // byte [] by = new byte [1024]; // while((len=bais.read(by)) !=-1){ // System.out.print(new String(by,0,len)); // } // 一次读一个字节 /* * 1.含有汉字的数据，不能一次读取一个字节的方法进行读取， * 因为一个汉字是由两个字节存储。 * 2.且不能使用字节流，得使用字符流，因为字节流以一个字节为单位，汉字以两个字节为单位 * 可能会出现最后一个汉字，只有一个字节，另一字节丢失。 * * */ int by = 0; while((by=bais.read()) !=-1){ System.out.print((char)by); } // 释放资源 //bais.close();}
}
----------------------------------知识点3-------------------------------------
package cn.itcast_03;
import java.io.IOException;
import java.io.PrintWriter;
/*
-
打印流：
-
字节打印流 PrintStream
-
字符打印流 PrintWriter
-
打印流的特点：
-
1.只有写数据，没有读数据，只能操作目的地，不能操作数据源 -
2.可以操作任意类型的数据 -
3.如果启动了自动刷新，能够自动刷新 -
4.该流是可以直接操作文本文件 -
可以直接操作文件的流： -
FileInputStream -
FileOutputStream -
FileReader -
FileWriter -
PrintStream -
PrintWriter -
流： -
基本流：就是能够直接读写文件 -
高级流：在基本流的基础上提供了一些其他的功能 -
*/
public class PrintWriterDemo {
public static void main(String[] args) throws IOException {
// 作为Writer的子类使用
PrintWriter pw = new PrintWriter(“bw.txt”);pw.write("hello"); pw.write("world"); pw.write("java"); pw.flush(); pw.close(); //BufferedWriter bw = new BufferedWriter(new FileWriter("bw.txt")); //bw.write("hello"); //bw.write("world"); //bw.flush();}
}
----------------------------------知识点4-------------------------------------
package cn.itcast_03;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.PrintWriter;
/*
*
-
1.可以操作任意数据
-
print() -
println() -
2.启动自动刷新
-
PrintWriter pw = new PrintWriter(new FileWriter("bw2.txt"),true); -
还是应该调用println()的方法才可以 -
println() -
其实等价于： -
bw.write(); -
bw.newLine(); -
bw.flush; -
*/
public class PrintWriterDemo2 {
public static void main(String[] args) throws IOException {
// PrintWriter pw = new PrintWriter(“bw2.txt”);
PrintWriter pw = new PrintWriter(new FileOutputStream(“bw2.txt”),true);
pw.println(“hello”);
pw.print(true);
pw.print(‘a’);
pw.print(12.23);
pw.print(12);// powwe // BufferedWriter bw = new BufferedWriter(new FileWriter("test.txt")); // bw.write(120); // bw.flush(); // bw.close();}
}
----------------------------------知识点5-------------------------------------
package cn.itcast_03;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
/*
-
需求：DataStreamDemo.java复制Copy.java中
-
分析：
-
数据源：
-
DataStreamDemo.java--读数据--FileReader--BufferedReader -
目的地：
-
Copy.java--写数据--FileWriter--BufferedWriter--PrintWriter -
*/
public class PrintWriterDemo3 {
public static void main(String[] args) throws IOException{
// 创建字符输入流
BufferedReader br = new BufferedReader(new FileReader(“DataStreamDemo.java”));// 创建字符输出流 PrintWriter pw = new PrintWriter(new FileWriter("Copy.java"),true); // 读取数据 String line = null; while((line=br.readLine())!=null){ pw.println(line); } // 释放资源 br.close();}
}
----------------------------------知识点6-------------------------------------
package cn.itcast_04;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
/*
-
System.in 标准输入流。是从键盘获取数据的
-
键盘录入数据：
-
1.main方法的args接收参数。 -
java HelloWorld hello world java -
2.Scanner(JDK5以后) -
Scanner sc = new Scanner(System.in); -
3.通过字符缓冲流包装标准输入流实现 -
BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); -
*/
public class SystemInDemo {
public static void main(String[] args) throws IOException{
// 获取标准输入流
// InputStream is = System.in;
// InputStreamReader isr = new InputStreamReader(is);
// BufferedReader br = new BufferedReader(isr);// 简化写法
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));System.out.println(“请输入一个字符串：”);
String s = br.readLine();
System.out.println(“你输入的数据是：”+s);System.out.println(“请输入一个整数：”);
int i = Integer.parseInt(br.readLine());
System.out.println(“你输入的整数是：”+i);}
}
----------------------------------知识点7-------------------------------------
package cn.itcast_04;
import java.io.PrintStream;
/*System类中的两个成员变量
-
标准输入流
-
public static final InputStream in -
标准输出流：
-
public static final PrintStream out -
InputStream is =System.in;
-
PrintStream ps = System.out;
-
*/
public class SystemOutDemo {
public static void main(String[] args) {
// 输出语句的本质是IO流输出到控制台
System.out.println(“hello world”);PrintStream ps = System.out; ps.println("hello world"); ps.println(); // ps.print(); // System.out.println(); // System.out.print(); // System.out.print(); // System.out.print();}
}
----------------------------------知识点8-------------------------------------
package cn.itcast_04;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.PrintStream;
/*
-
需求:实现将标准输出流，输出到控制台
-
*/
public class SystemOutDemo2 {
public static void main(String[] args) throws IOException {
PrintStream ps = System.out;// 将标准是的输出打印字节流，转换为字符流 OutputStreamWriter osw = new OutputStreamWriter(ps); BufferedWriter bw = new BufferedWriter(osw); //写入数据 bw.write("hello"); bw.newLine(); bw.write("world"); bw.newLine(); bw.write("java"); bw.flush(); // 释放资源 bw.close();}
}
----------------------------------知识点9-------------------------------------
package cn.itcast_05;
import java.io.IOException;
import java.io.RandomAccessFile;
/*
-
RandomAccessFile类不属于流，是Object类的子类。
-
但它融合了InputStream和OutputStream的功能。
-
支持对随机访问文件的读取和写入
-
public RandomAccessFile(String name, String mode)：第一个参数是文件的路径，第二个参数是操作文件的模式
-
模式有4种，但是我们常用的有是"rw",表示可以写数据，也可以读数据。 -
*/
public class RandomAccessFileDemo {
public static void main(String[] args) throws IOException {
// 写数据
//write();//读数据 read();}
private static void read() throws IOException{
RandomAccessFile raf = new RandomAccessFile(“raf.txt”, “rw”);
// 读取数据
// 该文件指针可以通过 getFilePointer 方法读取，
// 并通过 seek 方法设置。int i = raf.readInt(); System.out.println(i); System.out.println("文件指针的位置是："+raf.getFilePointer()); String s = raf.readUTF(); System.out.println(s); System.out.println("文件指针的位置是："+raf.getFilePointer()); boolean b = raf.readBoolean(); System.out.println(b); System.out.println("文件指针的位置是："+raf.getFilePointer()); char c = raf.readChar(); System.out.println(c); System.out.println("文件指针的位置是："+raf.getFilePointer()); String cs = raf.readLine(); System.out.println(cs); System.out.println("文件指针的位置是："+raf.getFilePointer()); // 设置文件指针位置 raf.seek(4); String s2 = raf.readUTF(); System.out.println(s2); System.out.println("文件指针的位置是："+raf.getFilePointer()); // 释放资源 raf.close();}
private static void write() throws IOException {
// 创建随机访问流
RandomAccessFile raf = new RandomAccessFile(“raf.txt”, “rw”);
/*
* 有问题的写法,该流没有flush()方法，需要释放资源，才能写入。
* 故要写方法
*
* */
// 写入数据
raf.writeInt(100);
raf.writeUTF(“中国”);
raf.writeBoolean(true);
raf.writeChar(‘c’);
raf.writeChars(“我爱”);// 释放资源 raf.close();}
}
----------------------------------知识点10-------------------------------------
package cn.itcast_06;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.SequenceInputStream;
/*
-
以前的操作：
-
a.txt–b.txt
-
c.txt–d.txt
-
新需求：
-
a.txt+b.txt – c.txt
-
*/
public class SequenceInputStreamDemo {
public static void main(String[] args) throws IOException{
// SequenceInputStream(InputStream s1, InputStream s2)
// 需求：将DataStreamDemo.java和RandomAccessFileDemo.java合并输出到Copy.java中
InputStream s1 = new FileInputStream(“DataStreamDemo.java”);
InputStream s2 = new FileInputStream(“RandomAccessFileDemo.java”);
SequenceInputStream sis=new SequenceInputStream(s1, s2);// 创建字节输出流 BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("Copy.java")); // 复制操作 int len =0; byte [] bys = new byte [1024]; while((len=sis.read(bys)) !=-1){ bos.write(bys,0,len); bos.flush(); } // 释放资源 s1.close(); s2.close(); bos.close();}
}
----------------------------------知识点11-------------------------------------
package cn.itcast_06;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.SequenceInputStream;
import java.util.Enumeration;
import java.util.Vector;
/*
-
以前的操作：
-
a.txt–b.txt
-
c.txt–d.txt
-
新需求：
-
a.txt+b.txt – c.txt
-
*/
public class SequenceInputStreamDemo2 {
public static void main(String[] args) throws IOException{
// 需求：把三个文件CopyFile.java，DataStreamDemo.java，RandomAccessFileDemo.java合并到Copy.java中// SequenceInputStream(Enumeration<? extends InputStream> e) Vector<InputStream> v = new Vector<InputStream>(); InputStream is1 =new FileInputStream("CopyFile.java"); InputStream is2 = new FileInputStream("DataStreamDemo.java"); InputStream is3 = new FileInputStream("RandomAccessFileDemo.java"); v.add(is1); v.add(is2); v.add(is3); Enumeration<InputStream> en = v.elements(); SequenceInputStream sis = new SequenceInputStream(en); // 复制操作 BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("Copy.java")); int len =0; byte [] bys = new byte[1024]; while((len=sis.read(bys)) !=-1){ bos.write(bys,0,len); } // 释放资源 sis.close(); bos.close();}
}
----------------------------------知识点12-------------------------------------
package cn.itcast_07;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
/*
-
序列化流：把对象按照流一样的方式存入文本文件或者网络中传输。对象–数据流（ObjectOutputStream）
-
反序列化流：把文本文件中的流对象数据或者网络中的流对象数据还原成对象。数据流–对象(ObjeceInputStream)
-
java.io.InvalidClassException: cn.itcast_07.Person;
-
local class incompatible: stream classdesc
-
serialVersionUID = -2071565876962058344,
-
local class serialVersionUID = -8345153069362641443
-
为什么会有问题呢？
-
Person类实现了序列化接口，那么它本身也应该有一个标记值。 -
这个时候标记值假设是100 -
开始的时候： -
Person.class -- id =100 -
write数据：oos.txt--id=100 -
resd数据：oos.txt --id=100 -
现在： -
Person.class -- id=200 -
write数据：oos.txt --id=100 -
read数据：oos.txt--id=100 -
在实际开发中，我们需要使用以前写过的数据，不能重新写入，怎么办呢
-
每次修改java文件的内容的时候，class文件的id不匹配，所以出现问题
-
而读取文件的时候，会和class文件中的id值进行匹配，所以就会出现问题
-
解决办法：
-
让这个id值固定，这样就不会出错。点击鼠标生成private static final long serialVersionUID = -2071565876962058344L; -
注意：
-
看到类实现了序列化接口的时候，要想解决黄色警告线的问题，可以自动产生一个序列化id值 -
而产生这个值后，我们对类进行任何的改动，它读取的以前的数据都是没问题的。 -
*/
public class ObjectStreamDemo {
public static void main(String[] args) throws IOException, ClassNotFoundException {
// 序列化数据，其实就是把对象写到文本文件
// 所以我们先定义一个类
// write();read();}
private static void read() throws IOException, ClassNotFoundException{
// 创建反序列化流对象
ObjectInputStream ois = new ObjectInputStream(new FileInputStream(“oos.txt”));// 读取数据 Object obj = ois.readObject(); // 释放资源 ois.close(); // 输出对象 System.out.println(obj);}
private static void write() throws IOException{
// 创建序列化流对象
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(“oos.txt”));// 创建对象 Person p = new Person("林青霞",23); //public final void writeObject(Object obj) oos.writeObject(p); // 释放资源 oos.close();}
}
----------------------------------知识点13-------------------------------------
package cn.itcast_07;
import java.io.Serializable;
/*
-
NotSerializableException:为序列化异常
-
通过实现java.io.Serializable 接口启用其序列化功能。未实现此接口的类将无法使其任何状态序列化或者反序列化
-
该接口没有任何方法，类似于这种没有方法的接口被称为标记接口。 -
注意：
-
当一个类中有很多成员变量，有些不需要进行序列化的，该怎么办 -
使用transient关键字声明不需要序列化的成员变量 -
*/
public class Person implements Serializable {
private static final long serialVersionUID = -2071565876962058344L;
private String name;
private transient int age;
public Person() {
super();
// TODO Auto-generated constructor stub
}
public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}@Override
public String toString() {
return “Person [name=” + name + “, age=” + age + “]”;
}
}
----------------------------------知识点14-------------------------------------
package cn.itcast_08;
import java.io.IOException;
import java.nio.charset.Charset;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.List;
/*
- nio包在JDK4出现，提供了IO流的操作效率。但是目前还不是大范围的使用。
- JDK7要了解的新IO类
Path:与平台无关的路径。
Paths:包含了返回Path的静态方法。
public static Path get(URI uri):根据给定的URI来确定文件路径。
Files:操作文件的工具类。提供了大量的方法，简单了解如下方法
public static long copy(Path source, OutputStream out) :复制文件
public static Path write(Path path, Iterable<? extends CharSequence> lines, Charset cs, OpenOption… options):
把集合的数据写到文件。 - */
public class NIODemo {
public static void main(String[] args) throws IOException {
// public static long copy(Path source, OutputStream out) :复制文件
// Files.copy(Paths.get(“DataStreamDemo.java”), new FileOutputStream(“Copy.java”));
//把集合中的数据写到文件
List<String> list = new ArrayList<String>();
list.add("hello");
list.add("world");
list.add("java");
Files.write(Paths.get("list.txt"), list, Charset.forName("gbk"));
}
}
----------------------------------知识点15-------------------------------------
package cn.itcast_08;
import java.util.Properties;
import java.util.Set;
/*
-
Properties:属性集合类。是一个可以和IO流结合使用的集合类
-
Properties：可保存在流中或者从流中加载。属性列表中每个键对应的值都是一个字符串。
-
是Hashtable的子类，说明是一个Map集合
-
*/
public class PropertiesDemo {
public static void main(String[] args) {
// 作为Map集合的使用
// 以下写法是错误的
//Properties<String ,String> prop = new Properties<String,String>();
Properties prop = new Properties();prop.put("it_001", "马云"); prop.put("it_002", "马化腾"); prop.put("it_003", "丁磊"); prop.put("it_004", "雷军"); // 遍历集合 Set<Object> set = prop.keySet(); for(Object key:set){ Object value = prop.get(key); System.out.println(key+"---"+value); } //System.out.println(prop);}
}
----------------------------------知识点16-------------------------------------
package cn.itcast_08;
import java.util.Properties;
import java.util.Set;
/*
-
Properties的特殊功能
public Object setProperty(String key,String value):添加元素
public String getProperty(String key)：获取元素
public Set stringPropertyNames()：获取所有键的集合 -
*/
public class PropertiesDemo2 {
public static void main(String[] args) {
// 创建集合对想
Properties prop = new Properties();// 添加元素 prop.setProperty("张三", "30"); prop.setProperty("李四", "40"); prop.setProperty("王五", "50"); // 获取元素 Set<String> set = prop.stringPropertyNames(); for(String key:set){ String value = prop.getProperty(key); System.out.println(key+"---"+value); } // System.out.println(prop);}
}
----------------------------------知识点17-------------------------------------
package cn.itcast_08;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Reader;
import java.io.Writer;
import java.util.HashMap;
import java.util.Properties;
/*
-
Properties和IO流的结合使用
public void load(Reader reader):把文件中的数据读取到集合中
public void store(Writer writer,String comments):把集合中的数据存储到文件单机游戏：
进度的保存和加载： -
*/
public class PropertiesDemo3 {
public static void main(String[] args) throws IOException {
// public void load(Reader reader):把文件中的数据读取到集合中
// 注意：这个文件的数据必须是键值对的形式// 创建集合 HashMap<String, String> map = new HashMap<String, String>(); // // 方法 1 笨方法 一次读取一行，在进行键和值的分隔 // BufferedReader br = new BufferedReader(new FileReader("prop.txt")); // // // 读取数据 // String line = null; // while((line=br.readLine()) !=null){ // String [] str = line.split("="); // String key = str[0]; // String value = str[1]; // // map.put(key, value); // } // // // 遍历输出集合 // Set<String> set = map.keySet(); // for(String key:set){ // String value = map.get(key); // System.out.println(key+"---"+value); // } // // // 释放资源 // br.close(); // myLoad(); myRead();}
private static void myRead() throws IOException {
// 创建集合对象
Properties prop = new Properties();
prop.put(“李白”, “29”);
prop.put(“杜甫”, “34”);
prop.put(“王安石”, “37”);Writer w = new FileWriter("prop2.txt"); prop.store(w, "helloworld"); // 释放资源 w.close();}
private static void myLoad() throws IOException{
// 方法2 采用Properties集合特殊方法
// 创建集合对象
Properties prop = new Properties();
Reader r = new FileReader(“prop.txt”);
prop.load®;
r.close();System.out.println("prop:"+prop);}
}
----------------------------------知识点18-------------------------------------
package cn.itcast_08;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Reader;
import java.io.Writer;
import java.util.Properties;
import java.util.Set;
/*
-
我有一个文件(user.txt),我知道数据是键值对形式的，但是不知道内容是什么
-
请写一个程序判断是否有“lisi”这样的键存在，如果有就改变其实为"100";
-
分析：
-
1.把文件中的数据加载到集合中 -
2.遍历集合，获取每个键 -
3.判断是否为“lisi”的，如果有就修改其值为"100" -
4.把集合中的数据重新存储到文件中 -
*/
public class PropertiesTest {
public static void main(String[] args) throws IOException {
// 把文件中的数据加载到集合中
Properties prop = new Properties();
Reader r = new FileReader(“user.txt”);
prop.load®;
r.close();// 遍历集合，获取每个键 Set<String> set = prop.stringPropertyNames(); for(String key:set){ if(key.equals("lisi")){ prop.setProperty(key, "100"); break; } } // 把集合中的数据重新存储到文件中 Writer w = new FileWriter("user.txt"); prop.store(w, null); w.close();}
}
----------------------------------知识点19-------------------------------------
package cn.itcast_08;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Reader;
import java.io.Writer;
import java.util.Properties;
import java.util.Set;
/*
-
我有一猜数字小游戏的程序，请写一个程序实现在测试类中只能用5次，超过5次提示：游戏试玩结束，请付费。
-
*/
public class PropertiesTest2 {
public static void main(String[] args) throws IOException {
// 读取某个地方的数据，如果次数不大于5，可以继续玩，否则就提示“游戏试玩已结束，请付费”
Integer count =1;// 创建存储文件 // File file =new File("count.txt"); // if(!file.exists()){ // file.createNewFile(); // } while(count<=5){ // 将数据写入集合,初始化 Properties prop = new Properties(); prop.put("count", count.toString()); // 将集合中的数据写入文件 Writer w = new FileWriter("count.txt"); prop.store(w, null); w.close(); GuessNumberGame.playGame(); count++; // 读取文件中的数据到集合 Reader r = new FileReader("count.txt"); prop.load(r); r.close(); // 遍历集合 Set<String> set =prop.stringPropertyNames(); for(String key:set){ if(key.equals("count")){ prop.setProperty(key, count.toString()); } } } System.out.println("游戏试玩结束，请付费！");}
}
----------------------------------知识点20-------------------------------------
package cn.itcast_08;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Reader;
import java.io.Writer;
import java.util.Properties;
import java.util.Set;
/*
-
我有一猜数字小游戏的程序，请写一个程序实现在测试类中只能用5次，超过5次提示：游戏试玩结束，请付费。
-
改进版：
-
上一个版本有bug了，只要重新执行一次程序又可以玩5次 -
*/
public class PropertiesTest3 {
public static void main(String[] args) throws IOException {
// 读取某个地方的数据，如果次数不大于5，可以继续玩，否则就提示“游戏试玩已结束，请付费”Properties prop = new Properties(); // 读取文件中的数据到集合 Reader r = new FileReader("count.txt"); prop.load(r); r.close(); // 遍历集合 String count =null; Set<String> set =prop.stringPropertyNames(); for(String key:set){ count =prop.getProperty(key); } int number = Integer.parseInt(count); while(number<5){ number++; prop.setProperty("count", String.valueOf(number)); Writer w = new FileWriter("count.txt"); prop.store(w, null); w.close(); GuessNumberGame.playGame(); } System.out.println("试玩结束，请付费！"); System.exit(0);}
}
130
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
