文档版本号 开发工具 測试平台 project名字 日期 作者 备注
V1.0 2016.03.24 lutianfei none

登录注冊IO版

  • 例如以下代码仅为UserDaoImpl类文件，其它原码參考day22_login_registproject
  1. public class UserDaoImpl implements UserDao {
  2.     // 为了保证文件一载入就创建
  3.     private static File file = new File("user.txt");
  5.     static {
  6.         try {
  7.             file.createNewFile();
  8.         } catch (IOException e) {
  9.             System.out.println("创建文件失败");
  10.             // e.printStackTrace();
  11.         }
  12.     }
  14.     @Override
  15.     public boolean isLogin(String username, String password) {
  16.         boolean flag = false;
  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.         }
  48.         return flag;
  49.     }
  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. }

操作基本数据类型的流

  • 能够读写基本数据类型的数据

    • 数据输入流：DataInputStream

      • DataInputStream(InputStream in)
    • 数据输出流：DataOutputStream
      • DataOutputStream(OutputStream out)
  1. public class DataStreamDemo {
  2.     public static void main(String[] args) throws IOException {
  3.         // 写
  4.         // write();
  6.         // 读
  7.         read();
  8.     }
  10.     private static void read() throws IOException {
  11.         // DataInputStream(InputStream in)
  12.         // 创建数据输入流对象
  13.         DataInputStream dis = new DataInputStream(
  14.                 new FileInputStream("dos.txt"));
  16.         // 读数据
  17.         byte b = dis.readByte();
  18.         short s = dis.readShort();
  19.         int i = dis.readInt();
  20.         long l = dis.readLong();
  21.         float f = dis.readFloat();
  22.         double d = dis.readDouble();
  23.         char c = dis.readChar();
  24.         boolean bb = dis.readBoolean();
  26.         // 释放资源
  27.         dis.close();
  29.         System.out.println(b);
  30.         System.out.println(s);
  31.         System.out.println(i);
  32.         System.out.println(l);
  33.         System.out.println(f);
  34.         System.out.println(d);
  35.         System.out.println(c);
  36.         System.out.println(bb);
  37.     }
  39.     private static void write() throws IOException {
  40.         // DataOutputStream(OutputStream out)
  41.         // 创建数据输出流对象
  42.         DataOutputStream dos = new DataOutputStream(new FileOutputStream(
  43.                 "dos.txt"));
  45.         // 写数据了
  46.         dos.writeByte(10);
  47.         dos.writeShort(100);
  48.         dos.writeInt(1000);
  49.         dos.writeLong(10000);
  50.         dos.writeFloat(12.34F);
  51.         dos.writeDouble(12.56);
  52.         dos.writeChar('a');
  53.         dos.writeBoolean(true);
  55.         // 释放资源
  56.         dos.close();
  57.     }
  58. }

内存操作流

  • 内存操作流一般用于处理暂时信息。由于暂时信息不须要保存，使用后就能够删除。

  • 使用完成后，不须要close()方法，关闭流。

  • 操作字节数组

    • ByteArrayInputStream
    • ByteArrayOutputStream
  • 操作字符数组
    • CharArrayReader
    • CharArrayWrite
  • 操作字符串
    • StringReader
    • StringWriter
  1. public class ByteArrayStreamDemo {
  2.     public static void main(String[] args) throws IOException {
  3.         // 写数据
  4.         // ByteArrayOutputStream()
  5.         ByteArrayOutputStream baos = new ByteArrayOutputStream();
  7.         // 写数据
  8.         for (int x = 0; x < 10; x++) {
  9.             baos.write(("hello" + x).getBytes());
  10.         }
  12.         // 释放资源
  13.         // 通过查看源代码我们知道这里什么都没做，所以根本不须要close()
  14.         // baos.close();
  16.         // public byte[] toByteArray()
  17.         byte[] bys = baos.toByteArray();
  19.         // 读数据
  20.         // ByteArrayInputStream(byte[] buf)
  21.         ByteArrayInputStream bais = new ByteArrayInputStream(bys);
  23.         int by = 0;
  24.         while ((by = bais.read()) != -1) {
  25.             System.out.print((char) by);
  26.         }
  28.         // bais.close();
  29.     }
  30. }

流的基本分类

  • 基本流：就是能够直接读写文件的
  • 高级流：在基本流基础上提供了一些其它的功能

打印流

打印流概述

  • 字节流打印流 PrintStream
  • 字符打印流 PrintWriter

打印流特点

  • 仅仅有写数据的，没有读取数据。仅仅能操作目的地，不能操作数据源。
  • 能够操作随意类型的数据。
  • 假设启动了自己主动刷新。能够自己主动刷新。
  • 能够直接操作文本文件的
  • 能够操作随意类型的数据
    • print()
    • println()
      • 这个时候不仅仅自己主动刷新了，还实现了数据的换行。
哪些流对象是能够直接操作文本文件的呢?
  • FileInputStream
  • FileOutputStream
  • FileReader
  • FileWriter
  • PrintStream
  • PrintWriter

  • 详细方法：看API,查流对象的构造方法，假设同一时候有File类型和String类型的參数，一般来说就是能够直接操作文件的。

  • 基本功能

  1. public class PrintWriterDemo {
  2.     public static void main(String[] args) throws IOException {
  3.         // 作为Writer的子类使用
  4.         PrintWriter pw = new PrintWriter("pw.txt");
  6.         pw.write("hello");
  7.         pw.write("world");
  8.         pw.write("java");
  9.         pw.close();
  10.     }
  11. }
  • 带自己主动刷新、换行的高级功能
  1. /*
  2.  * 1:能够操作随意类型的数据。
  4. *         print()
  5.  *         println()
  6.  * 2:启动自己主动刷新
  7.  *         PrintWriter pw = new PrintWriter(new FileWriter("pw2.txt"), true);
  8.  *         还是应该调用println()的方法才干够
  9.  *         这个时候不仅仅自己主动刷新了，还实现了数据的换行。
  10.  *
  11.  *         println()
  12.  *        事实上等价于于：
  13.  *        bw.write();
  14.  *        bw.newLine();
  15.  *        bw.flush();
  16.  */
  17. public class PrintWriterDemo2 {
  18.     public static void main(String[] args) throws IOException {
  19.         // 创建打印流对象
  20.         // PrintWriter pw = new PrintWriter("pw2.txt");
  21.         PrintWriter pw = new PrintWriter(new FileWriter("pw2.txt"), true);
  23.         // write()是搞不定的，怎么办呢?
  25. // 我们就应该看看它的新方法
  26.         // pw.print(true);
  27.         // pw.print(100);
  28.         // pw.print("hello");
  30.         pw.println("hello");
  31.         pw.println(true);
  32.         pw.println(100);
  34.         pw.close();
  35.     }
  36. }
  • 打印流复制文本文件
  1. /*
  2.  * 需求：DataStreamDemo.java拷贝到Copy.java中
  3.  * 数据源：
  4.  *         DataStreamDemo.java -- 读取数据 -- FileReader -- BufferedReader
  5.  * 目的地：
  6.  *         Copy.java -- 写出数据 -- FileWriter -- BufferedWriter -- PrintWriter
  7.  */
  8. public class CopyFileDemo {
  9.     public static void main(String[] args) throws IOException {
  10.         // 曾经的版本号
  11.         // 封装数据源
  12.         // BufferedReader br = new BufferedReader(new FileReader(
  13.         // "DataStreamDemo.java"));
  14.         // // 封装目的地
  15.         // BufferedWriter bw = new BufferedWriter(new FileWriter("Copy.java"));
  16.         //
  17.         // String line = null;
  18.         // while ((line = br.readLine()) != null) {
  19.         // bw.write(line);
  20.         // bw.newLine();
  21.         // bw.flush();
  22.         // }
  23.         //
  24.         // bw.close();
  25.         // br.close();
  27.         // 打印流的改进版
  28.         // 封装数据源
  29.         BufferedReader br = new BufferedReader(new FileReader(
  30.                 "DataStreamDemo.java"));
  31.         // 封装目的地
  32.         PrintWriter pw = new PrintWriter(new FileWriter("Copy.java"), true);
  34.         String line = null;
  35.         while((line=br.readLine())!=null){
  36.             pw.println(line);
  37.         }
  39.         pw.close();
  40.         br.close();
  41.     }
  42. }

标准输入输出流（重点掌握）

  • (1)System类中的两个成员变量：

    • public static final InputStream in* “标准”输入流*
    • public static final PrintStream out* “标准”输出流*
    • InputStream is = System.in;
    • PrintStream ps = System.out;
    • 它们各代表了系统标准的输入和输出设备。
    • 默认输入设备是键盘，输出设备是显示器。

    • System.in的类型是InputStream。
    • System.out的类型是PrintStream 是OutputStream的子类FilterOutputStream 的子类.

  • (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));
  1. /*
  2.  * 标准输入输出流
  3.  * System类中的两个成员变量：
  4.  *        public static final InputStream in “标准”输入流。
  5.  *         public static final PrintStream out “标准”输出流。
  6.  *
  7.  *         InputStream is = System.in;
  8.  *         PrintStream ps = System.out;
  9.  */
  10. public class SystemOutDemo {
  11.     public static void main(String[] args) {
  12.         // 有这里的解说我们就知道了，这个输出语句其本质是IO流操作，把数据输出到控制台。
  13.         System.out.println("helloworld");
  15.         // 获取标准输出流对象
  16.         PrintStream ps = System.out;
  17.         ps.println("helloworld");
  19.         ps.println();
  20.         // ps.print();//这种方法不存在
  22.         // System.out.println();
  23.         // System.out.print();
  24.     }
  25. }
  • 用System.in实现键盘录入数据。

    用BufferedReader改进。

  1. /*
  2.  * System.in 标准输入流。是从键盘获取数据的
  3.  *
  4.  * 键盘录入数据：
  5.  *         A:main方法的args接收參数。
  6.  *             java HelloWorld hello world java
  7.  *         B:Scanner(JDK5以后的)
  8.  *             Scanner sc = new Scanner(System.in);
  9.  *             String s = sc.nextLine();
  10.  *             int x = sc.nextInt()
  11.  *         C:通过字符缓冲流包装标准输入流实现
  12.  *             BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
  13.  */
  14. public class SystemInDemo {
  15.     public static void main(String[] args) throws IOException {
  16.         // //获取标准输入流
  17.         // InputStream is = System.in;
  18.         // //我要一次获取一行行不行呢?
  20. // //行。
  22. // //怎么实现呢?
  23.         // //要想实现，首先你得知道一次读取一行数据的方法是哪个呢?
  24.         // //readLine()
  25.         // //而这种方法在哪个类中呢?
  26.         // //BufferedReader
  27.         // //所以，你这次应该创建BufferedReader的对象，可是底层还是的使用标准输入流
  28.         // // BufferedReader br = new BufferedReader(is);
  29.         // //依照我们的推想，如今应该能够了。可是却报错了
  30.         // //原因是：字符缓冲流仅仅能针对字符流操作。而你如今是字节流。所以不能使用?
  32. // //那么，我还就想使用了，请大家给我一个解决方式?
  33.         // //把字节流转换为字符流，然后在通过字符缓冲流操作
  34.         // InputStreamReader isr = new InputStreamReader(is);
  35.         // BufferedReader br= new BufferedReader(isr);
  36.         BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
  38.         System.out.println("请输入一个字符串：");
  39.         String line = br.readLine();
  40.         System.out.println("你输入的字符串是：" + line);
  42.         System.out.println("请输入一个整数：");
  43.         // int i = Integer.parseInt(br.readLine());
  44.         line = br.readLine();
  45.         int i = Integer.parseInt(line);
  46.         System.out.println("你输入的整数是：" + i);
  47.     }
  48. }
  • 用System.out实现控制台输出数据。用BufferedWriter改进。
  1. /*
  2.  * 转换流的应用。
  3.  */
  4. public class SystemOutDemo2 {
  5.     public static void main(String[] args) throws IOException {
  6.         // 获取标准输入流
  7.         // // PrintStream ps = System.out;
  8.         // // OutputStream os = ps;
  9.         // OutputStream os = System.out; // 多态
  10.         // // 我能不能依照刚才使用标准输入流的方式一样把数据输出到控制台呢?
  11.         // OutputStreamWriter osw = new OutputStreamWriter(os);
  12.         // BufferedWriter bw = new BufferedWriter(osw);
  13.         BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(
  14.                 System.out));
  16.         bw.write("hello");
  17.         bw.newLine();
  18.         // bw.flush();
  19.         bw.write("world");
  20.         bw.newLine();
  21.         // bw.flush();
  22.         bw.write("java");
  23.         bw.newLine();
  24.         bw.flush();
  26.         bw.close();
  27.     }
  28. }

随机訪问流

RandomAccessFile概述

  • RandomAccessFile类不属于流，是Object类的子类。但它融合了InputStream和OutputStream的功能。支持对随机訪问文件的读取和写入。

訪问模式

  • “r” 以仅仅读方式打开。

    调用结果对象的不论什么 write 方法都将导致抛出 IOException。

  • “rw” 打开以便读取和写入。假设该文件尚不存在，则尝试创建该文件。
  • “rws” 打开以便读取和写入。对于 “rw”，还要求对文件的内容或元数据的每一个更新都同步写入究竟层存储设备。
  • “rwd” 打开以便读取和写入，对于 “rw”，还要求对文件内容的每一个更新都同步写入究竟层存储设备。

  • 一般使用rw模式。

  • 案例演示


  2. public static void main(String[] args) throws IOException {
  3.     write();
  4.     read();
  5. }
  7. private static void read() throws IOException {
  8.     RandomAccessFile raf = new RandomAccessFile("raf.txt", "rw");
  9.     int i = raf.readInt();
  10.     System.out.println(i);
  11.     System.out.println("当前指针位置：" + raf.getFilePointer());
  12.     char ch = raf.readChar();
  13.     System.out.println(ch);
  14.     System.out.println("当前指针位置：" + raf.getFilePointer());
  15.     String s = raf.readUTF();
  16.     System.out.println(s);
  17.     System.out.println("当前指针位置：" + raf.getFilePointer());
  18.     System.out.println("读取数据完成");
  20.     System.out.println("当前指针位置：" + raf.getFilePointer());
  21.     raf.seek(0);// 返回数据开头
  22.     int ii = raf.readInt();
  23.     System.out.println(ii);
  24. }
  26. private static void write() throws IOException {
  27. RandomAccessFile raf = new RandomAccessFile("raf.txt", "rw");
  28.     raf.writeInt(100); // 写入int类型
  29.     raf.writeChar('爱');// 写入字符
  30.     raf.writeUTF("中国你好");// 写入字符串
  31.     raf.close();
  32.     System.out.println("写入成功");
  33. }

合并流

SequenceInputStream概述

  • SequenceInputStream类能够将多个输入流串流在一起，合并为一个输入流。因此，该流也被称为合并流。

SequenceInputStream的构造方法

  • SequenceInputStream(InputStream s1, InputStream s2)
  • SequenceInputStream(Enumeration
  1. /*
  2.  * 曾经的操作：
  3.  * a.txt -- b.txt
  4.  * c.txt -- d.txt
  5.  *
  6.  * 如今想要：
  7.  * a.txt+b.txt -- c.txt
  8.  */
  9. public class SequenceInputStreamDemo {
  10.     public static void main(String[] args) throws IOException {
  11.         // SequenceInputStream(InputStream s1, InputStream s2)
  12.         // 需求：把ByteArrayStreamDemo.java和DataStreamDemo.java的内容拷贝到Copy.java中
  13.         InputStream s1 = new FileInputStream("ByteArrayStreamDemo.java");
  14.         InputStream s2 = new FileInputStream("DataStreamDemo.java");
  15.         SequenceInputStream sis = new SequenceInputStream(s1, s2);
  16.         BufferedOutputStream bos = new BufferedOutputStream(
  17.                 new FileOutputStream("Copy.java"));
  19.         // 怎样写读写呢，事实上非常easy，你就依照曾经怎么读写。如今还是怎么读写
  20.         byte[] bys = new byte[1024];
  21.         int len = 0;
  22.         while ((len = sis.read(bys)) != -1) {
  23.             bos.write(bys, 0, len);
  24.         }
  26.         bos.close();
  27.         sis.close();
  28.     }
  29. }
  • 方式二：
  1. public class SequenceInputStreamDemo2 {
  2.     public static void main(String[] args) throws IOException {
  3.         // 需求：把以下的三个文件的内容拷贝到Copy.java中
  4.         // ByteArrayStreamDemo.java,CopyFileDemo.java,DataStreamDemo.java
  6.         // SequenceInputStream(Enumeration e)
  7.         // 通过简单的回想我们知道了Enumeration是Vector中的一个方法的返回值类型。
  8.         // Enumeration<E> elements()
  9.         Vector<InputStream> v = new Vector<InputStream>();
  10.         InputStream s1 = new FileInputStream("ByteArrayStreamDemo.java");
  11.         InputStream s2 = new FileInputStream("CopyFileDemo.java");
  12.         InputStream s3 = new FileInputStream("DataStreamDemo.java");
  13.         v.add(s1);
  14.         v.add(s2);
  15.         v.add(s3);
  16.         Enumeration<InputStream> en = v.elements();
  17.         SequenceInputStream sis = new SequenceInputStream(en);
  18.         BufferedOutputStream bos = new BufferedOutputStream(
  19.                 new FileOutputStream("Copy.java"));
  21.         // 怎样写读写呢，事实上非常easy，你就依照曾经怎么读写。如今还是怎么读写
  22.         byte[] bys = new byte[1024];
  23.         int len = 0;
  24.         while ((len = sis.read(bys)) != -1) {
  25.             bos.write(bys, 0, len);
  26.         }
  28.         bos.close();
  29.         sis.close();
  30.     }
  31. }

序列化流

序列化流概述

  • 对象序列化是将对象状态转换为可保持或传输的过程。一般的格式是与平台无关的二进制流，能够将这样的二进制流持久保存在磁盘上。也能够通过网络将这样的二进制流传输到还有一个网络结点。

  • 序列化流:能够把对象写入文本文件或者在网络中传输

    • ObjectOutputStream
  • 反序列化流:把这样的二进制流数据还原成对象。

    • ObjectInputStream
  • 序列化操作问题
    • 为什么要实现序列化?

    • 怎样实现序列化?
      • 让被序列化的对象所属类实现序列化接口。

      • 该接口是一个标记接口。没有功能须要实现。
    • 序列化数据后。再次改动类文件，读取数据会出问题，怎样解决呢?
      • 在类文件里，给出一个固定的序列化id值。并且，这样也能够解决黄色警告线问题
    • 使用transient关键字声明不须要序列化的成员变量
  1. public class ObjectStreamDemo {
  2.     public static void main(String[] args) throws IOException,
  3.             ClassNotFoundException {
  4.         // 由于我们要对对象进行序列化。所以我们先自定义一个类
  5.         // 序列化数据事实上就是把对象写到文本文件
  6.         // write();
  8.         read();
  9.     }
  11.     private static void read() throws IOException, ClassNotFoundException {
  12.         // 创建反序列化对象
  13.         ObjectInputStream ois = new ObjectInputStream(new FileInputStream(
  14.                 "oos.txt"));
  16.         // 还原对象
  17.         Object obj = ois.readObject();
  19.         // 释放资源
  20.         ois.close();
  22.         // 输出对象
  23.         System.out.println(obj);
  24.     }
  26.     private static void write() throws IOException {
  27.         // 创建序列化流对象
  28.         ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(
  29.                 "oos.txt"));
  31.         // 创建对象
  32.         Person p = new Person("林青霞", 27);
  34.         // public final void writeObject(Object obj)
  35.         oos.writeObject(p);
  37.         // 释放资源
  38.         oos.close();
  39.     }
  40. }
  • person类
  1. /*
  2.  * NotSerializableException:未序列化异常
  3.  *
  4.  * 类通过实现 java.io.Serializable 接口以启用其序列化功能。未实现此接口的类将无法使其不论什么状态序列化或反序列化。
  5.  * 该接口竟然没有不论什么方法，相似于这样的没有方法的接口被称为标记接口。
  7. *
  8.  * java.io.InvalidClassException:
  9.  * cn.itcast_07.Person; local class incompatible:
  10.  * stream classdesc serialVersionUID = -2071565876962058344,
  11.  * local class serialVersionUID = -8345153069362641443
  12.  *
  13.  * 为什么会有问题呢?
  14.  *         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值进行匹配。
  31. 所以。就会出问题。
  32.  * 可是呢，假设我有办法。让这个id值在java文件里是一个固定的值，这样，你改动文件的时候。这个id值还会发生改变吗?
  33.  * 不会。如今的关键是我怎样能够知道这个id值怎样表示的呢?
  35. * 不用操心。你不用记住，也没关系。点击鼠标就可以。
  36.  * 你难道没有看到黄色警告线吗?
  37.  *
  38.  * 我们要知道的是：
  39.  *         看到类实现了序列化接口的时候。要想解决黄色警告线问题。就能够自己主动产生一个序列化id值。
  40.  *         并且产生这个值以后，我们对类进行不论什么改动，它读取曾经的数据是没有问题的。
  41.  *
  42.  * 注意：
  43.  *         我一个类中可能有非常多的成员变量。有些我不想进行序列化。请问该怎么办呢?
  44.  *         使用transient关键字声明不须要序列化的成员变量
  45.  */
  46. public class Person implements Serializable {
  47.     private static final long serialVersionUID = -2071565876962058344L;
  49.     private String name;
  51.     // private int age;
  53.     private transient int age;
  55.     // int age;
  57.     public Person() {
  58.         super();
  59.     }
  61.     public Person(String name, int age) {
  62.         super();
  63.         this.name = name;
  64.         this.age = age;
  65.     }
  67.     public String getName() {
  68.         return name;
  69.     }
  71.     public void setName(String name) {
  72.         this.name = name;
  73.     }
  75.     public int getAge() {
  76.         return age;
  77.     }
  79.     public void setAge(int age) {
  80.         this.age = age;
  81.     }
  83.     @Override
  84.     public String toString() {
  85.         return "Person [name=" + name + ", age=" + age + "]";
  86.     }
  87. }

Properties集合

Properties概述

  • (1)是一个集合类，Hashtable的子类,是一个能够和IO流相结合使用的集合类。

    可保存在流中或从流中载入。属性列表中每一个键及其相应值都是一个字符串。

  • (2)特有功能

    • public Object setProperty(String key,String value)：加入元素
    • public String getProperty(String key):获取元素
    • public Set<String> 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)

Properties作为Map集合的使用

  1. /*
  2.  * 是Hashtable的子类，说明是一个Map集合。
  3.  */
  4. public class PropertiesDemo {
  5.     public static void main(String[] args) {
  6.         // 作为Map集合的使用
  7.         // 以下这样的使用方法是错误的。一定要看API。假设没有<>，就说明该类不是一个泛型类,在使用的时候就不能加泛型
  8.         // Properties<String, String> prop = new Properties<String, String>();
  10.         Properties prop = new Properties();
  12.         // 加入元素
  13.         prop.put("it002", "hello");
  14.         prop.put("it001", "world");
  15.         prop.put("it003", "java");
  17.         // System.out.println("prop:" + prop);
  19.         // 遍历集合
  20.         Set<Object> set = prop.keySet();
  21.         for (Object key : set) {
  22.             Object value = prop.get(key);
  23.             System.out.println(key + "---" + value);
  24.         }
  25.     }
  26. }

Properties的特殊功能

  • public Object setProperty(String key,String value)：加入元素
  • public String getProperty(String key):获取元素
  • public Set<String> stringPropertyNames():获取全部的键的集合

  2. public class PropertiesDemo2 {
  3.     public static void main(String[] args) {
  4.         // 创建集合对象
  5.         Properties prop = new Properties();
  7.         // 加入元素
  8.         prop.setProperty("张三", "30");
  9.         prop.setProperty("李四", "40");
  10.         prop.setProperty("王五", "50");
  12.         // public Set<String> stringPropertyNames():获取全部的键的集合
  13.         Set<String> set = prop.stringPropertyNames();
  14.         for (String key : set) {
  15.             String value = prop.getProperty(key);
  16.             System.out.println(key + "---" + value);
  17.         }
  18.     }
  19. }
  21. /*
  22.  * class Hashtalbe<K,V> { public V put(K key,V value) { ... } }
  23.  *
  24.  * class Properties extends Hashtable { public V setProperty(String key,String
  25.  * value) { return put(key,value); } }
  26.  */

Properties和IO流的结合使用

  • public void load(Reader reader):把文件里的数据读取到集合中

    • public void store(Writer writer,String comments):把集合中的数据存储到文件
  1. /*
  2.  * 这里的集合必须是Properties集合：
  3.  * public void load(Reader reader):把文件里的数据读取到集合中
  4.  * public void store(Writer writer,String comments):把集合中的数据存储到文件
  5.  */
  6. public class PropertiesDemo3 {
  7.     public static void main(String[] args) throws IOException {
  8.         // myLoad();
  10.         myStore();
  11.     }
  13.     private static void myStore() throws IOException {
  14.         // 创建集合对象
  15.         Properties prop = new Properties();
  17.         prop.setProperty("林青霞", "27");
  18.         prop.setProperty("武鑫", "30");
  19.         prop.setProperty("刘晓曲", "18");
  21.         //public void store(Writer writer,String comments):把集合中的数据存储到文件
  22.         Writer w = new FileWriter("name.txt");
  23.         prop.store(w, "helloworld");
  24.         w.close();
  25.     }
  27.     private static void myLoad() throws IOException {
  28.         Properties prop = new Properties();
  30.         // public void load(Reader reader):把文件里的数据读取到集合中
  31.         // 注意：这个文件的数据必须是键值对形式
  32.         Reader r = new FileReader("prop.txt");
  33.         prop.load(r);
  34.         r.close();
  36.         System.out.println("prop:" + prop);
  37.     }
  38. }
  • 练习1：我有一个文本文件，我知道数据是键值对形式的。可是不知道内容是什么。

    请写一个程序推断是否有“lisi”这样的键存在，假设有就改变事实上为”100”

  1. /*
  2.  * 我有一个文本文件(user.txt)，我知道数据是键值对形式的，可是不知道内容是什么。
  3.  * 请写一个程序推断是否有“lisi”这样的键存在，假设有就改变事实上为”100”
  4.  *
  5.  * 分析：
  6.  *         A:把文件里的数据载入到集合中
  7.  *         B:遍历集合，获取得到每一个键
  8.  *         C:推断键是否有为"lisi"的，假设有就改动其值为"100"
  9.  *         D:把集合中的数据又一次存储到文件里
  10.  */
  11. public class PropertiesTest {
  12.     public static void main(String[] args) throws IOException {
  13.         // 把文件里的数据载入到集合中
  14.         Properties prop = new Properties();
  15.         Reader r = new FileReader("user.txt");
  16.         prop.load(r);
  17.         r.close();
  19.         // 遍历集合，获取得到每一个键
  20.         Set<String> set = prop.stringPropertyNames();
  21.         for (String key : set) {
  22.             // 推断键是否有为"lisi"的。假设有就改动其值为"100"
  23.             if ("lisi".equals(key)) {
  24.                 prop.setProperty(key, "100");
  25.                 break;
  26.             }
  27.         }
  29.         // 把集合中的数据又一次存储到文件里
  30.         Writer w = new FileWriter("user.txt");
  31.         prop.store(w, null);
  32.         w.close();
  33.     }
  34. }
  • 练习2：我有一个猜数字小游戏的程序。请写一个程序实如今測试类中仅仅能用5次，超过5次提示：游戏试玩已结束。请付费。
  1. /*
  2.  * 我有一个猜数字小游戏的程序，请写一个程序实如今測试类中仅仅能用5次，超过5次提示：游戏试玩已结束，请付费。
  3.  */
  4. public class PropertiesTest2 {
  5.     public static void main(String[] args) throws IOException {
  6.         // 读取某个地方的数据。假设次数不大于5，能够继续玩。否则就提示"游戏试玩已结束，请付费。
  8. "
  9.         // 创建一个文件
  10.         // File file = new File("count.txt");
  11.         // if (!file.exists()) {
  12.         // file.createNewFile();
  13.         // }
  15.         // 把数据载入到集合中
  16.         Properties prop = new Properties();
  17.         Reader r = new FileReader("count.txt");
  18.         prop.load(r);
  19.         r.close();
  21.         // 我自己的程序。我当然知道里面的键是谁
  22.         String value = prop.getProperty("count");
  23.         int number = Integer.parseInt(value);
  25.         if (number > 5) {
  26.             System.out.println("游戏试玩已结束，请付费。");
  27.             System.exit(0);
  28.         } else {
  29.             number++;
  30.             prop.setProperty("count", String.valueOf(number));
  31.             Writer w = new FileWriter("count.txt");
  32.             prop.store(w, null);
  33.             w.close();
  35.             GuessNumber.start();
  36.         }
  37.     }
  38. }

NIO包下的IO流

  • (1) JDK4出现NIO。

    新IO和传统的IO有同样的目的，都是用于进行输入输出的，但新IO使用了不同的方式来处理输入输出，採用内存映射文件的方式，将文件或者文件的一段区域映射到内存中，就能够像訪问内存一样的来訪问文件了，这样的方式效率比旧IO要高非常多，可是眼下好多地方我们看到的还是旧IO的引用，所以我们仍以旧IO为主。知道NIO就可以。

  • (2)JDK7的NIO的使用

    • 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)

  • 案例1：拷贝文件

    Files.copy(Paths.get("Demo.java"), newFileOutputStream("Copy.Java"));

  • 案例2：把集合中的数据写到文件

  1. public class NIODemo {
  2.     public static void main(String[] args) throws IOException {
  3.         // public static long copy(Path source,OutputStream out)
  4.         // Files.copy(Paths.get("ByteArrayStreamDemo.java"), new
  5.         // FileOutputStream(
  6.         // "Copy.java"));
  8.         ArrayList<String> array = new ArrayList<String>();
  9.         array.add("hello");
  10.         array.add("world");
  11.         array.add("java");
  12.         Files.write(Paths.get("array.txt"), array, Charset.forName("GBK"));
  13.     }
  14. }

No_16_0324 Java基础学习第二十三天的更多相关文章

  1. Java基础学习第二天

    ================每日必读==================== 写代码: 1.明确需求.我需要实现什么需求? 2.分析思路.我需要怎么实现需求? 3.确定步骤.我的每一部分思路需要使 ...

  2. Java基础学习笔记十三 常用API之正则表达式、Date、DateFormat、Calendar

    正则表达式 正则表达式(英语:Regular Expression,在代码中常简写为regex).正则表达式是一个字符串,使用单个字符串来描述.用来定义匹配规则,匹配一系列符合某个句法规则的字符串.在 ...

  3. Java基础学习笔记总结

    Java基础学习笔记一 Java介绍 Java基础学习笔记二 Java基础语法之变量.数据类型 Java基础学习笔记三 Java基础语法之流程控制语句.循环 Java基础学习笔记四 Java基础语法之 ...

  4. JAVA基础学习-集合三-Map、HashMap,TreeMap与常用API

    森林森 一份耕耘,一份收获 博客园 首页 新随笔 联系 管理 订阅 随笔- 397  文章- 0  评论- 78  JAVA基础学习day16--集合三-Map.HashMap,TreeMap与常用A ...

  5. 尚学堂JAVA基础学习笔记

    目录 尚学堂JAVA基础学习笔记 写在前面 第1章 JAVA入门 第2章 数据类型和运算符 第3章 控制语句 第4章 Java面向对象基础 1. 面向对象基础 2. 面向对象的内存分析 3. 构造方法 ...

  6. [转帖]java基础学习总结——多态(动态绑定)

    https://www.cnblogs.com/xdp-gacl/p/3644035.html 多态的概念 java基础学习总结——多态(动态绑定) 一.面向对象最核心的机制——动态绑定,也叫多态

  7. Java基础学习-- 继承 的简单总结

    代码参考:Java基础学习小记--多态 为什么要引入继承? 还是做一个媒体库,里面可以放CD,可以放DVD.如果把CD和DVD做成两个没有联系的类的话,那么在管理这个媒体库的时候,要单独做一个添加CD ...

  8. Java基础学习中一些词语和语句的使用

    在Java基础学习中,我们刚接触Java会遇到一些词和语句的使用不清的情况,不能很清楚的理解它的运行效果会是怎么样的,如:break,continue在程序中运行效果及跳转位置, 1.先来看看brea ...

  9. 转载-java基础学习汇总

    共2页: 1 2 下一页  Java制作证书的工具keytool用法总结 孤傲苍狼 2014-06-24 11:03 阅读:25751 评论:3     Java基础学习总结——Java对象的序列化和 ...

随机推荐

  1. 机器学习方法：回归（二）：稀疏与正则约束ridge regression，Lasso

    欢迎转载,转载请注明:本文出自Bin的专栏blog.csdn.net/xbinworld. "机器学习方法"系列,我本着开放与共享(open and share)的精神撰写,目的是 ...

  2. Search in Rotated Sorted Array I&&II——二分法

    Search in Rotated Sorted Array I Suppose a sorted array is rotated at some pivot unknown to you befo ...

  3. win10更换登陆背景和关闭锁屏

    更换登陆背景图 用国外一个hacker写的工具,可在github上下载,或者下载我上传到百度网盘的备份.win10默认的登陆背景太难看了. 去掉锁屏图片 登陆界面其实本身就是一种锁屏,为什么还要单独搞 ...

  4. AC日记——「HNOI2017」单旋 LiBreOJ 2018

    #2018. 「HNOI2017」单旋 思路: set+线段树: 代码: #include <bits/stdc++.h> using namespace std; #define max ...

  5. 解决CentOS7 firefox崩溃问题

    现象:我在博客园写随笔的时候插入图片,每次都会崩溃,百度了好久,发现这个方法还挺好用的 在终端敲入如下命令: setsebool -P unconfined_mozilla_plugin_transi ...

  6. 简单邮件传输协议SMTP

    1.SMTP是由源地址到目的地址传送邮件的一组规则,用来控制信件的中转方式. 2.SMTP服务器是遵循SMTP协议的发送邮件服务器,用来发送或者中转发出的邮件,客户端通过SMTP命令与SMTP服务器进 ...

  7. django使用MySQL时部分配置

    若是Django中使用MySQL,需要在项目名文件目录下(而不是应用文件)的__init__.py文件中添加: import pymysqlpymysql.install_as_MySQLdb()

  8. BestCoder Round #65 （ZYB's Game）

    ZYB's Game Accepts: 672 Submissions: 1207 Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 65536 ...

  9. Redux 源码自己写了一遍

    <!DOCTYPE HTML> <html> <head> <meta http-equiv="content-type" content ...

  10. Java 线程池的实现

    http://blog.csdn.net/iterzebra/article/details/6758481 http://blog.sina.com.cn/s/blog_4914a33b010118 ...