//java中的流是用来读写数据的，有输入流和输出流。输入流就相当于一个数据源，站在程序的角度就可以认为
输入流中的数据应该流到程序当中，而对于输出流也类似。最原始的输入和输出流为InputStream OutputStream.
其它的流都是继承该两个类，而数据的输入输出流又分为节点流和处理流，按照数据的原始形式将数据读写进输入和输出
流当中的就是节点流，而对于处理流，则是在节点流当总包裹了一层流，用来对原始的数据进行处理。

//节点流：直接将数据从源数据输入或者输出到目的数据源。

//单字节文件流，以一个字节为单位进行输入和输出。
//字符流：以字符为单位进行输入和输出，例如：当一个文件中包括unicode字符时，使用inputstream读取数据时就会发生乱码。
，低于输出流，如果我们想要输出的数据是unicode字符，则写入到目的地的数据也会发生差错。
//文件流使用输入流读取的数据是文件字符对应的ascii码值。
import java.io.*;
public class Stream{
//这里的io异常对应的是read方法，read方法返回-1代表读取到了文件的末尾；
public static void main(String args[]) throws IOException{
int b = 0;
FileInputStream in = new FileInputStream("/users/mac/LEARN/src/App.java");
//此处如果目标文件不存在，则会自动创建一个同名的文件。
FileOutputStream out = new FileOutputStream("/users/mac/LEARN/src/txt");
try{
while((b=in.read())!=-1){
out.write((char)b);
}
//这里的filenotdound对应的是文件输入和输出流。
}catch(FileNotFoundException e){
System.out.println("文件找不到");
}finally{
//每个流打开后，使用完都需要关闭。
in.close();
out.close();
}
}
}

//字符的文件流
public class Stream{
public static void main(String args[]) throws IOException{
int b = 0;
FileReader in = new FileReader("/users/mac/LEARN/src/App.java");
FileWriter out = new FileWriter("/users/mac/LEARN/src/txt");
try{
while((b=in.read())!=-1){
// System.out.println(b);
out.write(b);
}
}catch(FileNotFoundException e){
System.out.println("文件找不到");
System.out.println(1);
}finally{
in.close();
out.close();
}
}
}

//处理流：

//缓冲流：需要建立在相应的节点流之上，对读写添加了缓冲的功能，提高读写效率，还提供了一些其它的方法。
缓冲区即内存中的一小块地方，读写的数据都先放入缓冲区，这样可以减少程序对硬盘的访问次数。当缓冲区满了以后
就将缓冲区的数据读入或者输出。

public class Stream{
public static void main(String args[]) throws IOException{
int b = 0;
FileInputStream in = new FileInputStream("/users/mac/LEARN/src/App.java");
FileOutputStream out = new FileOutputStream("/users/mac/LEARN/src/txtt");
BufferedOutputStream bf = new BufferedOutputStream(out);
//FileOutputStream out = new FileOutputStream("/users/mac/LEARN/src/txtt");
try{
while((b=in.read())!=-1){
bf.write(b);
}
//调用flush方法清空缓冲区。
bf.flush();
}catch(FileNotFoundException e){
System.out.println("文件找不到");
System.out.println(1);
}finally{
bf.close();
out.close();
in.close();
//out.close();
}
}
}

//新的一些方法。
public class Stream{
public static void main(String args[]) throws IOException{
String b;
FileReader in = new FileReader("/users/mac/LEARN/src/App.java");
BufferedReader bf = new BufferedReader(in);
try{
//调用readLine可以一次读取一行的数据。
while((b=bf.readLine())!=null){
System.out.println(b);
System.out.println(1);
}
}catch(IOException e){
System.out.println("文件找不到");
System.out.println(1);
}finally{
bf.close();
in.close();
//out.close();
}
}
}

//转换流
OnputStreamReader,OutputStreamWriter 用于字节与字符之间的转换。例如：在写入数据的时候，字节流一个
字节的写入目的地，而转换成字符流可以一个字符的写入，还可以写入字符串。

public class Stream{
public static void main(String args[]) throws IOException{
//加上参数true，就是在写入的时候使用追加的方式。
FileOutputStream in = new FileOutputStream("/users/mac/LEARN/src/txt",true);
OutputStreamWriter ir = new OutputStreamWriter(in);
try{
//可以直接写入字符串。
ir.write("aabdcsdafaf");
//获取系统的默认编码方式。
System.out.println(ir.getEncoding());
}catch(IOException e){
System.out.println("文件找不到");
System.out.println(1);
}finally{
ir.close();
in.close();
//out.close();
}
}
}

//打印流:可以改变打印数据的目的地。

public class Stream{
public static void main(String args[]) throws IOException{
//加上参数true，就是在写入的时候使用追加的方式。
FileOutputStream in = new FileOutputStream("/users/mac/LEARN/src/txt",true);
PrintStream pt = new PrintStream(in);
try{
//改变输出的目的地，默认是dos窗口。
System.setOut(pt);
System.out.print("yuqihong");
}finally{
pt.close();
in.close();
//out.close();
}
}
}

//对象流：直接读或者写入一个对象（ObjectOutputStream ObjectInputStream).

public class Stream{
public static void main(String args[]) throws IOException, ClassNotFoundException{
//加上参数true，就是在写入的时候使用追加的方式。
// FileOutputStream in = new FileOutputStream("/users/mac/LEARN/src/txt",true);
// ObjectOutputStream os = new ObjectOutputStream(in);
// try{

// A a = new A();
// //writeobject将对象直接写入输出流中。
// os.writeObject(a);
// }finally{
// os.close();
// in.close();
// //out.close();
// }
FileInputStream in = new FileInputStream("/users/mac/LEARN/src/txt");
ObjectInputStream oi = new ObjectInputStream(in);
try{
//读取输入流中的对象，并且对其进行强制性的转换。
A a =(A)oi.readObject();
System.out.println(a);
}finally{
oi.close();
in.close();
//out.close();
}
}
}
//这里的Serializable必须实现该接口，该接口的作用是作为编译器识别的一个标识，表示
//该对象可以序列化。
class A implements Serializable{
/**
*
*/
private static final long serialVersionUID = 1L;

public void min(){
System.out.println(1);
}
}

//数据流

public class Stream{
public static void main(String args[]) throws IOException{
double b = 0;
//调用该构造方法会自动的在内存中创建一个字节数组。
ByteArrayOutputStream bos = new ByteArrayOutputStream();
//FileWriter out = new FileWriter("/users/mac/LEARN/src/txt");
DataOutputStream dos = new DataOutputStream(bos);
try{
for(int i=0;i<100;i++){
dos.writeDouble(Math.random());
}
ByteArrayInputStream bais = new ByteArrayInputStream(bos.toByteArray());
//获取该输入流还能读入多少数据。
System.out.println(bais.available());
DataInputStream dis = new DataInputStream(bais);
while((b=(double)dis.readDouble())!=-1){
System.out.println(b);
}
dis.close();
bais.close();
// for(int i=0;i<60000;i++){
// out.write(i);
// }
}catch(FileNotFoundException e){
System.out.println("文件找不到");
System.out.println(1);
}finally{
dos.close();
bos.close();
// out.close();
}
}
}