你需要的是什麼，直接評論留言。
分享是一種美德，分享更快樂！
1:登入注冊io版本案例(掌握)
要求，對着寫一遍。
cn.itcast.pojo user
cn.itcast.dao userdao
cn.itcast.dao.impl userdaoimpl(實作我不管)
cn.itcast.game guessnumber
cn.itcast.test
usertest
package cn.itcast.pojo;(1)
/**
* 這是使用者基本描述類
*
* @author 風清揚
* @version v1.1
*/
public class user {
// 使用者名
private string username;
// 密碼
private string password;
public user() {
}
public string getusername() {
return username;
public void setusername(string username) {
this.username = username;
public string getpassword() {
return password;
public void setpassword(string password) {
this.password = password;
package cn.itcast.dao;(2)
import cn.itcast.pojo.user;
* 這是針對使用者進行操作的接口
public interface userdao {
* 這是使用者登入功能
* @param username
* 使用者名
* @param password
* 密碼
* @return 傳回登入是否成功
public abstract boolean islogin(string username, string password);
* 這是使用者注冊功能
* @param user
* 要注冊的使用者資訊
public abstract void regist(user user);
package cn.itcast.dao.impl;(3)
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;
* 這是使用者操作的具體實作類(io版)
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;
// 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("使用者登入找不到資訊所在的檔案");
system.out.println("使用者登入失敗");
} finally {
if (br != null) {
br.close();
system.out.println("使用者登入釋放資源失敗");
return flag;
public void regist(user user) {
/*
* 為了讓注冊的資料能夠有一定的規則，我就自己定義了一個規則： 使用者名=密碼
bufferedwriter bw = null;
// 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();
system.out.println("使用者注冊失敗");
if (bw != null) {
bw.close();
system.out.println("使用者注冊釋放資源失敗");
package cn.itcast.game;(4)
import java.util.scanner;
* 這是猜數字小遊戲
public class guessnumber {
private guessnumber() {
public static void start() {
// 産生一個随機數
int number = (int) (math.random() * 100) + 1;
// 定義一個統計變量
int count = 0;
while (true) {
// 鍵盤錄入一個資料
scanner sc = new scanner(system.in);
system.out.println("請輸入資料(1-100)：");
int guessnumber = sc.nextint();
count++;
// 判斷
if (guessnumber > number) {
system.out.println("你猜的資料" + guessnumber + "大了");
} else if (guessnumber < number) {
system.out.println("你猜的資料" + guessnumber + "小了");
} else {
system.out.println("恭喜你，" + count + "次就猜中了");
package cn.itcast.test;(5)
import cn.itcast.dao.impl.userdaoimpl;
import cn.itcast.game.guessnumber;
* 使用者測試類
public class usertest {
public static void main(string[] args) {
// 為了能夠回來
// 歡迎界面，給出選擇項
system.out.println("--------------歡迎光臨--------------");
system.out.println("1 登入");
system.out.println("2 注冊");
system.out.println("3 退出");
system.out.println("請輸入你的選擇:");
// 鍵盤錄入選擇，根據選擇做不同的操作
// 為了後面的錄入資訊的友善，我所有的資料錄入全部用字元接收
string choicestring = sc.nextline();
// switch語句的多個地方要使用，我就定義到外面
userdao ud = new userdaoimpl();
// 經過簡單的思考，我選擇了switch
switch (choicestring) {
case "1":
// 登入界面，請輸入使用者名和密碼
system.out.println("--------------登入界面--------------");
system.out.println("請輸入使用者名：");
string username = sc.nextline();
system.out.println("請輸入密碼：");
string password = sc.nextline();
// 調用登入功能
// userdao ud = new userdaomimpl();
boolean flag = ud.islogin(username, password);
if (flag) {
system.out.println("登入成功,可以開始玩遊戲了");
system.out.println("你玩嗎?y/n");
string resultstring = sc.nextline();
if (resultstring.equalsignorecase("y")) {
// 玩遊戲
guessnumber.start();
system.out.println("你還玩嗎?y/n");
system.out.println("謝謝使用，歡迎下次再來");
system.exit(0);
// break; //這裡寫break，結束的是switch
system.out.println("使用者名或者密碼有誤,登入失敗");
case "2":
// 歡迎界面，請輸入使用者名和密碼
system.out.println("--------------注冊界面--------------");
string newusername = sc.nextline();
string newpassword = sc.nextline();
// 把使用者名和密碼封裝到一個對象中
user user = new user();
user.setusername(newusername);
user.setpassword(newpassword);
// 調用注冊功能
// 多态
// userdao ud = new userdaoimpl();
// 具體類使用
// userdaoimpl udi = new userdaoimpl();
ud.regist(user);
system.out.println("注冊成功");
case "3":
default:
2:資料操作流(操作基本類型資料的流)(了解)
(1)可以操作基本類型的資料
(2)流對象名稱
datainputstream
dataoutputstream
package cn.itcast_01;
import java.io.datainputstream;
import java.io.dataoutputstream;
import java.io.fileinputstream;
import java.io.fileoutputstream;
* 可以讀寫基本資料類型的資料
* 資料輸入流：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();
3:記憶體操作流(了解)
(1)有些時候我們操作完畢後，未必需要産生一個檔案，就可以使用記憶體操作流。
(2)三種
a:bytearrayinputstream,bytearrayoutputstream
b:chararrayreader,chararraywriter
c:stringreader,stringwriter
package cn.itcast_02;
import java.io.bytearrayinputstream;
import java.io.bytearrayoutputstream;
* 記憶體操作流：用于處理臨時存儲資訊的，程式結束，資料就從記憶體中消失。
* 位元組數組：
bytearrayinputstream
bytearrayoutputstream
* 字元數組：
chararrayreader
chararraywriter
* 字元串：
stringreader
stringwriter
public class bytearraystreamdemo {
// 寫資料
// 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();
4:列印流(掌握)
(1)位元組列印流，字元列印流
(2)特點：
a:隻操作目的地,不操作資料源
b:可以操作任意類型的資料
c:如果啟用了自動重新整理，在調用println()方法的時候，能夠換行并重新整理
d:可以直接操作檔案
問題：哪些流可以直接操作檔案呢?
看api，如果其構造方法能夠同時接收file和string類型的參數，一般都是可以直接操作檔案的
package cn.itcast_03;
import java.io.printwriter;
* 列印流
* 位元組流列印流
printstream
* 字元列印流
printwriter
* 列印流的特點：
a:隻有寫資料的，沒有讀取資料。隻能操作目的地，不能操作資料源。
b:可以操作任意類型的資料。
c:如果啟動了自動重新整理，能夠自動重新整理。
d:該流是可以直接操作文本檔案的。
哪些流對象是可以直接操作文本檔案的呢?
fileinputstream
fileoutputstream
filereader
filewriter
看api,查流對象的構造方法，如果同時有file類型和string類型的參數，一般來說就是可以直接操作檔案的。
流：
基本流：就是能夠直接讀寫檔案的
進階流：在基本流基礎上提供了一些其他的功能
public class printwriterdemo {
// 作為writer的子類使用
printwriter pw = new printwriter("pw.txt");
pw.write("hello");
pw.write("world");
pw.write("java");
pw.close();
* 1:可以操作任意類型的資料。
print()
println()
* 2:啟動自動重新整理
printwriter pw = new printwriter(new filewriter("pw2.txt"), true);
還是應該調用println()的方法才可以
這個時候不僅僅自動重新整理了，還實作了資料的換行。
*
其實等價于于：
bw.write();
public class printwriterdemo2 {
// 建立列印流對象
// printwriter pw = new printwriter("pw2.txt");
// write()是搞不定的，怎麼辦呢?
// 我們就應該看看它的新方法
// pw.print(true);
// pw.print(100);
// pw.print("hello");
pw.println("hello");
pw.println(true);
pw.println(100);
(3)列印流複制文本檔案
bufferedreader br = new bufferedreader(new filereader("a.txt"));
printwriter pw = new printwriter(new filewriter("b.txt"),true);
while((line=br.readline())!=null) {
pw.println(line);
* 需求：datastreamdemo.java複制到copy.java中
* 資料源：
datastreamdemo.java -- 讀取資料 -- filereader -- bufferedreader
* 目的地：
copy.java -- 寫出資料 -- filewriter -- bufferedwriter -- printwriter
public class copyfiledemo {
// 以前的版本
// 封裝資料源
// 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);
while((line=br.readline())!=null){
5:标準輸入輸出流(了解)
(1)system類下面有這樣的兩個字段
in 标準輸入流
out 标準輸出流
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 {
// 有這裡的講解我們就知道了，這個輸出語句其本質是io流操作，把資料輸出到控制台。
system.out.println("helloworld");
// 擷取标準輸出流對象
ps.println("helloworld");
ps.println();
// ps.print();//這個方法不存在
// system.out.println();
// system.out.print();
(2)三種鍵盤錄入方式
a:main方法的args接收參數
b:system.in通過bufferedreader進行包裝
bufferedreader br = new bufferedreader(new inputstreamreader(system.in));
c:scanner
import java.io.inputstreamreader;
* system.in 标準輸入流。是從鍵盤擷取資料的
* 鍵盤錄入資料：
a:main方法的args接收參數。
java helloworld hello world java
b:scanner(jdk5以後的)
string s = sc.nextline();
int x = sc.nextint()
c:通過字元緩沖流包裝标準輸入流實作
public class systemindemo {
// //擷取标準輸入流
// inputstream is = system.in;
// //我要一次擷取一行行不行呢?
// //行。
// //怎麼實作呢?
// //要想實作，首先你得知道一次讀取一行資料的方法是哪個呢?
// //readline()
// //而這個方法在哪個類中呢?
// //bufferedreader
// //是以，你這次應該建立bufferedreader的對象，但是底層還是的使用标準輸入流
// // bufferedreader br = new bufferedreader(is);
// //按照我們的推想，現在應該可以了，但是卻報錯了
// //原因是：字元緩沖流隻能針對字元流操作，而你現在是位元組流，是以不能是用?
// //那麼，我還就想使用了，請大家給我一個解決方案?
// //把位元組流轉換為字元流，然後在通過字元緩沖流操作
// inputstreamreader isr = new inputstreamreader(is);
// bufferedreader br= new bufferedreader(isr);
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);
(3)轉換流:
import java.io.outputstreamwriter;
* 轉換流的應用。
public class systemoutdemo2 {
// 擷取标準輸入流
// // 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.write("world");
bw.write("java");
(4)輸出語句的原理和如何使用字元流輸出資料
a:原理
b:把system.out用字元緩沖流包裝一下使用
bufferedwriter bw = new bufferedwriter(new outputstreamwriter(system.out));
6:随機通路流(了解)
(1)可以按照檔案指針的位置寫資料和讀資料。
(2)案例：
a:寫資料
b:讀資料
c:擷取和改變檔案指針的位置
package cn.itcast_05;
import java.io.randomaccessfile;
* 随機通路流：
randomaccessfile類不屬于流，是object類的子類。
但它融合了inputstream和outputstream的功能。
支援對檔案的随機通路讀取和寫入。
* public randomaccessfile(string name,string mode)：第一個參數是檔案路徑，第二個參數是操作檔案的模式。
模式有四種，我們最常用的一種叫"rw",這種方式表示我既可以寫資料，也可以讀取資料
public class randomaccessfiledemo {
// 建立随機通路流對象
randomaccessfile raf = new randomaccessfile("raf.txt", "rw");
int i = raf.readint();
// 該檔案指針可以通過 getfilepointer方法讀取，并通過 seek 方法設定。
system.out.println("目前檔案的指針位置是：" + raf.getfilepointer());
char ch = raf.readchar();
system.out.println(ch);
string s = raf.readutf();
// 我不想重頭開始了，我就要讀取a，怎麼辦呢?
raf.seek(4);
ch = raf.readchar();
// 怎麼玩呢?
raf.writeint(100);
raf.writechar('a');
raf.writeutf("中國");
raf.close();
7:合并流(了解)
(1)把多個輸入流的資料寫到一個輸出流中。
(2)構造方法：
a:sequenceinputstream(inputstream s1, inputstream s2)
b:sequenceinputstream(enumeration<? extends inputstream> e)
案例:a: a.txt+b.txt -- c.txt
package cn.itcast_06;
import java.io.bufferedoutputstream;
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 {
// 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();
b: a.txt+b.txt+c.txt -- d.txt
import java.util.enumeration;
import java.util.vector;
* e.txt -- f.txt
* a.txt+b.txt+c.txt -- d.txt
public class sequenceinputstreamdemo2 {
// 需求：把下面的三個檔案的内容複制到copy.java中
// bytearraystreamdemo.java,copyfiledemo.java,datastreamdemo.java
// sequenceinputstream(enumeration e)
// 通過簡單的回顧我們知道了enumeration是vector中的一個方法的傳回值類型。
// enumeration<e> elements()
vector<inputstream> v = new vector<inputstream>();
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);
8:序列化流(了解)
(1)可以把對象寫入文本檔案或者在網絡中傳輸
(2)如何實作序列化呢?
讓被序列化的對象所屬類實作序列化接口。
該接口是一個标記接口。沒有功能需要實作。
(3)注意問題：
把資料寫到檔案後，在去修改類會産生一個問題。
如何解決該問題呢?
在類檔案中，給出一個固定的序列化id值。
而且，這樣也可以解決黃色警告線問題
package cn.itcast_07;
import java.io.objectinputstream;
import java.io.objectoutputstream;
* 序列化流：把對象按照流一樣的方式存入文本檔案或者在網絡中傳輸。對象 -- 流資料(objectoutputstream)
* 反序列化流:把文本檔案中的流對象資料或者網絡中的流對象資料還原成對象。流資料 -- 對象(objectinputstream)
public class objectstreamdemo {
public static void main(string[] args) throws ioexception,
classnotfoundexception {
// 由于我們要對對象進行序列化，是以我們先自定義一個類
// 序列化資料其實就是把對象寫到文本檔案
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);
// 建立序列化流對象
objectoutputstream oos = new objectoutputstream(new fileoutputstream(
// 建立對象
person p = new person("林青霞", 27);
// public final void writeobject(object obj)
oos.writeobject(p);
oos.close();
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
* 我們在實際開發中，可能還需要使用以前寫過的資料，不能重新寫入。怎麼辦呢?
* 回想一下原因是因為它們的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) {
this.name = name;
this.age = age;
public string getname() {
return name;
public void setname(string name) {
public int getage() {
return age;
public void setage(int age) {
public string tostring() {
return "person [name=" + name + ", age=" + age + "]";
(4)面試題：
什麼時候序列化?
如何實作序列化?
什麼是反序列化?
9:properties(了解)
(1)是一個集合類，hashtable的子類
package cn.itcast_08;
import java.util.properties;
import java.util.set;
* properties:屬性集合類。是一個可以和io流相結合使用的集合類。
* properties 可儲存在流中或從流中加載。屬性清單中每個鍵及其對應值都是一個字元串。
* 是hashtable的子類，說明是一個map集合。
public class propertiesdemo {
// 作為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);
(2)特有功能
a:public object setproperty(string key,string value)
b:public string getproperty(string key)
c:public set<string> stringpropertynames()
* 特殊功能：
* public object setproperty(string key,string value)：添加元素
* public string getproperty(string key):擷取元素
* public set<string> stringpropertynames():擷取所有的鍵的集合
public class propertiesdemo2 {
// 建立集合對象
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);
* 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); } }
(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)
import java.io.reader;
import java.io.writer;
* 這裡的集合必須是properties集合：
* public void load(reader reader):把檔案中的資料讀取到集合中
* public void store(writer writer,string comments):把集合中的資料存儲到檔案
* 單機版遊戲：
進度儲存和加載。
三國群英傳，三國志，仙劍奇俠傳...
呂布=1
方天畫戟=1
public class propertiesdemo3 {
// myload();
mystore();
private static void mystore() throws ioexception {
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 {
// public void load(reader reader):把檔案中的資料讀取到集合中
// 注意：這個檔案的資料必須是鍵值對形式
reader r = new filereader("prop.txt");
prop.load(r);
r.close();
system.out.println("prop:" + prop);
(4)案例：
a:根據給定的檔案判斷是否有鍵為"lisi"的，如果有就修改其值為100
* 我有一個文本檔案(user.txt)，我知道資料是鍵值對形式的，但是不知道内容是什麼。
* 請寫一個程式判斷是否有“lisi”這樣的鍵存在，如果有就改變其實為”100”
* 分析：
a:把檔案中的資料加載到集合中
b:周遊集合，擷取得到每一個鍵
c:判斷鍵是否有為"lisi"的，如果有就修改其值為"100"
d:把集合中的資料重新存儲到檔案中
public class propertiestest {
// 把檔案中的資料加載到集合中
reader r = new filereader("user.txt");
// 周遊集合，擷取得到每一個鍵
// 判斷鍵是否有為"lisi"的，如果有就修改其值為"100"
if ("lisi".equals(key)) {
prop.setproperty(key, "100");
// 把集合中的資料重新存儲到檔案中
writer w = new filewriter("user.txt");
prop.store(w, null);
b:寫一個程式實作控制猜數字小遊戲程式不能玩超過5次
* 我有一個猜數字小遊戲的程式，請寫一個程式實作在測試類中隻能用5次，超過5次提示：遊戲試玩已結束，請付費。
public class propertiestest2 {
// 讀取某個地方的資料，如果次數不大于5，可以繼續玩。否則就提示"遊戲試玩已結束，請付費。"
// 建立一個檔案
// file file = new file("count.txt");
// if (!file.exists()) {
// file.createnewfile();
// 把資料加載到集合中
reader r = new filereader("count.txt");
// 我自己的程式，我當然知道裡面的鍵是誰
string value = prop.getproperty("count");
int number = integer.parseint(value);
if (number > 5) {
system.out.println("遊戲試玩已結束，請付費。");
number++;
prop.setproperty("count", string.valueof(number));
writer w = new filewriter("count.txt");
10:nio(了解)
(1)jdk4出現的nio，對以前的io操作進行了優化，提供了效率。但是大部分我們看到的還是以前的io
(2)jdk7的nio的使用
path:路徑
paths:通過靜态方法傳回一個路徑
files:提供了常見的功能
複制文本檔案
把集合中的資料寫到文本檔案
package cn.itcast_09;
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 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"));
java幫幫交流群