1、输入流还是输出流都是针对程序来说的：
文件---》程序：及从文件到程序叫做：输入流；
文件《---程序：及从程序到文件叫做：输出流；
2、将文件中的数据全部读出(用字节流)：
import java.io.*;
public class Demo{
public static void main(String args[]) throws Exception{
FileInputStream in=new FileInputStream("D:\\java.txt");
int b=0;
while((b=in.read())!=-1){
//in.read()返回的是下一个数据字节；
System.out.print((char)b);
}
in.close();
}
}
注意：1、in.read()是读一字节，如果D:\\java.txt文件中有汉字，将会出现乱码，
原因是：汉字在java中占两个字节；
2、注in.read()是一个字节一个字节的读取得，并且读一个字节访问 一次硬盘，
对硬盘有伤害；
3.将文件中的数据读取，并将其写到另一个文件中：
import java.io.*;
public class Demo{
public static void main(String args[]) throws Exception{
FileInputStream in=new FileInputStream("D:\\java.txt");
FileOutputStream out=new FileOutputStream("D:\\java02.txt");
int b=0;
//in.read()返回的是下一个数据字节；
while((b=in.read())!=-1){
//将指定字节写入文件输出流，即写入到文件中；
out.write(b);
}
in.close();
}
}
4、读取文件的全部内容(用字符流)---即两个字节两个字节的读，这样就不会出现乱码了
import java.io.*;
public class Demo{
public static void main(String args[]) throws Exception{
Reader r=new FileReader("D:\\java.txt");
int b=0;
//r.read()返回的是作为整数的字符；
while((b=r.read())!=-1){
System.out.print((char)b);
}
r.close();
}
}
5、处理流：对读写数据提供了缓冲的功能，提高了效率，同时增加了些新方法；
（大管道包含小管道即在小管道上套上一个大管道）
第一个处理流：缓冲流；文件<---->程序
import java.io.*;
public class Demo{
public static void main(String args[]) throws Exception{
FileInputStream fis=new FileInputStream("D:\\java.txt");
BufferedInputStream bis=new BufferedInputStream(fis);
int c=0;
System.out.println(bis.read());
System.out.println(bis.read());
bis.mark(100);
for(int i=0;i<=10&&(c=bis.read())!=-1;i++){
System.out.print(c+" ");
}
System.out.println();
bis.reset();
for(int i=0;i<=10&&(c=bis.read())!=-1;i++){
System.out.print(c+" ");
}
bis.close();
}
}
import java.io.*;
public class Demo{
public static void main(String args[]) throws Exception{
BufferedReader br=new BufferedReader(new FileReader("D:\\java.txt"));
String str=null;
//缓冲流的新方法
while(br.readLine()!=null){
str=br.readLine();
System.out.println(str);
}
}
}
第二个处理流：文件<----->程序
转换流OutputStreamWriter InputStreamReader；
import java.io.*;
public class Demo{
public static void main(String args[]) throws Exception{
OutputStreamWriter osw=new OutputStreamWriter(
new FileOutputStream("D:\\java.txt"));
osw.write("hello girls");
System.out.println(osw.getEncoding());
osw.close();
osw=new OutputStreamWriter(
new FileOutputStream("D:\\java.txt",true),"ISO8859_1");
osw.write("hello girls");
System.out.println(osw.getEncoding());
}
}
import java.io.*;
public class Demo{
public static void main(String args[]) throws Exception{
//System.in中的这个in是InputStream的子类，代表针对键盘的输入
//其实和FileInputStream一样都是一个流
InputStreamReader isr=new InputStreamReader(System.in);
BufferedReader br=new BufferedReader(isr);
String s=null;
s=br.readLine();
while(s!=null){
if(s.equalsIgnoreCase("exit")) break;
System.out.println(s.toUpperCase());
s=br.readLine();
}
}
}
第三个处理流：内存<---->程序
处理数据的流，因为数据占几个字节的也有，而InputStream和Reader等是操作一个和两个字节的
为此java有个专门处理数据的流；
import java.io.*;
public class Demo{
public static void main(String args[]) throws Exception{
//在内存中开辟一个存放字节的区域，并创建一个输出流指向该区域
ByteArrayOutputStream baos=new ByteArrayOutputStream();
//创建一个数据操作流包在baos这个流上
DataOutputStream dos=new DataOutputStream(baos);
//写一个double类型的数据到内存
dos.writeDouble(Math.random());
//写一个boolean类型的数据到内存
dos.writeBoolean(true);
//创建一个输入流指向内存中开辟的那块字节区域
ByteArrayInputStream bais=new ByteArrayInputStream(baos.toByteArray());
//创建一个数据流包在bais上
DataInputStream dis=new DataInputStream(bais);
//记住先写的先读，也就是先进先出---队列
System.out.println(dis.readDouble());
System.out.println(dis.readBoolean());
//关闭流
dos.close();
dis.close();
}
}
第四个：打印流---System.out就是一个打印流；
import java.io.*;
public class Demo{
public static void main(String args[]) throws Exception{
//声明一个打印流
PrintStream ps=null;
//创建一个指向文件的字节流
FileOutputStream fos=new FileOutputStream("D:\\java.txt");
//在fos上套一个打印流
ps=new PrintStream(fos);
if(ps!=null){
//System.out默认的是输出到控制台，而这里将其设置输出到ps
System.setOut(ps);//参数类型必须是PrintStream
}
int ln=0;
for(char c=0;c<=60000;c++){
System.out.print(c+" ");
if(ln++ >=100){System.out.println();ln=0;}
}
}
}
================================================================
import java.io.*;
public class Demo{
public static void main(String args[]) throws Exception{
String filename=args[0];
if(filename!=null){
list(filename,System.out);
}
}
public static void list(String filename,PrintStream fs) throws Exception{
BufferedReader br=new BufferedReader(new FileReader(filename));
String s=null;
while((s=br.readLine())!=null){
fs.println(s);
}
br.close();
}
}
======================================================================
import java.io.*;
import java.util.*;
public class Demo{
public static void main(String args[]) throws Exception{
String s=null;
//输入流 读入键盘输入的内容
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
//输出流 为了向日志里面写内容
FileWriter fw=new FileWriter("D:\\java.txt",true);
PrintWriter log=new PrintWriter(fw);
while((s=br.readLine())!=null){
if(s.equalsIgnoreCase("exit")) break;
System.out.println(s.toUpperCase());
log.println("--------------");
log.println(s.toUpperCase());
log.flush();
}
log.println("====="+new Date()+"======");
log.flush();
log.close();
}
}
Object流：将Object直接写入或读出；-----序列化
import java.io.*;
import java.util.*;
public class Demo{
public static void main(String args[]) throws Exception{
T t=new T();
t.k=8;
FileOutputStream fos=new FileOutputStream("D:\\java.txt");
ObjectOutputStream oos=new ObjectOutputStream(fos);
oos.writeObject(t);
oos.flush();
oos.close();
FileInputStream fis=new FileInputStream("D:\\java.txt");
ObjectInputStream ois=new ObjectInputStream(fis);
T tReaded=(T)ois.readObject();
System.out.println(tReaded.i+" "+tReaded.j+" "+tReaded.d+" "+tReaded.k);
}
}
class T implements Serializable{
int i=10;
int j=9;
double d=2.3;
//transient 透明，即该变量在序列化时不被考虑
transient int k=29;
}