首页 > 代码库 > Java笔记(22)：IO流(04)
Java笔记(22)：IO流(04)
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 =http://www.mamicode.com/ 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 =http://www.mamicode.com/ 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 }
--品尝过的失落 消化成温暖情歌 等着你伤心时候点播
Java笔记(22)：IO流(04)
声明：以上内容来自用户投稿及互联网公开渠道收集整理发布，本网站不拥有所有权，未作人工编辑处理，也不承担相关法律责任，若内容有误或涉及侵权可进行投诉： 投诉/举报 工作人员会在5个工作日内联系你，一经查实，本站将立刻删除涉嫌侵权内容。