黑马程序员——IO流02

——Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ——-

一、字符流

 

1.字符流定义

字节流操作中文数据不是特别的方便，所以就出现了转换流。 

转换流的作用就是把字节流转换字符流来使用。

 

2.转换流其实是一个字符流

字符流 = 字节流 + 编码表

关于字符流，其构造方法和使用方法与字节流几乎相同，在此只记录一些特殊部分

掌握了字节流，几乎就掌握了字符流

 

3.编码表

1）就是由字符和对应的数值组成的一张表

2）常见的编码表              占用字节数

ASCII                              1（高位为0）

ISO-8859-1                   1（高位为1）

GB2312                         3

GBK                                2

GB18030                       2

UTF-8                             3（升级版占4）

3）字符串中的编码问题

编码

String -- byte[]

解码

byte[] -- String

 

4.IO流中的编码问题

1）OutputStreamWriter

OutputStreamWriter(OutputStream os):默认编码，GBK

OutputStreamWriter(OutputStream os,StringcharsetName):指定编码。

2）InputStreamReader

InputStreamReader(InputStream is):默认编码，GBK

InputStreamReader(InputStream is,StringcharsetName):指定编码

3）编码问题其实很简单，编码只要一致即可

 

5.字符流结构

Reader

    int read():一次读取一个字符

    int read(char[] chs):一次读取一个字符数组

|--InputStreamReader

|--FileReader

|--BufferedReader

String readLine():一次读取一个字符串

Writer

|--OutputStreamWriter

|--FileWriter

|--BufferedWriter

 

6.案例

BufferedReader，BufferedWriter的一些特殊方法

import java.io.BufferedReader; 

import java.io.BufferedWriter; 

import java.io.FileReader; 

import java.io.FileWriter; 

import java.io.IOException; 

 

/*

 * 需求：把当前项目目录下的a.txt内容复制到当前项目目录下的b.txt中

 * 

 * 数据源：

 *     a.txt -- 读取数据 -- 字符转换流 -- InputStreamReader -- FileReader -- BufferedReader

 * 目的地：

 *     b.txt -- 写出数据 -- 字符转换流 -- OutputStreamWriter -- FileWriter -- BufferedWriter

 */ 

public class CopyFileDemo2 { 

   public static void main(String[] args) throws IOException { 

       // 封装数据源 

       BufferedReader br = new BufferedReader(newFileReader("a.txt")); 

       // 封装目的地 

       BufferedWriter bw = new BufferedWriter(newFileWriter("b.txt")); 

 

       // 读写数据 

       String line = null; 

       while ((line = br.readLine()) != null) { 

           bw.write(line); 

           bw.newLine(); 

           bw.flush(); 

       } 

 

       // 释放资源 

       bw.close(); 

       br.close(); 

   } 

}

二、IO流小结

 

IO流

|--字节流

|--字节输入流

    InputStream

int read():一次读取一个字节

int read(byte[] bys):一次读取一个字节数组

 

|--FileInputStream

|--BufferedInputStream

|--字节输出流

    OutputStream

void write(int by):一次写一个字节

void write(byte[] bys,int index,int len):一次写一个字节数组的一部分

 

|--FileOutputStream

|--BufferedOutputStream

|--字符流

|--字符输入流

    Reader

int read():一次读取一个字符

int read(char[] chs):一次读取一个字符数组

 

|--InputStreamReader

|--FileReader

|--BufferedReader

String readLine():一次读取一个字符串

|--字符输出流

    Writer

void write(int ch):一次写一个字符

void write(char[] chs,int index,int len):一次写一个字符数组的一部分

 

|--OutputStreamWriter

|--FileWriter

|--BufferedWriter

void newLine():写一个换行符

void write(String line):一次写一个字符串

 

三、其他流

 

1.数据操作流(操作基本类型数据的流)

1）可以操作基本类型的数据

writeByte() ,readByte()

writeShort() ,readShort()

writeChar() ,readChar()

等等8种基本类型的读写

 

2）流对象名称

数据输入流：DataInputStream(InputStream in)

数据输出流：DataOutputStream(OutputStream out) 

 

2.内存操作流

1）有些时候我们操作完毕后，未必需要产生一个文件，就可以使用内存操作流，程序结束，数据就从内存中消失。

不需要close()

2）三种

字节数组：ByteArrayInputStream,ByteArrayOutputStream

字符数组：CharArrayReader,CharArrayWriter

字符串：StringReader,StringWriter

 

3:打印流 PrintWriter，PrintStream 

1）字节打印流，字符打印流

 

2）特点：

A：只操作目的地,不操作数据源

B：可以操作任意类型的数据

C：如果启用了自动刷新，在调用println()方法的时候，能够换行并刷新

启用自动刷新代码：PrintWriter pw = new PrintWriter(newFileWriter("pw2.txt"), true)

true代表启动自动刷新

D：可以直接操作文件

 

3）复制文本文件

BufferedReader br = new BufferedReader(newFileReader("a.txt")); 

PrintWriter pw = new PrintWriter(newFileWriter("b.txt"),true); 

 

String line = null; 

while((line=br.readLine())!=null) { 

   pw.println(line); 

} 

 

pw.close(); 

br.close(); 

 

4.标准输入输出流

1）System类下面有这样的两个字段

in 标准输入流

out 标准输出流

2）三种键盘录入方式

A:main方法的args接收参数

B:System.in通过BufferedReader进行包装

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

C:Scanner

Scanner sc = new Scanner(System.in);

3）输出语句的原理

System.out.println("helloworld");

 

PrintStream ps = System.out;

ps.println("helloworld");

定义了一个打印输出流，输出对象是屏幕

 

4）使用字符流输出数据方法

把System.out用字符缓冲流包装一下使用

BufferedWriter bw = new BufferedWriter(newOutputStreamWriter(System.out));

 

5.随机访问流 RandomAccessFile

RandomAccessFile类不属于流，是Object类的子类。但它融合了InputStream和OutputStream的功能。支持对文件的随机访问读取和写入。

1）构造方法

public RandomAccessFile(String name,Stringmode)：第一个参数是文件路径，第二个参数是操作文件的模式。

模式有四种，我们最常用的一种叫"rw",这种方式表示我既可以写数据，也可以读取数据（“r”，"rws"，"rwd"）

2）案例：

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

   } 

} 

 

6.合并流 SequenceInputStream

1）把多个输入流的数据写到一个输出流中。

2）构造方法：

A:SequenceInputStream(InputStream s1,InputStream s2) 

B:SequenceInputStream(Enumeration<?extends InputStream> e) 

3）案例

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 = newFileInputStream("ByteArrayStreamDemo.java"); 

       InputStream s2 = newFileInputStream("CopyFileDemo.java"); 

       InputStream s3 = newFileInputStream("DataStreamDemo.java"); 

       v.add(s1); 

       v.add(s2); 

       v.add(s3); 

       Enumeration<InputStream> en = v.elements(); 

       SequenceInputStream sis = new SequenceInputStream(en); 

        BufferedOutputStream bos = newBufferedOutputStream( 

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

   } 

} 

 

7.序列化流 ObjectOutputStream，ObjectInputStream

可以把对象写入文本文件或者在网络中传输

1）实现序列化方法

让被序列化的对象所属类实现序列化接口。

该接口是一个标记接口。没有功能需要实现。

2）注意：

把数据写到文件后，在去修改类会产生问题。

为了解决该问题，在类文件中，给出一个固定的序列化id值。（点击自动生成即可）

如：private static final long serialVersionUID = -207156587696L;

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

3）案例

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(newFileOutputStream( 

                "oos.txt")); 

 

       // 创建对象 

       Person p = new Person("林青霞", 27); 

 

       // public final void writeObject(Object obj) 

       oos.writeObject(p); 

 

       // 释放资源 

       oos.close(); 

   } 

} 

 

 

import java.io.Serializable; 

 

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

   } 

} 

 

8.NIO

1）JDK4出现的NIO，对以前的IO操作进行了优化，提供了效率。但是大部分我们看到的还是以前的IO

2）JDK7的NIO的使用

Path:路径

Paths:通过静态方法返回一个路径 publicstatic Path get(URI uri)

Files:提供了常见的功能

public static long copy(Pathsource,OutputStream out):复制文件
public static Path write(Path path,Iterable<? extends CharSequence>lines,Charset cs,OpenOption... options)把集合中的数据写到文本文件

 

3）案例

import java.io.IOException; 

import java.nio.charset.Charset; 

import java.nio.file.Files; 

import java.nio.file.Paths; 

import java.util.ArrayList; 

 

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

   } 

} 

 

四、Properties

 

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

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

 

1.特有功能

1）public ObjectsetProperty(String key,String value)：添加元素

2）public StringgetProperty(String key)：获取元素

3）publicSet<String> stringPropertyNames()：获取所有的键的集合

 

2.和IO流结合的方法

1）把键值对形式的文本文件内容加载到集合中

public void load(Reader reader)

public void load(InputStream inStream)

2）把集合中的数据存储到文本文件中

public void store(Writer writer,Stringcomments)

public void store(OutputStream out,Stringcomments)

 

3.案例

写一个程序实现控制猜数字小游戏程序不能玩超过5次

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

       } 

   } 

}