day22-----------IO流（傳智視頻）

登陸註冊案例IO版實現

      該案例是由day17的登陸改版而來，只修改了，impl類的文件，將其中的的存儲用戶信息，存儲到文件便可，還有一些小細節，註釋都有體現。

package cn.itcast.dao.impl;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

import cn.itcast.dao.UserDao;
import cn.itcast.pojo.User;

/**
 * 這是用戶操做的具體實現類(IO版)
 * 
 * @author 風清揚
 * @version V1.1
 * 
 */
public class UserDaoImpl implements UserDao {
	// 爲了保證文件一加載就建立
	private static File file = new File("user.txt");

	static {
		try {
			file.createNewFile();
		} catch (IOException e) {
			System.out.println("建立文件失敗");
			// e.printStackTrace();
		}
	}

	@Override
	public boolean isLogin(String username, String password) {
		boolean flag = false;

		BufferedReader br = null;
		try {
			// br = new BufferedReader(new FileReader("user.txt"));
			br = new BufferedReader(new FileReader(file));
			String line = null;
			while ((line = br.readLine()) != null) {
				// 用戶名=密碼
				String[] datas = line.split("=");
				if (datas[0].equals(username) && datas[1].equals(password)) {
					flag = true;
					break;
				}
			}
		} catch (FileNotFoundException e) {
			System.out.println("用戶登陸找不到信息所在的文件");
			// e.printStackTrace();
		} catch (IOException e) {
			System.out.println("用戶登陸失敗");
			// e.printStackTrace();
		} finally {
			if (br != null) {
				try {
					br.close();
				} catch (IOException e) {
					System.out.println("用戶登陸釋放資源失敗");
					// e.printStackTrace();
				}
			}
		}

		return flag;
	}

	@Override
	public void regist(User user) {
		/*
		 * 爲了讓註冊的數據可以有必定的規則，我就本身定義了一個規則： 用戶名=密碼
		 */
		BufferedWriter bw = null;
		try {
			// bw = new BufferedWriter(new FileWriter("user.txt"));
			// bw = new BufferedWriter(new FileWriter(file));
			// 爲了保證數據是追加寫入，必須加true
			bw = new BufferedWriter(new FileWriter(file, true));
			bw.write(user.getUsername() + "=" + user.getPassword());
			bw.newLine();
			bw.flush();
		} catch (IOException e) {
			System.out.println("用戶註冊失敗");
			// e.printStackTrace();
		} finally {
			if (bw != null) {
				try {
					bw.close();
				} catch (IOException e) {
					System.out.println("用戶註冊釋放資源失敗");
					// e.printStackTrace();
				}
			}
		}
	}
}

數據輸入輸出流的概述和講解

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)
 * 數據輸出流：DataOutputStream
 * 			DataOutputStream(OutputStream out) 
 */
public class DataStreamDemo {
	public static void main(String[] args) throws IOException {
		// 寫
		// write();

		// 讀
		read();
	}

	private static void read() throws IOException {
		// DataInputStream(InputStream in)
		// 建立數據輸入流對象
		DataInputStream dis = new DataInputStream(
				new FileInputStream("dos.txt"));

		// 讀數據
		byte b = dis.readByte();
		short s = dis.readShort();
		int i = dis.readInt();
		long l = dis.readLong();
		float f = dis.readFloat();
		double d = dis.readDouble();
		char c = dis.readChar();
		boolean bb = dis.readBoolean();

		// 釋放資源
		dis.close();

		System.out.println(b);
		System.out.println(s);
		System.out.println(i);
		System.out.println(l);
		System.out.println(f);
		System.out.println(d);
		System.out.println(c);
		System.out.println(bb);
	}

	private static void write() throws IOException {
		// DataOutputStream(OutputStream out)
		// 建立數據輸出流對象
		DataOutputStream dos = new DataOutputStream(new FileOutputStream(
				"dos.txt"));

		// 寫數據了
		dos.writeByte(10);
		dos.writeShort(100);
		dos.writeInt(1000);
		dos.writeLong(10000);
		dos.writeFloat(12.34F);
		dos.writeDouble(12.56);
		dos.writeChar('a');
		dos.writeBoolean(true);

		// 釋放資源
		dos.close();
	}
}

內存操做流的概述和講解

package cn.itcast_02;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;

/*
 * 內存操做流：用於處理臨時存儲信息的，程序結束，數據就從內存中消失。
 * 字節數組：
 * 		ByteArrayInputStream
 * 		ByteArrayOutputStream
 * 字符數組：
 * 		CharArrayReader
 * 		CharArrayWriter
 * 字符串：
 * 		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(("hello" + x).getBytes());
		}

		// 釋放資源
		// 經過查看源碼咱們知道這裏什麼都沒作，因此根本須要close()
		// baos.close();

		// public byte[] toByteArray()
		byte[] bys = baos.toByteArray();

		// 讀數據
		// ByteArrayInputStream(byte[] buf)
		ByteArrayInputStream bais = new ByteArrayInputStream(bys);

		int by = 0;
		while ((by = bais.read()) != -1) {
			System.out.print((char) by);
		}

		// bais.close();
	}
}

PrintWriter做爲Writer的子類使用

package cn.itcast_03;

import java.io.IOException;
import java.io.PrintWriter;

/*
 * 打印流
 * 字節流打印流	PrintStream
 * 字符打印流	PrintWriter
 * 
 * 打印流的特色：
 * 		A:只有寫數據的，沒有讀取數據。只能操做目的地，不能操做數據源。
 * 		B:能夠操做任意類型的數據。
 * 		C:若是啓動了自動刷新，可以自動刷新。
 * 		D:該流是能夠直接操做文本文件的。
 * 			哪些流對象是能夠直接操做文本文件的呢?
 * 			FileInputStream
 * 			FileOutputStream
 * 			FileReader
 * 			FileWriter
 * 			PrintStream
 * 			PrintWriter
 * 			看API,查流對象的構造方法，若是同時有File類型和String類型的參數，通常來講就是能夠直接操做文件的。
 * 
 * 			流：
 * 				基本流：就是可以直接讀寫文件的
 * 				高級流：在基本流基礎上提供了一些其餘的功能
 */
public class PrintWriterDemo {
	public static void main(String[] args) throws IOException {
		// 做爲Writer的子類使用
		PrintWriter pw = new PrintWriter("pw.txt");

		pw.write("hello");
		pw.write("world");
		pw.write("java");
		
		pw.close();
	}
}

PrintWriter實現自動刷新和換行

package cn.itcast_03;

import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;

/*
 * 1:能夠操做任意類型的數據。
 * 		print()
 * 		println()
 * 2:啓動自動刷新
 * 		PrintWriter pw = new PrintWriter(new FileWriter("pw2.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("pw2.txt");
		PrintWriter pw = new PrintWriter(new FileWriter("pw2.txt"), true);

		// write()是搞不定的，怎麼辦呢?
		// 咱們就應該看看它的新方法
		// pw.print(true);
		// pw.print(100);
		// pw.print("hello");

		pw.println("hello");
		pw.println(true);
		pw.println(100);

		pw.close();
	}
}

打印版改進複製文本文件案例

package cn.itcast_03;

import java.io.BufferedReader;
import java.io.BufferedWriter;
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 CopyFileDemo {
	public static void main(String[] args) throws IOException {
		// 之前的版本
		// 封裝數據源
		// BufferedReader br = new BufferedReader(new FileReader(
		// "DataStreamDemo.java"));
		// // 封裝目的地
		// BufferedWriter bw = new BufferedWriter(new FileWriter("Copy.java"));
		//
		// String line = null;
		// while ((line = br.readLine()) != null) {
		// bw.write(line);
		// bw.newLine();
		// bw.flush();
		// }
		//
		// bw.close();
		// br.close();

		// 打印流的改進版
		// 封裝數據源
		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);
		}
		
		pw.close();
		br.close();
	}
}

標準輸入輸出流概述和輸出語句的本質

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("helloworld");

		// 獲取標準輸出流對象
		PrintStream ps = System.out;
		ps.println("helloworld");
		
		ps.println();
		// ps.print();//這個方法不存在
		
		// System.out.println();
		// System.out.print();
	}
}

三種方式實現鍵盤錄入

package cn.itcast_04;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

/*
 * 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));
 */
public class SystemInDemo {
	public static void main(String[] args) throws IOException {
		// //獲取標準輸入流
		// InputStream is = System.in;
		// //我要一次獲取一行行不行呢?
		// //行。
		// //怎麼實現呢?
		// //要想實現，首先你得知道一次讀取一行數據的方法是哪一個呢?
		// //readLine()
		// //而這個方法在哪一個類中呢?
		// //BufferedReader
		// //因此，你此次應該建立BufferedReader的對象，可是底層仍是的使用標準輸入流
		// // BufferedReader br = new BufferedReader(is);
		// //按照咱們的推想，如今應該能夠了，可是卻報錯了
		// //緣由是：字符緩衝流只能針對字符流操做，而你如今是字節流，因此不能是用?
		// //那麼，我還就想使用了，請你們給我一個解決方案?
		// //把字節流轉換爲字符流，而後在經過字符緩衝流操做
		// InputStreamReader isr = new InputStreamReader(is);
		// BufferedReader br= new BufferedReader(isr);
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

		System.out.println("請輸入一個字符串：");
		String line = br.readLine();
		System.out.println("你輸入的字符串是：" + line);

		System.out.println("請輸入一個整數：");
		// int i = Integer.parseInt(br.readLine());
		line = br.readLine();
		int i = Integer.parseInt(line);
		System.out.println("你輸入的整數是：" + i);
	}
}

輸出語句用字符緩衝流改進

package cn.itcast_04;

import java.io.BufferedWriter;
import java.io.IOException;
import java.io.OutputStreamWriter;
/*
 * 轉換流的應用。
 */
public class SystemOutDemo2 {
	public static void main(String[] args) throws IOException {
		// 獲取標準輸入流
		// // PrintStream ps = System.out;
		// // OutputStream os = ps;
		// OutputStream os = System.out; // 多態
		// // 我能不能按照剛纔使用標準輸入流的方式同樣把數據輸出到控制檯呢?
		// OutputStreamWriter osw = new OutputStreamWriter(os);
		// BufferedWriter bw = new BufferedWriter(osw);
		BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(
				System.out));

		bw.write("hello");
		bw.newLine();
		// bw.flush();
		bw.write("world");
		bw.newLine();
		// bw.flush();
		bw.write("java");
		bw.newLine();
		bw.flush();
		
		bw.close();
	}
}

隨機訪問流讀取數據和操做文件指針

package cn.itcast_05;

import java.io.IOException;
import java.io.RandomAccessFile;

/*
 * 隨機訪問流：
 * 		RandomAccessFile類不屬於流，是Object類的子類。
 * 		但它融合了InputStream和OutputStream的功能。
 * 		支持對文件的隨機訪問讀取和寫入。
 * 
 * public RandomAccessFile(String name,String mode)：第一個參數是文件路徑，第二個參數是操做文件的模式。
 * 		模式有四種，咱們最經常使用的一種叫"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");

		int i = raf.readInt();
		System.out.println(i);
		// 該文件指針能夠經過 getFilePointer方法讀取，並經過 seek 方法設置。
		System.out.println("當前文件的指針位置是：" + raf.getFilePointer());

		char ch = raf.readChar();
		System.out.println(ch);
		System.out.println("當前文件的指針位置是：" + raf.getFilePointer());

		String s = raf.readUTF();
		System.out.println(s);
		System.out.println("當前文件的指針位置是：" + raf.getFilePointer());

		// 我不想重頭開始了，我就要讀取a，怎麼辦呢?
		raf.seek(4);
		ch = raf.readChar();
		System.out.println(ch);
	}

	private static void write() throws IOException {
		// 建立隨機訪問流對象
		RandomAccessFile raf = new RandomAccessFile("raf.txt", "rw");

		// 怎麼玩呢?
		raf.writeInt(100);
		raf.writeChar('a');
		raf.writeUTF("中國");

		raf.close();
	}
}

將兩個文件合併到一個文件中

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)
		// 需求：把ByteArrayStreamDemo.java和DataStreamDemo.java的內容複製到Copy.java中
		InputStream s1 = new FileInputStream("ByteArrayStreamDemo.java");
		InputStream s2 = new FileInputStream("DataStreamDemo.java");
		SequenceInputStream sis = new SequenceInputStream(s1, s2);
		BufferedOutputStream bos = new BufferedOutputStream(
				new FileOutputStream("Copy.java"));

		// 如何寫讀寫呢，其實很簡單，你就按照之前怎麼讀寫，如今仍是怎麼讀寫
		byte[] bys = new byte[1024];
		int len = 0;
		while ((len = sis.read(bys)) != -1) {
			bos.write(bys, 0, len);
		}

		bos.close();
		sis.close();
	}
}

合併流讀取多個文件的內容複製到一個文件中

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
 * e.txt -- f.txt
 * 
 * 如今想要：
 * a.txt+b.txt+c.txt -- d.txt
 */
public class SequenceInputStreamDemo2 {
	public static void main(String[] args) throws IOException {
		// 需求：把下面的三個文件的內容複製到Copy.java中
		// ByteArrayStreamDemo.java,CopyFileDemo.java,DataStreamDemo.java

		// SequenceInputStream(Enumeration e)
		// 經過簡單的回顧咱們知道了Enumeration是Vector中的一個方法的返回值類型。
		// Enumeration<E> elements()
		Vector<InputStream> v = new Vector<InputStream>();
		InputStream s1 = new FileInputStream("ByteArrayStreamDemo.java");
		InputStream s2 = new FileInputStream("CopyFileDemo.java");
		InputStream s3 = new FileInputStream("DataStreamDemo.java");
		v.add(s1);
		v.add(s2);
		v.add(s3);
		Enumeration<InputStream> en = v.elements();
		SequenceInputStream sis = new SequenceInputStream(en);
		BufferedOutputStream bos = new BufferedOutputStream(
				new FileOutputStream("Copy.java"));

		// 如何寫讀寫呢，其實很簡單，你就按照之前怎麼讀寫，如今仍是怎麼讀寫
		byte[] bys = new byte[1024];
		int len = 0;
		while ((len = sis.read(bys)) != -1) {
			bos.write(bys, 0, len);
		}

		bos.close();
		sis.close();
	}
}

序列化和反序列化

package cn.itcast_07;

import java.io.Serializable;

/*
 * 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關鍵字聲明不須要序列化的成員變量
 */
public class Person implements Serializable {
	private static final long serialVersionUID = -2071565876962058344L;

	private String name;

	// private int age;

	private transient int age;

	// int age;

	public Person() {
		super();
	}

	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 + "]";
	}
}

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)
 * 反序列化流:把文本文件中的流對象數據或者網絡中的流對象數據還原成對象。流數據 -- 對象(ObjectInputStream)
 */
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("林青霞", 27);

		// public final void writeObject(Object obj)
		oos.writeObject(p);

		// 釋放資源
		oos.close();
	}
}

Properties的概述和做爲Map集合的使用

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集合的使用
		// 下面這種用法是錯誤的，必定要看API，若是沒有<>，就說明該類不是一個泛型類,在使用的時候就不能加泛型
		// Properties<String, String> prop = new Properties<String, String>();

		Properties prop = new Properties();

		// 添加元素
		prop.put("it002", "hello");
		prop.put("it001", "world");
		prop.put("it003", "java");

		// System.out.println("prop:" + prop);

		// 遍歷集合
		Set<Object> set = prop.keySet();
		for (Object key : set) {
			Object value = prop.get(key);
			System.out.println(key + "---" + value);
		}
	}
}

Properties的特殊功能

package cn.itcast_08;

import java.util.Properties;
import java.util.Set;

/*
 * 特殊功能：
 * public Object setProperty(String key,String value)：添加元素
 * public String getProperty(String key):獲取元素
 * public Set<String> stringPropertyNames():獲取全部的鍵的集合
 */
public class PropertiesDemo2 {
	public static void main(String[] args) {
		// 建立集合對象
		Properties prop = new Properties();

		// 添加元素
		prop.setProperty("張三", "30");
		prop.setProperty("李四", "40");
		prop.setProperty("王五", "50");

		// public Set<String> stringPropertyNames():獲取全部的鍵的集合
		Set<String> set = prop.stringPropertyNames();
		for (String key : set) {
			String value = prop.getProperty(key);
			System.out.println(key + "---" + value);
		}
	}
}

/*
 * class Hashtalbe<K,V> { public V put(K key,V value) { ... } }
 * 
 * class Properties extends Hashtable { public V setProperty(String key,String
 * value) { return put(key,value); } }
 */

Properties的load()和store()功能

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;

/*
 * 這裏的集合必須是Properties集合：
 * public void load(Reader reader):把文件中的數據讀取到集合中
 * public void store(Writer writer,String comments):把集合中的數據存儲到文件
 * 
 * 單機版遊戲：
 * 		進度保存和加載。
 * 		三國羣英傳，三國志，仙劍奇俠傳...
 * 
 * 		呂布=1
 * 		方天畫戟=1
 */
public class PropertiesDemo3 {
	public static void main(String[] args) throws IOException {
		// myLoad();

		myStore();
	}

	private static void myStore() throws IOException {
		// 建立集合對象
		Properties prop = new Properties();

		prop.setProperty("林青霞", "27");
		prop.setProperty("武鑫", "30");
		prop.setProperty("劉曉曲", "18");
		
		//public void store(Writer writer,String comments):把集合中的數據存儲到文件
		Writer w = new FileWriter("name.txt");
		prop.store(w, "helloworld");
		w.close();
	}

	private static void myLoad() throws IOException {
		Properties prop = new Properties();

		// public void load(Reader reader):把文件中的數據讀取到集合中
		// 注意：這個文件的數據必須是鍵值對形式
		Reader r = new FileReader("prop.txt");
		prop.load(r);
		r.close();

		System.out.println("prop:" + prop);
	}
}

判斷文件中是否有指定的鍵，若是有就修改值的案例

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」
 * 
 * 分析：
 * 		A:把文件中的數據加載到集合中
 * 		B:遍歷集合，獲取獲得每個鍵
 * 		C:判斷鍵是否有爲"lisi"的，若是有就修改其值爲"100"
 * 		D:把集合中的數據從新存儲到文件中
 */
public class PropertiesTest {
	public static void main(String[] args) throws IOException {
		// 把文件中的數據加載到集合中
		Properties prop = new Properties();
		Reader r = new FileReader("user.txt");
		prop.load(r);
		r.close();

		// 遍歷集合，獲取獲得每個鍵
		Set<String> set = prop.stringPropertyNames();
		for (String key : set) {
			// 判斷鍵是否有爲"lisi"的，若是有就修改其值爲"100"
			if ("lisi".equals(key)) {
				prop.setProperty(key, "100");
				break;
			}
		}

		// 把集合中的數據從新存儲到文件中
		Writer w = new FileWriter("user.txt");
		prop.store(w, null);
		w.close();
	}
}

如何讓猜字小遊戲只能玩5次案例

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;

/*
 * 我有一個猜數字小遊戲的程序，請寫一個程序實如今測試類中只能用5次，超過5次提示：遊戲試玩已結束，請付費。
 */
public class PropertiesTest2 {
	public static void main(String[] args) throws IOException {
		// 讀取某個地方的數據，若是次數不大於5，能夠繼續玩。不然就提示"遊戲試玩已結束，請付費。"
		// 建立一個文件
		// File file = new File("count.txt");
		// if (!file.exists()) {
		// file.createNewFile();
		// }

		// 把數據加載到集合中
		Properties prop = new Properties();
		Reader r = new FileReader("count.txt");
		prop.load(r);
		r.close();

		// 我本身的程序，我固然知道里面的鍵是誰
		String value = prop.getProperty("count");
		int number = Integer.parseInt(value);

		if (number > 5) {
			System.out.println("遊戲試玩已結束，請付費。");
			System.exit(0);
		} else {
			number++;
			prop.setProperty("count", String.valueOf(number));
			Writer w = new FileWriter("count.txt");
			prop.store(w, null);
			w.close();

			GuessNumber.start();
		}
	}
}

NIO的介紹和JDK7下NIO的一個案例

package cn.itcast_09;

import java.io.IOException;
import java.nio.charset.Charset;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.ArrayList;

/*
 * 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)
 */
public class NIODemo {
	public static void main(String[] args) throws IOException {
		// public static long copy(Path source,OutputStream out)
		// Files.copy(Paths.get("ByteArrayStreamDemo.java"), new
		// FileOutputStream(
		// "Copy.java"));

		ArrayList<String> array = new ArrayList<String>();
		array.add("hello");
		array.add("world");
		array.add("java");
		Files.write(Paths.get("array.txt"), array, Charset.forName("GBK"));
	}
}