Day19

操作基本数据类型的流

DataInputStream

DataOutputStream

/*

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

 * 数据输入流：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

  ByteArrayOutputStream

操作字符数组

  CharArrayReader

  CharArrayWrite

操作字符串

  StringReader

  StringWriter

/*

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

 * 字节数组：

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

}

}

打印流

打印流概述

  字节流打印流

  字符打印流

打印流特点

  只能操作目的地，不能操作数据。

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

  如果启动了自动刷新，能够自动刷新。

  可以操作文件的流

打印流复制文本文件

/*

 * 打印流

 * 字节流打印流 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();

 */

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

 */

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

}

}

标准输入输出流

System类中的字段：in，out。

它们各代表了系统标准的输入和输出设备。

默认输入设备是键盘，输出设备是显示器。

System.in的类型是InputStream.

System.out的类型是PrintStream是OutputStream的子类FilterOutputStream 的子类.

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

}

}

/*

 * 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类不属于流，是Object类的子类。但它融合了InputStream和OutputStream的功能。支持对随机访问文件的读取和写入。

"r" 以只读方式打开。调用结果对象的任何 write 方法都将导致抛出 IOException。  

"rw" 打开以便读取和写入。如果该文件尚不存在，则尝试创建该文件。  

"rws" 打开以便读取和写入，对于 "rw"，还要求对文件的内容或元数据的每个更新都同步写入到底层存储设备。  

"rwd" 打开以便读取和写入，对于 "rw"，还要求对文件内容的每个更新都同步写入到底层存储设备。

一般使用rw模式。

/*

 * 随机访问流：

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

}

}

合并流

S equenceInputStream概述

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

SequenceInputStream的构造方法

   SequenceInputStream(InputStream s1, InputStream s2)  

   SequenceInputStream(Enumeration<? extends InputStream> e)

把多个文件的内容写入到一个文本文件

/*

 * 以前的操作：

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

}

}

三个以上的文件怎么合并

/*

 * 以前的操作：

 * 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

序列化操作问题

为什么要实现序列化?

如何实现序列化?

序列化数据后，再次修改类文件，读取数据会出问题，如何解决呢?

使用transient关键字声明不需要序列化的成员变量

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

对象反序列化 ，是指把这种二进制流数据还原成对象。

/*

 * NotSerializableException:未序列化异常

 *

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

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

 *

 * java.io.InvalidClassException:

 * cn.it18zhang_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 + "]" ;

}

}

/*

 * 序列化流：把对象按照流一样的方式存入文本文件或者在网络中传输。对象 -- 流数据(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集合

Properties概述

属性集合类。是一个可以和IO流相结合使用的集合类。

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

是Hashtable的子类，说明是一个Map集合。

/*

 * 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的特殊功能

public Object setProperty(String key,String value)

public String getProperty(String key)

public Set<String> stringPropertyNames()

/*

 * 特殊功能：

 * 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和IO流的结合使用

public void load(Reader reader)

public void store(Writer writer,String comments)

/*

 * 这里的集合必须是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);

}

}

我有一个文本文件，我知道数据是键值对形式的，但是不知道内容是什么。请写一个程序判断是否有“lisi”这样的键存在，如果有就改变其实为”100”

/*

 * 我有一个文本文件(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次，超过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();

}

}

}

原文：http://12426495.blog.51cto.com/12416495/1894282