[关闭]
@w460461339 2016-11-15T23:08:41.000000Z 字数 11596 阅读 1060

Java学习Day11 （登陆注册案例 以及超级多的流）

Java基础

今天学习了超级多的流以及用IO的方法重写了一下login&Regist的任务，发现还是挺多问题的。
下面一一介绍

1、LogIn&Regist

需求分析：
A：可以实现注册功能，并将用户存储至本地文件，下次仍可调用
B：实现注册功能，重名用户显示注册失败
C：实现登陆功能，用户名，密码均一致显示成功，否则显示失败

分包：
A：用户类包
|---用于构建用户类，以便今后调用来创建用户对象，存储存储用户信息。
B：用户功能接口包
|---定义可以针对用户类的功能接口，描述可以对用户类进行的操作。
C：用户功能实现包
|---实现对用户类的功能。
D：测试包
|---添加测试程序。

1.1用户类包
  1. package lr_User;
  2. //这个很简单，不解释了
  3. public class User {
  4.     private String accout;
  5.     private String password;
  6.     public User() {
  7.         super();
  8.         // TODO Auto-generated constructor stub
  9.     }
  10.     public User(String accout, String password) {
  11.         super();
  12.         this.accout = accout;
  13.         this.password = password;
  14.     }
  15.     public String getAccout() {
  16.         return accout;
  17.     }
  18.     public void setAccout(String accout) {
  19.         this.accout = accout;
  20.     }
  21.     public String getPassword() {
  22.         return password;
  23.     }
  24.     public void setPassword(String password) {
  25.         this.password = password;
  26.     }
  27.     @Override
  28.     public String toString() {
  29.         return "User [accout=" + accout + ", password=" + password + "]";
  30.     }
  31. }
1.2用户功能接口包
  1. package lr_function;
  3. import lr_User.User;
  4.     //定义方法的名称，参数类型，访问属性等。但不包含具体实现
  5. public interface  User_function {
  6.     //登陆方法，成功返回true，失败返回false
  7.     public abstract boolean login(String account,String password);
  9.     //注册方法，成功返回true，失败返回false
  10.     public abstract boolean regist(User myuser);
  11. }
1.3用户功能实现包
  1. package lr_function_impl;
  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;
  11. import lr_User.User;
  12. import lr_function.User_function;
  14. public class User_funciton_impl implements User_function{
  16.     private static File file=new File("account.txt");
  17.     //静态代码块，在调用该类的时候仅且运行一次。用来创建存储数据的文件。
  18.     static{
  19.         try {
  20.             if(!file.exists()){
  21.                 file.createNewFile();
  22.             }   
  23.         } catch (IOException e) {
  24.             System.out.println("内存不足，初始文件失败");
  25.             //e.printStackTrace();
  26.         }
  27.     }
  28.     //实现登陆方法
  29.     @Override
  30.     public boolean login(String account, String password) {
  31.         boolean flag=false;
  32.         try {
  33.             //按行得到account.txt中的数据
  34.             BufferedReader br=new BufferedReader(
  35.                                     new FileReader("account.txt"));
  36.             String line=null;
  37.             while((line=br.readLine())!=null){
  38.             //以“=“为分割标志将数据分割
  39.                 String[] acc_pass=line.split("=");
  40.             //比较用户名和账户
  41.     if(acc_pass[0].equals(account)&&acc_pass[1].equals(password)){
  42.                     System.out.println("登陆成功");
  43.                     flag=true;
  44.                 }
  45.             }
  46.         } catch (FileNotFoundException e) {
  47.             // TODO Auto-generated catch block
  48.             System.out.println("文件不存在");
  49.             //e.printStackTrace();
  50.         } catch (IOException e) {
  51.             // TODO Auto-generated catch block
  52.             System.out.println("登录失败");
  53.             //e.printStackTrace();
  54.         }
  55.         return flag;
  56.     }
  58.     @SuppressWarnings("finally")
  59.     @Override
  60.     public boolean regist(User myuser) {
  61.         boolean flag=false;
  62.         BufferedWriter bw=null;
  63.         BufferedReader br=null;
  66.         try {
  67.         //判断用户名是否重复
  68.             br=new BufferedReader(new FileReader("account.txt"));
  69.             String line = null;
  70.             while((line=br.readLine())!=null){
  71.                 String[] acc_pass=line.split("=");
  72.                 if(acc_pass[0].equals(myuser.getAccout())){
  73.                     System.out.println("用户名重复");
  74.                     return flag=false;
  75.                 }
  76.             }
  77.         } catch (IOException e1) {
  78.             // TODO Auto-generated catch block
  79.             System.out.println("IOException");
  80.             //e1.printStackTrace();
  81.         }
  83.     try {
  84.         //写入新的用户
  85.         br=new BufferedReader(new FileReader("account.txt"));
  86.         bw=new BufferedWriter(new FileWriter("account.txt",true));
  87.         bw.write(myuser.getAccout()+"="+myuser.getPassword());
  88.         bw.newLine();
  89.         bw.flush();
  90.         System.out.println("注册成功");
  91.         flag=true;
  92.     } catch (IOException e) {
  93.             // TODO Auto-generated catch block
  94.             System.out.println("注册失败");
  95.             flag=false;
  96.             //e.printStackTrace();
  97.     }finally{
  98.         if(bw!=null){
  99.                 try {
  100.                     bw.close();
  101.                 } catch (final IOException e) {
  102.                 System.out.println("释放资源失败");
  103.                 //e.printStackTrace();
  104.                     }
  105.             }
  106.             return flag;
  107.         }
  108.     }
  109. }
1.4测试包
  1. package lr_test;
  3. import java.util.Scanner;
  5. import lr_User.User;
  6. import lr_function_impl.User_funciton_impl;
  8. public class LogRegTest {
  10.     /**
  11.      * @param args
  12.      */
  13.     public static void main(String[] args) {
  14.         User_funciton_impl usefun=new User_funciton_impl();
  15.         Scanner sc=new Scanner(System.in);
  16.         String account=null;
  17.         String password=null;
  18.         for(int i=1;i<6;i++){
  19.             account=sc.nextLine();
  20.             password=sc.nextLine();
  21.             User myuser=new User(account,password);
  22.             usefun.regist(myuser);  
  23.         }
  25.         boolean flag=false;
  26.         do{
  27.             account=sc.nextLine();
  28.             password=sc.nextLine();
  29.             flag=usefun.login(account, password);
  30.             if(!flag){
  31.                 System.out.println("用户名或者密码不对");
  32.             }
  33.         }while(!flag);
  34.     }
  35. }

2.数据操作流(操作基本类型数据的流)(理解)

(1)可以操作基本类型的数据
八种基本数据类型，int，byte，long，char，short，double，float，boolean
(2)流对象名称
DataInputStream
DataOutputStream

  1. package trynewStream;
  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;
  9. public class DataStreamDemo {
  11.     public static void main(String[] args) throws IOException {
  12.         //注意，只能直接操作8种基本数据类型，String之类的就不行了。
  13.         //仅有读写配对才能顺利读写，不然报错
  14.         DataOutputStream dos=new DataOutputStream(
  15.                         new FileOutputStream("datademo.txt"));
  16.         DataInputStream dis=new DataInputStream(
  17.                         new FileInputStream("datademo.txt"));
  18.         //写的时候写int
  19.         dos.writeInt(10);
  20.         dos.close();
  21.         //读的时候就要用int读
  22.         System.out.println(dis.readInt());
  23.         dis.close();
  24.     }
  25. }

3.内存操作流(理解)

(1)有些时候我们操作完毕后，未必需要产生一个文件，就可以使用内存操作流。意思就是说把产生的东西丢到内存中，然后从内存中拿出来。多用于临时文件存储。
(2)三种
字节数组： A:ByteArrayInputStream,ByteArrayOutputStream
字符数组： B:CharArrayReader,CharArrayWriter
字符串 ： C:StringReader,StringWriter
就演示下字符数组的好了= - 不好玩= - 

  1. package trynewStream;
  3. import java.io.CharArrayReader;
  4. import java.io.CharArrayWriter;
  5. import java.io.IOException;
  7. public class CharArrayReaderDemo {
  9.     public static void main(String[] args)throws IOException {
  10.         // TODO Auto-generated method stub
  11.         CharArrayWriter caw=new CharArrayWriter();
  12.         char[] ca={97,98,99,100};
  13.         char[] ca2=new char[4];
  14.         caw.write(ca);
  15.         CharArrayReader car=new CharArrayReader(ca);
  16.         car.read(ca2);
  17.         System.out.println(ca2);
  18.     }
  19. }

4:打印流(掌握)

(1)字节打印流，字符打印流
PrintStream,PritnWriter
(2)特点：
A:只操作目的地,不操作数据源
B:可以操作任意类型的数据
C:如果启用了自动刷新，在调用println()方法的时候，能够换行并刷新
D:可以直接操作文件
问题：哪些流可以直接操作文件呢?
看API，如果其构造方法能够同时接收File和String类型的参数，一般都是可以直接操作文件的
(3)复制文本文件

  1. package trynewStream;
  3. import java.io.BufferedReader;
  4. import java.io.File;
  5. import java.io.FileOutputStream;
  6. import java.io.FileReader;
  7. import java.io.IOException;
  8. import java.io.PrintStream;
  10. public class PrintDemo {
  12.     public static void main(String[] args)throws IOException {
  13.         //封装数据源
  14.         BufferedReader br=new BufferedReader(
  15.                                 new FileReader("account.txt"));
  16.         //封装目的地
  17.         PrintStream ps=new PrintStream(new FileOutputStream(
  18.                                 new File("copy.txt")),true);
  19.         String line=null;
  20.         while((line=br.readLine())!=null){
  21.             ps.println(line);//直接完成写入，换行，刷新三个动作
  22.         }
  23.         br.close();
  24.         ps.close();
  25.     }
  26. }

5.标准输入输出流(理解)

其实就这么理解，标准输入流使用BufferedWriter实现的，标准输出流使用PrintSteram实现的。
(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:原理

  1.             System.out.println("helloworld");
  2.             PrintStream ps = System.out;
  3.             ps.println("helloworld");
    B:把System.out用字符缓冲流包装一下使用

  1.             BufferedWriter bw = new BufferedWriter(
  2.                             new OutputStreamWriter(System.out));

6随机访问流(理解)

(1)可以按照文件指针的位置写数据和读数据。
RandomAccessFile();这货可读可写啊~~
(2)案例：
A:写数据
B:读数据
C:获取和改变文件指针的位置

  1. package trynewStream;
  3. import java.io.File;
  4. import java.io.IOException;
  5. import java.io.RandomAccessFile;
  7. public class RandomStreamDemo {
  8.     public static void main(String[] args) throws IOException{
  9.         RandomAccessFile raf=new RandomAccessFile(new File("account.txt"), "rw");
  10.         System.out.println(raf.readLine()+
  11.                                        "---"+raf.getFilePointer());
  12.         System.out.println(raf.readLine()+
  13.                                        "---"+raf.getFilePointer());
  14.         System.out.println(raf.readLine()+
  15.                                        "---"+raf.getFilePointer());
  16.         //文件指针重新指到18的位置上，再次读取后，最后一行又被读了
  17.         raf.seek(18);
  18.         System.out.println(raf.readLine()+
  19.                                        "---"+raf.getFilePointer());
  20.     }
  21. }

7.合并流(理解)

(1)把多个输入流的数据写到一个输出流中。
(2)构造方法：
A:SequenceInputStream(InputStream s1, InputStream s2)
B:SequenceInputStream(Enumeration e)

  1. import java.io.BufferedOutputStream;
  2. import java.io.File;
  3. import java.io.FileInputStream;
  4. import java.io.FileOutputStream;
  5. import java.io.IOException;
  6. import java.io.SequenceInputStream;
  8. public class SequenceStreamDemo {
  9.     public static void main(String[] args)throws IOException {
  10.         //封装数据源
  11.         SequenceInputStream sis=new SequenceInputStream(
  12.             new FileInputStream("account.txt"),
  13.             new FileInputStream("datademo.txt"));
  14.         //封装目的地
  15.         BufferedOutputStream bos=new BufferedOutputStream(
  16.             new FileOutputStream(new File("copy2.txt")));
  17.         //复制
  18.         byte[] bys=new byte[1024];
  19.         int len=0;
  20.         while((len=sis.read(bys))!=-1){
  21.             bos.write(bys, 0, len);
  22.         }
  23.         //释放资源，关闭
  24.         sis.close();
  25.         bos.close();
  26.     }
  27. }

写不动了，抄了一遍代码,这个说白了就是用vector存储所有要复制的流，然后一起输出。

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

8.序列化流(理解)

主要目的就是直接往流中添加对象
(1)可以把对象写入文本文件或者在网络中传输
(2)如何实现序列化呢?
让被序列化的对象所属类实现序列化接口。
该接口是一个标记接口。没有功能需要实现。
(3)注意问题：
把数据写到文件后，在去修改类会产生一个问题。
如何解决该问题呢?
在类文件中，给出一个固定的序列化id值。
而且，这样也可以解决黄色警告线问题
(4)面试题：
什么时候序列化?
如何实现序列化?
什么是反序列化?

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

10.NIO(了解)

(1)JDK4出现的NIO，对以前的IO操作进行了优化，提供了效率。但是大部分我们看到的还是以前的IO
(2)JDK7的NIO的使用
Path:路径
Paths:通过静态方法返回一个路径
Files:提供了常见的功能
复制文本文件
把集合中的数据写到文本文件

写不动了…睡觉= -

添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注