集合到文件数据排序改进版

键盘录入5个学生信息(姓名,语文成绩,数学成绩,英语成绩)。要求按照成绩总分从高到低写入文本文件
格式：姓名,语文成绩,数学成绩,英语成绩举例：林青霞,98,99,100

定义学生类
创建TreeSet集合，通过比较器排序进行排序
键盘录入学生数据
创建学生对象，把键盘录入的数据对应赋值给学生对象的成员变量
把学生对象添加到TreeSet集合
创建字符缓冲输出流对象
遍历集合，得到每一个学生对象
把学生对象的数据拼接成指定格式的字符串
调用字符缓冲输出流对象的方法写数据
释放资源

学生类

package com.itdemo_26;public class Student01 {private String name;private int chinese;private int math;private int english;public Student01() {}public Student01(String name, int chinese, int math, int english) {this.name = name;this.chinese = chinese;this.math = math;this.english = english;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getChinese() {return chinese;}public void setChinese(int chinese) {this.chinese = chinese;}public int getMath() {return math;}public void setMath(int math) {this.math = math;}public int getEnglish() {return english;}public void setEnglish(int english) {this.english = english;}//和方法public int getSum(){return this.chinese+this.math+this.english;}
}

测试类

package com.itdemo_26;import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Comparator;
import java.util.Scanner;
import java.util.TreeSet;public class TreeSetFileDemo {public static void main(String[] args) throws IOException {//        2. 创建TreeSet集合，通过比较器排序进行排序TreeSet<Student01> ts = new TreeSet<Student01>(new Comparator<Student01>() {@Overridepublic int compare(Student01 s1, Student01 s2) {//比较总成绩高低//s.getSum - this.getSum()从大到小//this.getsum -s.getSum() 从小到大int num = s2.getSum()-s1.getSum();
//                int num = s1.getSum()-s2.getSum();//自然排序//次要分析//姓名或成绩进行从自然排序int num2 = num == 0?s1.getChinese()-s2.getChinese():num;int num3 = num2 ==0?s1.getMath()-s2.getMath():num2;int num4 = num3 == 0?s1.getName().compareTo(s2.getName()):num3;return num4;}});
//3. 键盘录入学生数据for(int i=0;i<5;i++) {Scanner sc = new Scanner(System.in);System.out.println("请输入第"+(i+1)+"个学生信息");System.out.println("姓名");String name = sc.nextLine();System.out.println("语文");int chinese = sc.nextInt();System.out.println("数学");int math = sc.nextInt();System.out.println("英语");int english = sc.nextInt();//4. 创建学生对象，把键盘录入的数据对应赋值给学生对象的成员变量Student01 s = new Student01();s.setName(name);s.setChinese(chinese);s.setMath(math);s.setEnglish(english);//5. 把学生对象添加到TreeSet集合ts.add(s);}//6. 创建字符缓冲输出流对象BufferedWriter bw  = new BufferedWriter(new FileWriter("src\\ts.txt"));
//7. 遍历集合，得到每一个学生对象for (Student01 s : ts){//8. 把学生对象的数据拼接成指定格式的字符串StringBuilder sb = new StringBuilder();sb.append(s.getName()).append(",").append(s.getChinese()).append(",").append(s.getMath()).append(",").append(s.getEnglish()).append(",").append(s.getSum());//9. 调用字符缓冲输出流对象的方法写数据bw.write(sb.toString());bw.newLine();bw.flush();}
//10. 释放资源bw.close();}
}

案例: 复制单级文件夹

需求
把“E:\itcast”这个文件夹复制到模块目录下
步骤

创建数据源目录File对象，路径是E:\itcast
获取数据源目录File对象的名称
创建目的地目录File对象，路径由(模块名+第2步获取的名称)组成
判断第3步创建的File是否存在，如果不存在，就创建
获取数据源目录下所有文件的File数组
遍历File数组，得到每一个File对象，该File对象，其实就是数据源文件
获取数据源文件File对象的名称
创建目的地文件File对象，路径由(目的地目录+第7步获取的名称)组成
复制文件
由于不清楚数据源目录下的文件都是什么类型的，所以采用字节流复制文件
采用参数为File的构造方法

package com.itdemo_26;import java.io.*;public class CopyFolderDemo {public static void main(String[] args) throws IOException {//        1. 创建数据源目录File对象，路径是E:\itcastFile srcFolder = new File("D:\\itcast");
//        2. 获取数据源目录File对象的名称String srcFolderName = srcFolder.getName();
//        3. 创建目的地目录File对象，路径由(模块名+第2步获取的名称)组成File destFolder = new File("src", srcFolderName);
//        4. 判断第3步创建的File是否存在，如果不存在，就创建if (!destFolder.exists()) {destFolder.mkdir();}
//        5. 获取数据源目录下所有文件的File数组//返回一个抽象路径名数组，表示由该抽象路径名表示的目录中的文件。File[] listFiles = srcFolder.listFiles();
//        6. 遍历File数组，得到每一个File对象，该File对象，其实就是数据源文件for (File srcFile : listFiles) {//        7. 获取数据源文件File对象的名称String srcFileName = srcFile.getName();//        8. 创建目的地文件File对象，路径由(目的地目录+第7步获取的名称)组成File destFile = new File(destFolder, srcFileName);//        9. 复制文件copyFile(srcFile, destFile);}}//        由于不清楚数据源目录下的文件都是什么类型的，所以采用字节流复制文件
//                采用参数为File的构造方法private static void copyFile(File srcFile,File destFile)throws IOException {BufferedInputStream bis = new BufferedInputStream(new FileInputStream(srcFile));BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destFile));byte[] bys = new byte[1024];int len;while ((len=bis.read(bys))!=-1){bos.write(bys,0,len);}bos.close();bis.close();}
}

案例: 复制多级文件夹

需求:
把“E:\itcast”这个文件夹复制到 F盘目录下
步骤

创建数据源File对象，路径是E:\itcast
创建目的地File对象，路径是F:\
写方法实现文件夹的复制，参数为数据源File对象和目的地File对象
判断数据源File是否是文件
是文件：直接复制，用字节流
不是文件：在目的地下创建该目录遍历获取该目录下的所有文件的File数组，得到每一个File对象回到3继续(递归)

package com.itdemo_26;import java.io.*;public class CopyFoldersDemo {public static void main(String[] args) throws IOException{//创建数据源File对象,路径D:\\itcastFile srcFile = new File("D:\\itcast");//创建目的地FIle对象,路径D:\\BaiduNetdiskDownloadFile destFile = new File("D:\\BaiduNetdiskDownload\\");//写方法实现文件夹的复制,参数为数据源File对象和目的地FIle对象copyFolder(srcFile,destFile);}//复制文件夹private static void copyFolder(File srcFile,File destFile) throws IOException {//判断数据源FIle是否是目录if (srcFile.isDirectory()) {String srcFileName = srcFile.getName();File newFolder = new File(destFile, srcFileName);//D:\\baiduNetdiskDownloadif (!newFolder.exists()) {//测试此抽象路径名表示的文件或目录是否存在。newFolder.mkdir();}//获取数据源File下所有文件或者目录的File数组File[] fileArray = srcFile.listFiles();//遍历File数组,得到每一个fiel对象for (File file : fileArray) {//把该File作为数据源FIle对象,递归调用复制文件夹的方法copyFolder(file, newFolder);}}else{//说明是文件,直接复制,用字节流File newFile = new File(destFile,srcFile.getName());copyFile(srcFile,newFile);}}//字节缓冲流复制文件private static void copyFile(File srcFile,File destFile)throws IOException {//输入流BufferedInputStream bis = new BufferedInputStream(new FileInputStream(srcFile));//输出流BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destFile));//字节数组byte[] bys = new byte[1024];int len;while ((len=bis.read(bys))!=-1){bos.write(bys,0,len);}bos.close();bis.close();}
}

复制文件的异常处理

基本做法

public class CopyFileDemo {public static void main(String[] args) {}//try...catch...finallyprivate static void method(){FileReader fr = null;FileWriter fw = null;try {fr = new FileReader("fr.txt");fw = new FileWriter("fw.txt");char[] chs = new char[1024];int len;while ((len=fr.read())!=-1) {fw.write(chs, 0, len);}} catch (IOException e) {e.printStackTrace();}finally{if (fw!=null){try {fw.close();} catch (IOException e) {e.printStackTrace();}}if (fr!=null){try {fr.close();} catch (IOException e) {e.printStackTrace();}}}}/*之前的处理方法,将异常抛出private static void method()throws IOException {FileReader fr = new FileReader("fr.txt");FileWriter fw = new FileWriter("fw.txt");char[] chs = new char[1024];int len;while ((len=fr.read())!=-1){fw.write(chs,0,len);}}*/
}

JDk7之后版本

public class CopyFileDemo {public static void main(String[] args) {}//JDK7之后private static void method(){try {FileReader fr = new FileReader("fr.txt");FileWriter fw = new FileWriter("fw.txt");char[] chs = new char[1024];int len;while ((len=fr.read())!=-1){fw.write(chs,0,len);}}catch (IOException e){e.printStackTrace();}}
}

JDK9版本

public class CopyFileDemo {public static void main(String[] args) {}private static void method() throws IOException {FileReader fr = new FileReader("fr.txt");FileWriter fw = new FileWriter("fw.txt" );try (fr;fw){char[] chs = new char[1024];int len;while((len=fr.read())!=-1){fw.write(chs,0,len);}}catch (IOException e){e.printStackTrace();}}
}

特殊操作流

标准输入输出流

System类中有两个静态成员变量

public static final InputStream in: 标准输入流,通常该流对应于键盘输入或由主机环节或者用户指定的另一个输入员
public static final PrintStream out: 标准输出流,通常该流对应于显示输出或主机环境或用户指定的另一个输出目标

自己实现键盘录入数据

BufferedReader br = new BufferedReader(new InputStreamReader(System.in);

写起来太麻烦,java就提供了一个类实现键盘录入

Scanner sc = new Scanner(System.in);

package com.itdemo_26;import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.Scanner;public class SystemInDemo {public static void main(String[] args) throws IOException {/*//public static final InputStream in : 标准输入法InputStream is = System.in;int by;while ((by=is.read())!=-1){System.out.print((char)by);}//如何把字节流转换为字符流,用转换流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());System.out.println("你输入的是"+i);//自己实现键盘录入数据太麻烦了, 所以java提供了一个类供我们使用Scanner sc = new Scanner(System.in);}
}

标准输出流

System类中有两个静态的成员变量

public static final InputStream in: 标准输入流,通常该流对应与键盘输入或主机环境或用户指定的另一个输入源
public static final PrintStream out :标准输出流, 通常该流对应于显示输出或由主机环境或用户指定的另一个输出目标

输出语句的本质:是一个标准的输出流

PrintStream ps =System.out;
PrintStream类有的方法,System.out都可以使用

package com.itdemo_26;import java.io.PrintStream;public class SystemOutDemo {public static void main(String[] args) {//public static final PrintStream out：标准输出流PrintStream ps = System.out;//能够方便的打印各种数据值
//        ps.print("hello");
//        ps.print(100);
//        ps.println("hello");
//        ps.println(100);//System.out的本质是一个字节输出流System.out.println("hello");System.out.println(100);}
}

打印流

打印流分类

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

打印流的特点

只负责输出数据,不负责读取数据
有自己的特有方法
永远不会抛出IOException

字节打印流

PrintStream(String fileName): 使用指定的文件名创建新的打印流
使用继承父类的方法写数据,查看的时候会转码,使用自己的特有方法写数据,查看的数据原样输出
可以改变输出语句的目的地 public static void setOut(PrintStream out): 重新分配"标准"输出流

package com.itdemo_27;import java.io.IOException;
import java.io.PrintStream;public class PrintStreamDemo {public static void main(String[] args) throws IOException {//PrintStream(String fileName):使用指定的文件名创建新的打印流PrintStream ps = new PrintStream("src\\ps.txt");//写数据//字节输出流有的方法
//        ps.write(97);//a/*//使用特有方法写数据ps.print(97);//97ps.println();ps.print(98);//98
*/ps.println(97);ps.println(99);ps.close();}
}

字符打印流

package com.itdemo_27;import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;public class PrintWriterDemo {public static void main(String[] args) throws IOException {/*//PrintWriter(String fileName): 使用指定的文件名创建一个新的PrintWriter,而不需要自动执行行刷新PrintWriter pw = new PrintWriter("src\\pw.txt");//        pw.write("hello");
//        pw.write("\r\n");
//        pw.write("java");
//        pw.flush();pw.println("hello");pw.flush();*///PrintWriter(Writer out, boolean autoFlush)：创建一个新的PrintWriterPrintWriter pw = new PrintWriter(new FileWriter("src\\pw.txt"),true);pw.println("hello");pw.close();}
}

案例: 复制java文件(打印流改进)

案例需求
把模块目录下的PrintStreamDemo.java 复制到模块目录下的 Copy.java
分析步骤
根据数据源创建字符输入流对象
根据目的地创建字符输出流对象
读写数据，复制文件
释放资源

package com.itdemo_27;import java.io.*;public class CopyJavaDemo {public static void main(String[] args) throws IOException {/*//        根据数据源创建字符输入流对象BufferedReader br = new BufferedReader(new FileReader("src\\copy.java"));
//        根据目的地创建字符输出流对象BufferedWriter bw = new BufferedWriter(new FileWriter("src\\copy03.java"));
//        读写数据，复制文件String line;while ((line = br.readLine())!=null){bw.write(line);bw.newLine();bw.flush();}*///        根据数据源创建字符输入流对象BufferedReader br = new BufferedReader(new FileReader("src\\copy.java"));
//        根据目的地创建字符输出流对象PrintWriter bw = new PrintWriter(new FileWriter("src\\copy03.java"),true);String line;while ((line=br.readLine())!=null){bw.println(line);}//                释放资源bw.close();br.close();}
}

对象序列化流

对象序列化介绍

对象序列化: 就是将对象保存到磁盘中,或者在网络中传输对象
这种机制就是使用一个字节序列表示一个对象,该字节序列包含: 对象的类型,对象的数据和对象中存储的属性等信息
字节序列写到文件后,相当于文件中持久保存了一个对象的信息
反之,该字节序列还可以从文件中读取回来,重构对象,对它进行反序列化.

对象序列化流: ObjectOutputStream

将java对象的原始数据类型和图形写入OutputStream. 可以使用ObjectIntputStream读取(重构)对象,可以通过使用流的文件来实现对象的持久存储. 如果流是网络套接字流,则可以在另一个主机上或另一个进程中重构对象

构造方法

ObjectOutputStream(OutputStream out) : 创建一个写入指定的OutputStream的ObjectOutStream

序列化对象的方法:
void writeObject(Object obj): 将指定的对象写入ObjectOutputStream

注意:

一个对象想要被序列化,该对象所属的类必须实现Serializable 接口
Serializable是一个标记接口,实现该接口,不需要重写任何方法

学生类

package com.itdemo_27;import java.io.Serializable;public class Student implements Serializable {private String name;private int age;public Student() {}public Student(String name, int age) {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;}
}

测试类

package com.itdemo_27;import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;/*
NotSerializableException: 抛出一个实例需要一个Serializable接口,序列化运行时或实例的类可能会出现此异常
类的序列化由实现java.io.Serializable接口的类启用。 不实现此接口的类将不会使任何状态序列化或反序列化。*/
public class ObjectOutputStreamDemo {public static void main(String[] args) throws IOException {//ObjectOutputStream(OutputStream out)：创建一个写入指定的OutputStream 的ObjectOutputStreamObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("src\\oos.txt"));//创建对象Student s = new Student("林青霞",30);//void writeObject(Object obj): 将指定的对象写入ObjectOutputStreamoos.writeObject(s);//释放资源oos.close();}
}

对象反序列化流

对象反序列化流: ObjectInputStream

ObjectInputStream 反序列化先使用ObjectOutputStream编写的原始数据和对象

构造方法

ObjectInputStream(InputStream in) : 创建从指定的InputStream读取的ObjectInputStream

反序列化对象的方法

Object readObject() 从ObjectInputStream读取一个对象

package com.itdemo_27;import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;public class ObjectInputStreamDemo {public static void main(String[] args) throws IOException, ClassNotFoundException {//ObjectInputStream(InputStream in)：创建从指定的InputStream读取的 ObjectInputStreamObjectInputStream ois = new ObjectInputStream(new FileInputStream("src\\oos.txt"));//Object readObject()：从ObjectInputStream读取一个对象Object obj = ois.readObject();//向下转型Student s = (Student) obj;System.out.println(s.getName()+","+s.getAge());ois.close();}
}

特殊操作流

对象序列化流

serialVersionUID
用对象序列化流序列化了一个对象后，假如我们修改了对象所属的类文件，读取数据会不会出问题呢？

会出问题，会抛出InvalidClassException异常

如果出问题了，如何解决呢？

重新序列化给对象所属的类加一个serialVersionUID private static ﬁnal long serialVersionUID = 42L;

transient 如果一个对象中的某个成员变量的值不想被序列化，又该如何实现呢？

给该成员变量加transient关键字修饰，该关键字标记的成员变量不参与序列化过程

package com.itdemo_27;import java.io.Serializable;public class Student implements Serializable {private static final long serialVersionUID = 43L;private String name;
//    private int age;private transient int age;public Student() {}public Student(String name, int age) {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 "Student{" +
//                "name='" + name + '\'' +
//                ", age=" + age +
//                '}';
//    }
}

package com.itdemo_27;import java.io.*;/*
用对象序列化流序列化一个对象后,假如我们修改了对象所属的类文件,读取数据会不会出问题能java.io.InvalidClassException:当序列化运行时检测到类中的以下问题之一时抛出类的串行版本与流中读取的类描述符的类型不匹配该类包含未知的数据类型该类没有可访问的无参构造函数com.itdemo_27.Student; local class incompatible:stream classdesc serialVersionUID = -2513039094460410346,local class serialVersionUID = -8067741464344316131如果出问题了，如何解决呢？重新序列化 给对象所属的类加一个serialVersionUID private static ﬁnal long serialVersionUID = 42L;
transient 如果一个对象中的某个成员变量的值不想被序列化，又该如何实现呢？
给该成员变量加transient关键字修饰，该关键字标记的成员变量不参与序列化过程*/
public class ObjectStreamDemo {public static void main(String[] args) throws IOException, ClassNotFoundException {//在Student里添加private static final long serialVersionUID = 43L;
//        后修改重新输出后,修改仍然可以输出内容//write();read();}//反序列化private static void read() throws IOException, ClassNotFoundException {ObjectInputStream ois = new ObjectInputStream(new FileInputStream("src\\oos.txt"));Object obj = ois.readObject();Student s = (Student) obj;System.out.println(s.getName()+","+s.getAge());ois.close();}//序列化private static void write() throws IOException {ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("src\\oos.txt"));Student s = new Student("林青霞",30);oos.writeObject(s);oos.close();}
}

Properties

Properties概述

是一个Map体系的集合类
Properties可以保存到流中或从流中加载
属性列表中的每一个键及其对应的值都是一个字符串

package com.itdemo_27;import java.util.Properties;
import java.util.Set;public class PropertiesDemo01 {public static void main(String[] args) {//创建集合对象
//        Properties<String,String> prop = new Properties<String,String>();//方法错误Properties prop = new Properties();//存储元素prop.put("ithema001","林青霞");prop.put("ithema002","张志东");prop.put("ithema003","李时珍");//遍历集合Set<Object> keySet = prop.keySet();for (Object key : keySet){Object value = prop.get(key);System.out.println(key+","+value);}}
}

Properties作为集合的特有方法

package com.itdemo_27;import java.util.Properties;
import java.util.Set;/*
Object setProperty(String key, String value)
设置集合的键和值，都是String类型，底层调用 Hashtable方 法 put
String getProperty(String key) 使用此属性列表中指定的键搜索属性
Set stringPropertyNames()
从该属性列表中返回一个不可修改的键集，其中键及其对应的 值是字符串*/
public class PropertiesDemo02 {public static void main(String[] args) {//创建集合对象Properties prop = new Properties();//Object setProperty(String key, String value) 设置集合的键和值，都是String类型，底层调用 Hashtable方 法 putprop.setProperty("itheima001","林青霞");/*Object setProperty(String key, String value) {return put(key, value);}Object put(Object key, Object value) {return map.put(key, value);}*/prop.setProperty("itheima002","张仲景");prop.setProperty("itheima003","礼拜");//        String getProperty(String key) 使用此属性列表中指定的键搜索属性
//        System.out.println(prop.getProperty("itheima001"));//林青霞
//        System.out.println(prop.getProperty("itheima0011"));//null//        Set stringPropertyNames() 从该属性列表中返回一个不可修改的键集，其中键及其对应的 值是字符串Set<String> names = prop.stringPropertyNames();//获取键的集合for (String key :names){//            System.out.println(key);//键String value = prop.getProperty(key);System.out.println(key+","+value);}System.out.println(prop);//{itheima003=礼拜, itheima001=林青霞, itheima002=张仲景}}
}

Properties和IO流结合的方法

package com.itdemo_27;import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Properties;public class PropertiesDemo03 {public static void main(String[] args) throws IOException {//把集合中的数据保存到文件myStore();//把文件中的数据加载到集合myLoad();}private static void myLoad() throws IOException{Properties prop = new Properties();//void load(Reader reader) 从输入字符流读取属性列表（键和元素对）FileReader fr =  new FileReader("src\\fw.txt");prop.load(fr);fr.close();System.out.println(prop);}private static void myStore() throws IOException {//创建对象Properties prop = new Properties();prop.setProperty("itdemo001","林青霞");prop.setProperty("itdemo002","李白");prop.setProperty("itdemo003","杜甫");//        void store(Writer writer, String comments)将此属性列表（键和元素对）写入此 Properties表中，以适合使用 load(Reader)方法的格式写入输出字符流FileWriter fw = new FileWriter("src\\fw.txt");prop.store(fw,null);//comments描述信息,若不想进行任何描述就nullfw.close();}
}

案例: 游戏次数

需求: 请写程序实现猜数字小游戏,只能试玩3次,如果还想玩,提示游戏试玩已结束,想玩请充值
思路:

写一个游戏类,里面有一个猜数字的小游戏
写一个测试类,测试类中有main()方法,main()方法中按照下面步骤完成:
A: 从文件中读取数据道Properties集合,用load()方法实现
文件已经存在: game.txt
里面有一个数据值 : count=0;
B: 通过Properties集合获取到玩游戏的次数
C: 判断次数是否到3次了
如果到了,输出提示,游戏试玩已结束,想玩请充值
如果不到3次:
玩游戏,
次数+1,重新写回文件,用Properties的store() 方法实现

游戏类

package com.itdemo_27;import java.util.Random;
import java.util.Scanner;public class GuessNumber {public GuessNumber() {}public static void start(){//要完成猜数字的游戏,首先需要一个要猜的数字,使用随机数生成数字,范围1到00Random r = new Random();int number = r.nextInt(100)+1;while (true){//使用程序实现猜数字,每次输入猜测的数字值,需要使用键盘录入Scanner sc = new Scanner(System.in);System.out.println("请输入你猜的数字");int guessNumber = sc.nextInt();//比较输入的数字和系统产生的数字,if(guessNumber>number){System.out.println("你猜的数"+guessNumber+"大了");}else if(guessNumber<number){System.out.println("你猜的数"+guessNumber+"小了");}else{System.out.println("你猜对了");break;}}}
}

测试类

package com.itdemo_27;import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Properties;public class ProtertiesTest {public static void main(String[] args) throws IOException {//从文件中读取数据到properties类中,用load方法实现Properties prop = new Properties();FileReader fr = new FileReader("src\\game.txt");prop.load(fr);fr.close();//通过Properties集合获取到玩游戏的次数String count = prop.getProperty("count");int number = Integer.parseInt(count);//判断次数是否到达三次if(number >=3){//如果到了,给出提示System.out.println("游戏试玩已结束,想玩请充值");}else{//玩游戏GuessNumber.start();number++;prop.setProperty("count",String.valueOf(number));FileWriter fw = new FileWriter("src\\game.txt");prop.store(fw,null);fw.close();}}
}

笔记19-IO流Properties集合相关推荐

Java基础巩固（二）异常,多线程，线程池，IO流,Properties集合,IO工具类，字符流，对象流，Stream，Lambda表达式
一.异常,多线程学习目标 : 异常的概述异常的分类异常的处理方式自定义异常多线程入门 1 异常的概述 1.1 什么是异常? 异常就是程序出现了不正常情况 , 程序在执行过程中 , 数据导致程 ...
IO流和集合的交集Properties类的介绍。
Properties类继承了Hashtable,Hashtable实现了Map<K,V>接口.该类的键值对都是字符串. Properties的构造方法:Properties pro = ...
IO流案例以及特殊操作流/对象对象序列化流/Properties集合
文章目录 IO流案例复制单级文件夹复制多级文件夹 IO特殊操作流标准输入流字节打印流字符打印流对象序列化流 serialVersionUID&transient Propertie ...
java学习笔记-初学IO流
目录什么是IO IO流的分类 Java中的IO流 java中需要掌握的流:16个字节流 java.io.FileInputStream(字节输入流) java.io.FileOutputStre ...
【java笔记】IO流（1）：IO流概述，字节输出/输入流读写文件
IO概述: I: input( 读取 ) 把硬盘中的数据,读取到内存中使用 O: output(写入) 把内存中的数据,写入到硬盘中保存流:数据(字符,字节)1个字符=2个字节 ,1个字节=8个二 ...
（Java笔记）IO流的六类16种流方式
目录一.文件流 1.字节流 2.字符流二.转换流(字节流转字符流) 1.输入 2.输出三.缓冲流 1.字节流 2.字符流+转换流四.数据流 1.DataInputStream 2.DataOu ...
【Java笔记】IO流（2）：字符流
当使用字节流读取文件时,遇到中文字符时,可能不会显示完整的字符,因为一个中文字符可能占用多个字节储存.所以java提供一些字符流类,以字符为单位读写数据,专门处理文本文件一个汉字储存: GBK编码: ...
Java基础IO流概述、字符流、字节流、流操作规律、File类、Properties类、打印流、序列流
IO流:(Input Output)流字符流的由来:其实就是字节流读取文字字节数据后,不直接操作而是先查指定的码表,获取对应的文字进行操作简单说:字符流 = 字节流 + 编码表字节流的两个顶层父 ...
小码笔记17：IO流
小码笔记:IO流一.File类 1.构造方法 2.常用成员变量 3.常用方法 4.递归 5.文件过滤器二.IO流概述 1.分类选择 2.IO异常的处理 3.Properties属性集三.字节流 ...
java基础知识总结：基础知识、面向对象、集合框架、多线程、jdk1.5新特性、IO流、网络编程
目录一.基础知识: 二.面向对象三.集合框架四.多线程: 五.jdk1.5的新特性六.IO流七.网络编程: 一.基础知识: 1.JVM.JRE和JDK的区别: JVM(Java Virtua ...

笔记19-IO流Properties集合

集合到文件数据排序改进版

案例: 复制单级文件夹

案例: 复制多级文件夹

复制文件的异常处理

基本做法

JDk7之后版本

JDK9版本

特殊操作流

标准输入输出流

标准输出流

打印流

字节打印流

字符打印流

案例: 复制java文件(打印流改进)

对象序列化流

对象反序列化流

特殊操作流

对象序列化流

Properties

Properties作为集合的特有方法

Properties和IO流结合的方法

案例: 游戏次数

笔记19-IO流Properties集合相关推荐

最新文章

热门文章