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;
}