用户注册登录IO版本:
1 public class UserDaoImpl implements UserDao { 2 // 为了保证文件一加载就创建 3 private static File file = new File("user.txt"); 4 5 static { 6 try { 7 file.createNewFile(); 8 } catch (IOException e) { 9 System.out.println("创建文件失败"); 10 // e.printStackTrace(); 11 } 12 } 13 14 @Override 15 public boolean isLogin(String username, String password) { 16 boolean flag = false; 17 18 BufferedReader br = null; 19 try { 20 // br = new BufferedReader(new FileReader("user.txt")); 21 br = new BufferedReader(new FileReader(file)); 22 String line = null; 23 while ((line = br.readLine()) != null) { 24 // 用户名=密码 25 String[] datas = line.split("="); 26 if (datas[0].equals(username) && datas[1].equals(password)) { 27 flag = true; 28 break; 29 } 30 } 31 } catch (FileNotFoundException e) { 32 System.out.println("用户登录找不到信息所在的文件"); 33 // e.printStackTrace(); 34 } catch (IOException e) { 35 System.out.println("用户登录失败"); 36 // e.printStackTrace(); 37 } finally { 38 if (br != null) { 39 try { 40 br.close(); 41 } catch (IOException e) { 42 System.out.println("用户登录释放资源失败"); 43 // e.printStackTrace(); 44 } 45 } 46 } 47 48 return flag; 49 } 50 51 @Override 52 public void regist(User user) { 53 /* 54 * 为了让注册的数据能够有一定的规则，我就自己定义了一个规则： 用户名=密码 55 */ 56 BufferedWriter bw = null; 57 try { 58 // bw = new BufferedWriter(new FileWriter("user.txt")); 59 // bw = new BufferedWriter(new FileWriter(file)); 60 // 为了保证数据是追加写入，必须加true 61 bw = new BufferedWriter(new FileWriter(file, true)); 62 bw.write(user.getUsername() + "=" + user.getPassword()); 63 bw.newLine(); 64 bw.flush(); 65 } catch (IOException e) { 66 System.out.println("用户注册失败"); 67 // e.printStackTrace(); 68 } finally { 69 if (bw != null) { 70 try { 71 bw.close(); 72 } catch (IOException e) { 73 System.out.println("用户注册释放资源失败"); 74 // e.printStackTrace(); 75 } 76 } 77 } 78 } 79 }
* 打印流
* 字节流打印流 PrintStream
* 字符打印流 PrintWriter
*
* 打印流的特点：
* A:只有写数据的，没有读取数据。只能操作目的地，不能操作数据源。
* B:可以操作任意类型的数据。
* C:如果启动了自动刷新，能够自动刷新。
* D:该流是可以直接操作文本文件的。
* 哪些流对象是可以直接操作文本文件的呢?
* FileInputStream
* FileOutputStream
* FileReader
* FileWriter
* PrintStream
* PrintWriter
* 看API,查流对象的构造方法，如果同时有File类型和String类型的参数，一般来说就是可以直接操作文件的。
*
* 流：
* 基本流：就是能够直接读写文件的
* 高级流：在基本流基础上提供了一些其他的功能
1 // 作为Writer的子类使用 2 PrintWriter pw = new PrintWriter("pw3.txt"); 3 4 pw.write("hello"); 5 pw.flush(); 6 pw.write("world"); 7 pw.flush(); 8 pw.write("java"); 9 pw.flush(); 10 11 pw.close();
* 1:可以操作任意类型的数据。
* print()
* println()
* 2:启动自动刷新
* PrintWriter pw = new PrintWriter(new FileWriter("pw2.txt"), true);
* 还是应该调用println()的方法才可以
* 这个时候不仅仅自动刷新了，还实现了数据的换行。
*
* println()
* 其实等价于于：
* bw.write();
* bw.newLine();
* bw.flush();
1 // 创建打印流对象 2 // PrintWriter pw = new PrintWriter("pw2.txt"); 3 PrintWriter pw = new PrintWriter(new FileWriter("pw2.txt"), true); 4 5 // write()是搞不定的，怎么办呢? 6 // 我们就应该看看它的新方法 7 // pw.print(true); 8 // pw.print(100); 9 // pw.print("hello"); 10 11 pw.println("hello"); 12 pw.println(true); 13 pw.println(100); 14 15 pw.close();
* 需求：DataStreamDemo.java复制到Copy.java中
* 数据源：
* DataStreamDemo.java -- 读取数据 -- FileReader -- BufferedReader
* 目的地：
* Copy.java -- 写出数据 -- FileWriter -- BufferedWriter -- PrintWriter
1 // 打印流的改进版 2 // 封装数据源 3 BufferedReader br = new BufferedReader(new FileReader( 4 "DataStreamDemo.java")); 5 // 封装目的地 6 PrintWriter pw = new PrintWriter(new FileWriter("Copy.java"), true); 7 8 String line = null; 9 while((line=br.readLine())!=null){ 10 pw.println(line); 11 } 12 13 pw.close(); 14 br.close();
* System.in 标准输入流。是从键盘获取数据的
*
* 键盘录入数据：
* A:main方法的args接收参数。
* java HelloWorld hello world java
* B:Scanner(JDK5以后的)
* Scanner sc = new Scanner(System.in);
* String s = sc.nextLine();
* int x = sc.nextInt()
* C:通过字符缓冲流包装标准输入流实现
* BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
*/
1 BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); 2 3 System.out.println("请输入一个字符串："); 4 String line = br.readLine(); 5 System.out.println("你输入的字符串是：" + line); 6 7 System.out.println("请输入一个整数："); 8 // int i = Integer.parseInt(br.readLine()); 9 line = br.readLine(); 10 int i = Integer.parseInt(line); 11 System.out.println("你输入的整数是：" + i);
* 标准输入输出流
* System类中的两个成员变量：
* public static final InputStream in “标准”输入流。
* public static final PrintStream out “标准”输出流。
*
* InputStream is = System.in;
* PrintStream ps = System.out;
1 // 有这里的讲解我们就知道了，这个输出语句其本质是IO流操作，把数据输出到控制台。 2 System.out.println("helloworld"); 3 4 // 获取标准输出流对象 5 PrintStream ps = System.out; 6 ps.println("helloworld"); 7 8 ps.println(); 9 // ps.print();//这个方法不存在 10 11 // System.out.println(); 12 // System.out.print();
// 获取标准输入流
// // PrintStream ps = System.out;
// // OutputStream os = ps;
// OutputStream os = System.out; // 多态
// // 我能不能按照刚才使用标准输入流的方式一样把数据输出到控制台呢?
// OutputStreamWriter osw = new OutputStreamWriter(os);
// BufferedWriter bw = new BufferedWriter(osw);
1 BufferedWriter bw = new BufferedWriter(new OutputStreamWriter( 2 System.out)); 3 4 bw.write("hello"); 5 bw.newLine(); 6 // bw.flush(); 7 bw.write("world"); 8 bw.newLine(); 9 // bw.flush(); 10 bw.write("java"); 11 bw.newLine(); 12 bw.flush(); 13 14 bw.close();
* 序列化流：把对象按照流一样的方式存入文本文件或者在网络中传输。对象 -- 流数据(ObjectOutputStream)
* 反序列化流:把文本文件中的流对象数据或者网络中的流对象数据还原成对象。流数据 -- 对象(ObjectInputStream)
1 private static void read() throws IOException, ClassNotFoundException { 2 // 创建反序列化对象 3 ObjectInputStream ois = new ObjectInputStream(new FileInputStream( 4 "oos.txt")); 5 6 // 还原对象 7 Object obj = ois.readObject(); 8 9 // 释放资源 10 ois.close(); 11 12 // 输出对象 13 System.out.println(obj); 14 } 15 16 private static void write() throws IOException { 17 // 创建序列化流对象 18 ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream( 19 "oos.txt")); 20 21 // 创建对象 22 Person p = new Person("林青霞", 27); 23 24 // public final void writeObject(Object obj) 25 oos.writeObject(p); 26 27 // 释放资源 28 oos.close(); 29 }
* NotSerializableException:未序列化异常
*
* 类通过实现 java.io.Serializable 接口以启用其序列化功能。未实现此接口的类将无法使其任何状态序列化或反序列化。
* 该接口居然没有任何方法，类似于这种没有方法的接口被称为标记接口。
*
* java.io.InvalidClassException:
* cn.itcast_07.Person; local class incompatible:
* stream classdesc serialVersionUID = -2071565876962058344,
* local class serialVersionUID = -8345153069362641443
*
* 为什么会有问题呢?
* Person类实现了序列化接口，那么它本身也应该有一个标记值。
* 这个标记值假设是100。
* 开始的时候：
* Person.class -- id=100
* wirte数据： oos.txt -- id=100
* read数据: oos.txt -- id=100
*
* 现在：
* Person.class -- id=200
* wirte数据： oos.txt -- id=100
* read数据: oos.txt -- id=100
* 我们在实际开发中，可能还需要使用以前写过的数据，不能重新写入。怎么办呢?
* 回想一下原因是因为它们的id值不匹配。
* 每次修改java文件的内容的时候,class文件的id值都会发生改变。
* 而读取文件的时候，会和class文件中的id值进行匹配。所以，就会出问题。
* 但是呢，如果我有办法，让这个id值在java文件中是一个固定的值，这样，你修改文件的时候，这个id值还会发生改变吗?
* 不会。现在的关键是我如何能够知道这个id值如何表示的呢?
* 不用担心，你不用记住，也没关系，点击鼠标即可。
* 你难道没有看到黄色警告线吗?
*
* 我们要知道的是：
* 看到类实现了序列化接口的时候，要想解决黄色警告线问题，就可以自动产生一个序列化id值。
* 而且产生这个值以后，我们对类进行任何改动，它读取以前的数据是没有问题的。
*
* 注意：
* 我一个类中可能有很多的成员变量，有些我不想进行序列化。请问该怎么办呢?
* 使用transient关键字声明不需要序列化的成员变量
private static final long serialVersionUID = -2071565876962058344L;
private transient int age;
* Properties:属性集合类。是一个可以和IO流相结合使用的集合类。
* Properties 可保存在流中或从流中加载。属性列表中每个键及其对应值都是一个字符串。
*
* 是Hashtable的子类，说明是一个Map集合。
* 特殊功能：
* public Object setProperty(String key,String value)：添加元素
* public String getProperty(String key):获取元素
* public Set<String> stringPropertyNames():获取所有的键的集合
1 // 创建集合对象 2 Properties prop = new Properties(); 3 4 // 添加元素 5 prop.setProperty("张三", "30"); 6 prop.setProperty("李四", "40"); 7 prop.setProperty("王五", "50"); 8 9 // public Set<String> stringPropertyNames():获取所有的键的集合 10 Set<String> set = prop.stringPropertyNames(); 11 for (String key : set) { 12 String value = prop.getProperty(key); 13 System.out.println(key + "---" + value); 14 }
* 这里的集合必须是Properties集合：
* public void load(Reader reader):把文件中的数据读取到集合中
* public void store(Writer writer,String comments):把集合中的数据存储到文件
1 private static void myStore() throws IOException { 2 // 创建集合对象 3 Properties prop = new Properties(); 4 5 prop.setProperty("林青霞", "27"); 6 prop.setProperty("武鑫", "30"); 7 prop.setProperty("刘晓曲", "18"); 8 9 //public void store(Writer writer,String comments):把集合中的数据存储到文件 10 Writer w = new FileWriter("name.txt"); 11 prop.store(w, "helloworld"); 12 w.close(); 13 } 14 15 private static void myLoad() throws IOException { 16 Properties prop = new Properties(); 17 18 // public void load(Reader reader):把文件中的数据读取到集合中 19 // 注意：这个文件的数据必须是键值对形式 20 Reader r = new FileReader("prop.txt"); 21 prop.load(r); 22 r.close(); 23 24 System.out.println("prop:" + prop); 25 }
* nio包在JDK4出现，提供了IO流的操作效率。但是目前还不是大范围的使用。
* 有空的话了解下，有问题再问我。
*
* JDK7的之后的nio：
* Path:路径
* Paths:有一个静态方法返回一个路径
* public static Path get(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)
1 // public static long copy(Path source,OutputStream out) 2 // Files.copy(Paths.get("ByteArrayStreamDemo.java"), new 3 // FileOutputStream( 4 // "Copy.java")); 5 6 ArrayList<String> array = new ArrayList<String>(); 7 array.add("hello"); 8 array.add("world"); 9 array.add("java"); 10 Files.write(Paths.get("array.txt"), array, Charset.forName("GBK"));