2017

1 操作基本数据类型的流
可以读写基本数据类型的数据
数据输入流：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();
}
}

2 内存操作流
内存操作流：用于处理临时存储信息的，程序结束，数据就从内存中消失。
字节数据：
    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();
}
}

3 打印流
字节流打印流  PrintStream
字符打印流    PrintWriter
打印流特点：
    A:只有写数据的，没有读取数据。只能操作目的地，不能操作数据源。
    B:可以操作任意类型的数据。
    C:如果启动了自动刷新，能够自动刷新。
    D:该流是可以直接操作文本文件的。
       哪些流对象是可以直接操作文本文件的呢?
         FileInputStream
FileOutputStream
FileReader
FileWriter
PrintStream
PrintWriter
  看API,查流对象的构造方法，如果同时有File类型和String类型的参数，一般来说就是可以直接操作文件的。
      
         流：
基本流：就是能够直接读写文件的
高级流：在基本流基础上提供了一些其他的功能
----------------------------------------------------------
// 作为Writer的子类使用
PrintWriter pw = new PrintWriter("pw.txt");
pw.write("hello");
pw.write("world");
pw.write("java");
pw.close();
----------------------------------------------------------
PrintWriter实现自动刷新和换行
1:可以操作任意类型的数据。
         print()
         println()
2:启动自动刷新(调用带ln的方法才行)
      PrintWriter pw = new PrintWriter(new FileWriter("pw2.txt"), true);
      还是应该调用println()的方法才可以
      这个时候不仅仅自动刷新了，还实现了数据的换行。
           println()
  其实等价于于：
    bw.write();
    bw.newLine();
    bw.flush();
          // 创建打印流对象
 // 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();
4 打印流实现文本复制

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

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

InputStream is = System.in;
PrintStream os = System.out;

System.out.println("helloworld");
//获取标准输出流对象
PrintStream ps = System.out;
ps.println("helloworld");//以前讲的输出语句其实就是IO流操作，把数据输出到控制台

ps.println();
//ps.print();//这个方法不存在
//System.out.println();
//System.out.print();

6 三种方式实现键盘录入
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);
}
}

7 随机访问流

RandomAccessFile类不属于IO流，是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); // 100
// 该文件指针可以通过 getFilePointer方法读取，并通过 seek 方法设置。
System.out.println("当前文件的指针位置是：" + raf.getFilePointer()); //当前文件的指针位置是：4  (int 4)

char ch = raf.readChar();
System.out.println(ch);
System.out.println("当前文件的指针位置是：" + raf.getFilePointer());//当前文件的指针位置是：6 (char 2 +4)

String s = raf.readUTF();
System.out.println(s);
System.out.println("当前文件的指针位置是：" + raf.getFilePointer()); ////当前文件的指针位置是：14 （ 6+6(UTF的两个汉字) +2(readUTF后面要加2个。。。)）

// 我不想重头开始了，我就要读取a，怎么办呢?
raf.seek(4);
ch = raf.readChar();
System.out.println(ch); // 6
}

private static void write() throws IOException {
// 创建随机访问流对象
RandomAccessFile raf = new RandomAccessFile("raf.txt", "rw");

// 怎么玩呢?
raf.writeInt(100);
raf.writeChar('a');
raf.writeUTF("中国");
raf.close();
}
}

8 合并流
以前的操作：
a.txt -- b.txt
c.txt -- d.txt
现在想要：
a.txt+b.txt -- c.txt
(1)
// 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();

(2)
// 需求：把下面的三个文件的内容复制到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();

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