读写基本数据类型（DataInputStream）

• 可以读写基本数据类型的数据

数据输入流：DataInputStream

• DataInputStream(InputStream in)

数据输出流：DataOutputStream

• DataOutputStream(OutputStream out)

案例（读写基本数据类型）

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();}
}

内存操作流：（ByteArrayInputStream）

• 用于处理临时存储信息的，程序结束，数据就从内存中消失。

字节数组：

• ByteArrayInputStream
• ByteArrayOutputStream

字符数组：

• CharArrayReader
• CharArrayWriter

字符串：

• StringReader
• StringWriter

案例（内存操作流）

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和PrintStream）

• 字节流打印流 PrintStream
• 字符打印流 PrintWriter
• 打印流的特点：
  A:只有写数据的，没有读取数据。只能操作目的地，不能操作数据源。
  B:可以操作任意类型的数据。
  C:如果启动了自动刷新，能够自动刷新。
  D:该流是可以直接操作文本文件的。
• 哪些流对象是可以直接操作文本文件的呢?
  FileInputStream
  FileOutputStream
  FileReader
  FileWriter
  PrintStream
  PrintWriter
• 看API,查流对象的构造方法，如果同时有File类型和String类型的参数，一般来说就是可以直接操作文件的。
• 流：
  基本流：就是能够直接读写文件的
  高级流：在基本流基础上提供了一些其他的功能

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();}
}

1:可以操作任意类型的数据。

• print()
• println()

2:启动自动刷新

• PrintWriter pw = new PrintWriter(new FileWriter(“pw2.txt”), true);
• 还是应该调用println()的方法才可以
• 这个时候不仅仅自动刷新了，还实现了数据的换行。
• println()
• 其实等价于于：
• bw.write();
• bw.newLine();
• bw.flush();

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();}
}

案例（打印文件）

需求：DataStreamDemo.java复制到Copy.java中

• 数据源：
• DataStreamDemo.java – 读取数据 – FileReader – BufferedReader
• 目的地：
• Copy.java – 写出数据 – FileWriter – BufferedWriter – PrintWriter

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();}
}

标准输入输出流（InputStream和PrintStream）

• System类中的两个成员变量：
  public static final InputStream in “标准”输入流。
  public static final PrintStream out “标准”输出流。

InputStream is = System.in;
PrintStream ps = System.out;
案例（输出流）

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();}
}

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

案例（键盘录入）

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);}
}

随机访问流：（RandomAccessFile）

RandomAccessFile类

• RandomAccessFile类不属于流，是Object类的子类。
• 但它融合了InputStream和OutputStream的功能。
• 支持对文件的随机访问读取和写入。
• public RandomAccessFile(String name,String mode)：第一个参数是文件路径，第二个参数是操作文件的模式。
• 模式有四种，我们最常用的一种叫"rw",这种方式表示我既可以写数据，也可以读取数据

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();}
}

合并流（SequenceInputStream）

• 以前的操作：

• a.txt – b.txt

• c.txt – d.txt

• e.txt – f.txt

• 现在想要：

• a.txt+b.txt+c.txt – d.txt
  SequenceInputStream(InputStream s1, InputStream s2)
  需求：把ByteArrayStreamDemo.java和DataStreamDemo.java的内容复制到Copy.java中

• 需求：把下面的三个文件的内容复制到Copy.java中
  ByteArrayStreamDemo.java,CopyFileDemo.java,DataStreamDemo.java
  SequenceInputStream(Enumeration e)
  通过简单的回顾我们知道了Enumeration是Vector中的一个方法的返回值类型。
  Enumeration elements()

案例（合并2个流）

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();}
}

序列化流和反序列化流ObjectOutputStream和ObjectInputStream

• 序列化流：
  把对象按照流一样的方式存入文本文件或者在网络中传输。对象 – 流数据(ObjectOutputStream)
  方法：
  public final void writeObject(Object obj)
  public final Object readObject(Object obj);

• 反序列化流:
  把文本文件中的流对象数据或者网络中的流对象数据还原成对象。流数据 – 对象(ObjectInputStream)

• NotSerializableException:未序列化异常

• 类通过实现 java.io.Serializable 接口以启用其序列化功能。未实现此接口的类将无法使其任何状态序列化或反序列化。

• 该接口居然没有任何方法，类似于这种没有方法的接口被称为标记接口。

• 修改了student类
  java.io.InvalidClassException:
  cn.itcast_07.Person; local class incompatible:
  stream classdesc serialVersionUID = -2071565876962058344,
  local class serialVersionUID = -8345153069362641443
  在类中加入private static final long serialVersionUID = -2071565876962058344L;就可以解决UID问题
  在类中加入private transient int age;可以不用序列化

• 注意：
  我一个类中可能有很多的成员变量，有些我不想进行序列化。请问该怎么办呢?
  使用transient关键字声明不需要序列化的成员变量

案例（序列化）

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();}
}
---------------------------------------------------------
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;}@Overridepublic String toString() {return "Person [name=" + name + ", age=" + age + "]";}
}

Properties:属性集合类

• Properties:属性集合类。是一个可以和IO流相结合使用的集合类。
• Properties 可保存在流中或从流中加载。属性列表中每个键及其对应值都是一个字符串。
• 是Hashtable的子类，说明是一个Map集合。
• 特殊功能：
  public Object setProperty(String key,String value)：添加元素
  public String getProperty(String key):获取元素
  public Set stringPropertyNames():获取所有的键的集合
  案例（特殊功能）

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); } }*/

IO流相结合使用的集合类

这里的集合必须是Properties集合：

• public void load(Reader reader):把文件中的数据读取到集合中
• public void store(Writer writer,String comments):把集合中的数据存储到文件

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;/** 我有一个猜数字小游戏的程序，请写一个程序实现在测试类中只能用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();}}
}
-----------------------------------------------
package cn.itcast_08;import java.util.Scanner;/*** 这是猜数字小游戏* * @author 风清扬* @version V1.1* */
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 + "次就猜中了");break;}}}
}

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)

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"));}
}

Java SE day18_IO流4相关推荐

1. 11.Java SE IO流

   IO 流 流的分类 FileReader.FileWriter的使用(输入.输出的标准化过程) FileInputStream / FileOutStream 的使用: 缓冲流 转换流的使用 对象流的 ...

2. 《Java SE实战指南》22-04：字节流和字符流

   <Java SE实战指南> 22-04:字节流和字符流 内容导航: 前言 1.分类定义 2.字符流常用类 2.1.FileWriter 2.2.FileReader 前言 我们每天都在使用 ...

3. Java SE 第八十八,八十九,九十讲 递归深度剖析 IO流深入详解,递归作业详解

   1.所谓递归(Recursion),就是方法调用自身,对于递归来说,一定有一个出口,让递归结束,只有这样才能保证不出现死循环. 2.作业:给定任意一个目录,以树形方式展现该目录中所有子目录和文件.另外 ...

4. 一个编程小白的Java SE学习日志 X—— 输入输出(IO)流【极客BOY-米奇】

   文章目录 前言(转载请说明作者!)4.30~5.7编写 File类 File类的构造方法 File类常用方法 File类的一些常用方法实例 IO流 IO流的分类 按数据流的方向分类 按是否直接操作源或 ...

5. 【读书笔记】《写给大忙人看的Java SE 8》——Java8新特性总结

   2019独角兽企业重金招聘Python工程师标准>>> 阅读目录 接口中的默认方法和静态方法 函数式接口和Lambda表达式 Stream API 新的日期和时间 API 杂项改进 ...

6. java se翻译_(翻译)Java SE 8 Lambda 标准库概览(下)

   Java SE 8 Lambda 标准库概览 8,Collectors 在目前的例子中,我们已经使用了collect()方法来收集流中的元素并放入List或Set中了.collec()方法的参数是一个 ...

7. Java SE 6 新特性 Instrumentation 新功能

   系列内容: 此内容是该系列的一部分:Java SE 6 新特性 Instrumentation 简介 利用 Java 代码,即 java.lang.instrument 做动态 Instrumenta ...

8. 【java学习笔记】java se8的流库概念以及使用

   概念 代码实例 流的创建 惰性求值与及早求值 概念 流提供了一种让我们可以在比集合更高的概念级别上指定计算的数据视图.通过使用流,我们可以说明想要完成什么任务,而不是说明如何去实现它.我们将操作的调度 ...

9. 面试必会系列 - 1.1 Java SE 基础

   本文已收录至 github,完整图文:https://github.com/HanquanHq/MD-Notes Java SE 基础 面向对象 Java 按值调用还是引用调用? 按值调用指方法接收调 ...

最新文章

1. python真的这么厉害吗-Python为什么这么厉害?——Python ,能用来做什么
2. 51nod2626-未来常数【树上启发式合并,线段树】
3. bubbleSort 冒泡排序
4. 问题：pom文件有删除线，不能识别maven模块
5. Model和ViewModel之间的通用MVVM数据交换
6. extjs 月份选择控件_Ext JS 4实现带week(星期)的日期选择控件(实战二)
7. AcWing 841. 字符串哈希（字符串Hash）
8. 使用易语言+myqq制作QQ群管理机器人-入门教程
9. 2017年电子设计大赛（B题 滚球控制系统）赛后总结
10. 16-20信息安全工程师上午题总结
11. 干货 | Elasticsearch 8.X 版本升级指南
12. 解决WiFi共享大师频繁掉线问题
13. Tanzu Observability by Wavefront Spring Boot Starter
14. 用PYQT5实现非常基本sqlite的编辑器
15. 尚硅谷 尚医通学习笔记
16. Smiditor实现图片上传功能
17. html样式表三种类型包括,css样式有哪几种类型
18. [Android]listview图文混排
19. Java 多线程 线程同步
20. 大治一中2021年高考成绩查询,2021年大冶市高考状元名单资料,今年大冶市高考状元多少分...

热门文章

1. js替换字符串,替换路径
2. 【codeforces】【比赛题解】#862 CF Round #435 (Div.2)
3. elemen ui 单张图片上传，照片墙上传一张照片后隐藏后面的添加框
4. 9.3 Go json
5. windows10上mysql5.7下载以及安装
6. python中的.find用法
7. [转|会计学习]增值税中运费如何抵扣进项税
8. 二维数组的传参【01_数组指针_指向数组的指针】
9. Java调用C++的步骤和一些自己的见解（详细款式）
10. C语言堆栈入门——与数据结构堆栈区别