黑马程序员-java基础-IO流总结

 - ---<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ ----

<< RandomAccessFile (随机访问流)>>

概述:
随机读写流,不属于流对象;
直接集成Object类


可以进行文件的随机读写,可以在一个文件的任意位置上,读取和写入;
这个流对象,支持读取,支持写入;
这个类中包含大型字节数组,数组索引,文件的指针,利用类中的方法,操作文件指针;
实现随机读写 void seek(long l)
设置文件指针;


构造方法:
传递File对象,String mode  // mode 文件访问方式 : 一般都用"rw" 即可读,也可以写;
传递String文件名,String mode  


方法:
read 字节 .字节数组,读取基本类型;
write 字节 字节数组, 写基本类型
void seek(long l) 开头测量的文件指针,读写发生在设置的索引的下一个字节处;

案例:

package cn.itcast.iostream;
/*
 * 随机读写流,不属于流对象
 * 直接继承Object类
 * 
 * 可以进行文件的随机读写,可以在一个文件的任意位置上,读取和写入
 * 这个流对象,支持读取,支持写入
 * 这个类中包含大型字节数组,数组索引,文件的指针,利用类中的方法,操作文件指针
 * 实现随机读写  void seek(long l)
 * 设置文件的指针
 * 
 * 构造方法:
 *   传递File对象,String mode
 *   传递String文件名,String mode
 *   构造方法第二个参数 rw 即可读,又可以写
 *   
 *  这个类中的方法, read write
 *  read 字节,字节数组,读取基本类型
 *  write 字节,字节数组,写基本类型
 *  void seek(long l)开头测量的文件指针,读写发生在设置的索引的下一个字节处
 *  seek(10)
 */
import java.io.IOException;
import java.io.RandomAccessFile;
public class RandomAccessFileDemo {
public static void main(String[] args)throws IOException {
readFile();
}
/*
* 随机读写流,读取文件所有内容
* read方法结尾 抛出EOFException异常
* 循环读取,利用这个异常终止程序
*/
public static void readFile() {
RandomAccessFile raf = null;
try{
raf = new RandomAccessFile("c:\\random.txt", "rw");
byte[] bytes = new byte[4];
int len = 0 ;
while(true){
raf.read(bytes);
len = raf.readInt();
System.out.println(new String(bytes)+len);
}

}catch(IOException ex){

}finally{
 try{
raf.close();
 }catch(IOException ex){
 
 }
}

}

/*
* 随机读写流,读取文件
* 进行随机读取
*/
public static void read()throws IOException{
//创建随机读写流对象,传递字符串文件名 rw
RandomAccessFile raf = new RandomAccessFile("c:\\random.txt", "rw");
byte[] bytes = new byte[4];
//读取李四,17开始
raf.seek(16);

raf.read(bytes);
int x = raf.readInt();
System.out.println(new String(bytes)+x);

raf.close();
}



/*
* 随机读写流,写文件
* 进行随机操作
*/
public static void write()throws IOException{
//创建随机读写流对象,传递字符串文件名 rw
RandomAccessFile raf = new RandomAccessFile("c:\\random.txt", "rw");
//写 张三 65
raf.write("张三".getBytes());
raf.writeInt(65);

//写李四 66
raf.seek(16);
raf.write("李四".getBytes());
raf.writeInt(66);

//写王五 67 , 写到李四的前面
//王五出现在哪个字节上 9 方法seek移动文件指针
raf.seek(8);
raf.write("王五".getBytes());
raf.writeInt(67);
raf.close();

}
}

<<内存操作流>>

 内存操作流一般用于处理临时信息.
 内存流共性,只操作内存,其余存储容器不操作,不会占用操作系统资源;
 流对象不需要关闭;


*操作字节数组:
 
  *ByteArrayInputStream //将字节数组从内存中读取出 
   |-- 构造方法,空参数数
   |-- String toString() 直接将内存中的字节数组变成字符串
   |-- byte[] toByteArray() 将内存中的字节数组还原出来 


  *ByteArrayOutputStream //将字节数组写入内存;
   |-- 构造方法,传递字节数组,读取的数据源
   |-- read 字节数组


*操作字符数组: 同上


  *CharArrayReader    
  *CharArrayWrite


*操作字符串:
同上
  *StringReader      
  *StringWrite

案例:

package cn.itcast.iostream;
/*
 * JAVA中内存操作流对象
 *   操作字节数组的流对象
 *   ByteArrayInputStream 将字节数组，从内存中读取出来
 *   ByteArrayOutputStream 将字节数组，写入内存中
 *   
 * 内存流共性，只操作内存，其余存储容器不操作，不会占用操作系统资源
 * 流对象，不需要关闭
 */
import java.io.*;
public class ByteArrayStreamDemo {
public static void main(String[] args) throws IOException{
method_2();
}
/*
* ByteArrayInputStream
* ByteArrayOutputStream
* 整合一下
*/
public static void method_2()throws IOException{
ByteArrayOutputStream bos = new ByteArrayOutputStream();
for(int x = 0 ; x < 5 ;x++){
bos.write(("hello "+x).getBytes());
}

//读取字节数组，数据源，ByteArrayOutputStream写进去的字节数组
ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
int len = 0 ;
while((len = bis.read())!=-1){
System.out.print((char)len);
}
}


/*
* ByteArrayInputStream 读取字节数组
* 构造方法，传递字节数组
*/
public static void method_1(){
//创建字节数组输入流，构造方法，直接传递字节数组
ByteArrayInputStream bis = new ByteArrayInputStream("abcd".getBytes());
//读取read()
int len = 0 ;
while((len = bis.read())!=-1){
System.out.println(len);
}
}


/*
* ByteArrayOutputStream 写字节数组
* 构造方法，空参数的即可
* write字节数组
* toString() 将写入的字节数组，变成字符串
* byte[] toByteArray() 将内存中写进去的内容，变成字节数组
*/
public static void method()throws IOException{
//创建字节数组输出流
ByteArrayOutputStream bos = new ByteArrayOutputStream();
bos.write("hahahehe".getBytes());
bos.write("你好".getBytes());

String s = bos.toString();
System.out.println(s);
byte[] bytes = bos.toByteArray();
for(byte b : bytes){
System.out.println(b);
}
}

}

<<基本数据类型操作流>>
   DataInputStream 基本数据类型输入流，读取基本数据类型
   DataOutputStream 基本数据类型输出流，写入基本数据类型
  
   DataOutputStream
    构造方法，DataOutputStream(OutputStream out)
    传递字节输出流，基本数据类型输出流，将基本类型写入到一个字节输出流中 
    传递 FileOutputStream
    
    写的方法  write基本类型的名字  writeInt  writeBoolean writeDouble..等等
    
    DataInputStream
     构造方法，DataInputStream(InputStream in)
    传递字节输入流，从字节输入流包装的文件中，读取JAVA基本数据类型
     传递 FileInputStream
    
     读取的方法 readInt()  返回值int
    
     读取基本数据类型，文件结尾，不可能返回-1  -1是有效的基本数据类型
     读取文件的结尾，抛出异常 java.io.EOFExceptionsf

案例:

package cn.itcast.iostream;
/*
 * 基本数据类型操作流
 *  DataInputStream 基本数据类型输入流，读取基本数据类型
 *  DataOutputStream 基本数据类型输出流，写入基本数据类型
 *  
 *  DataOutputStream
 *    构造方法，DataOutputStream(OutputStream out)
 *    传递字节输出流，基本数据类型输出流，将基本类型写入到一个字节输出流中 
 *    传递 FileOutputStream
 *    
 *    写的方法  write基本类型的名字  writeInt  writeBoolean writeDouble
 *    writeInt(int a)
 *    
 *  DataInputStream
 *    构造方法，DataInputStream(InputStream in)
 *    传递字节输入流，从字节输入流包装的文件中，读取JAVA基本数据类型
 *    传递 FileInputStream
 *    
 *    读取的方法 readInt()  返回值int
 *    
 *    读取基本数据类型，文件结尾，不可能返回-1  -1是有效的基本数据类型
 *    读取文件的结尾，抛出异常 java.io.EOFException
 *    EOF  End Of File


 */
import java.io.*;
public class DataStreamDemo {
public static void main(String[] args)throws IOException {
//System.out.println((char)0);
// myWriteInt();
myReadInt();
}
/*
* 从文件中，读取JAVA基本数据类型
*/
public static void myReadInt(){
//创建基本数据类型输入流，构造器传递字节输入流
DataInputStream dis = null;
 try{
dis = new DataInputStream(new FileInputStream("c:\\data.txt"));
//读取基本类型int   readInt()
/*int x = dis.readInt();
System.out.println(x);*/
int len = 0;
while(true){
len = dis.readInt();
System.out.println(len);
}
  }catch(IOException ex){
   
  }
finally{
 try{
  dis.close();
 }catch(IOException ex){
 
 }
}
}


/*
* 将基本数据类型int，写入到文件中
*/
public static void myWriteInt()throws IOException{
//创建基本数据类型输出流，构造方法中，传递字节输出流
DataOutputStream dos = new DataOutputStream(new FileOutputStream("c:\\data.txt"));
//写入int基本类型，调用方法 writeInt()
dos.writeInt(97);
dos.writeInt(98);
dos.writeInt(99);
dos.writeInt(-1);
dos.close();
}
}

<<打印流>>

打印流的特点:
打印流为其他输出流添加了功能,方便打印各种数据,打印流也是装饰流(装饰类)
打印流永远不会抛出IO异常;
此流只操作数据目的,不操作数据源
打印流字符流,自动刷新;
打印流的使用场景:
当你需要做数据输出的时候,输出流,方便打印数据,考虑使用打印流;
文件复制;
互联网开发的时候 在服务器端,使用打印流将数据,打印到客户端浏览器上;


PrintStream  PrintWriter 共性内容:
打印方法都一样;


注意一点:如果开启自动刷新打印流的构造方法中,必须是流对象;字节流不需要刷新;

如果开启了打印流自动刷新,必须调用3个方法,自动刷新才会有效;
println() printf() format() 


打印字节流:
    PrintStream; -- OutputStream的子类;
//打印流的数据目的,数据目的都会放在构造方法中;
//构造方法中接受的数据目的:File对象,OutputStream,String文件名;
打印字符流:
PrintWriter --writer的子类;
//打印流的数据目的,数据目的都会放在构造方法中;
//构造方法中接受的数据目的:File对象,OutputStream,String文件名,Writer(字符输出流)
方法:
println();
print();

close();

 案例:

package cn.itcast.iostream;
/*
 * 打印流向数据目的中打印数据
 *   File对象
 *   字节输出流  开启自动刷新
 *   String文件名
 *   字符输出流 开启自动刷新
 *   
 *   如果开启了打印流的自动刷新，必须调用三个方法，自动刷新才会有效
 *    println  printf  format
 *    
 *   如果对方提供我们数据目的，别人提供数据目的是File对象，可以不可以使用自动刷新
 *   肯定可以使用自动刷新，自动刷新功能，不能直接用于File对象，但是可以间接使用
 *   常见的流对象 FileOutStream FileWriter构造方法，都接收File对象
 */
import java.io.*;
public class PrintWriterDemo {
public static void main(String[] args) throws IOException{
method_3();
PrintWriter pw = new PrintWriter(new FileWriter(new File("c:\\1.txt")),true);
}
/*
* 打印流向字符输出流中打印数据
*/
public static void method_3()throws IOException{
//创建打印流对象，传递字符输出流
PrintWriter pw = new PrintWriter(new FileWriter("c:\\4.txt"),true);
pw.println("abc");
pw.println("bcd");
pw.close();
}


/*
* 打印流向字节输出流中打印数据
*/
public static void method_2()throws IOException{
//创建打印流对象，传递字节输出流
PrintWriter pw = new PrintWriter(new FileOutputStream("c:\\3.txt"),true);
pw.println("haah");
pw.println("heihei");
pw.println("xixix");
pw.println("hehe");
pw.close();
}


/*
* 打印流向字符串的文件名中，打印数据
*/
public static void method_1()throws IOException{
//创建打印流对象，写字符串文件名
PrintWriter pw = new PrintWriter("c:\\2.txt");
pw.println("第一行");
pw.flush();
pw.println("第二行");
pw.flush();
pw.close();
}


/*
* 打印流向File包装的文件中打印数据
*/
public static void method()throws IOException{
File file = new File("c:\\1.txt");
//创建打印流对象，构造方法传递File对象
PrintWriter pw = new PrintWriter(file);
pw.println("abcdef");
pw.flush();
pw.close();
}
}

<<标准输入输出流>>


控制台输入输出:


System类 静态成员变量 in ,out ;
  public static  final InputStream in ();
    System.in 运算结果是字节输入流--BufferInputStream 
输入流可以应于键盘,文件,有用户指定另一个输入源;


public static final PrintStream out();
System.out 运算结果是字节输入流 打印流;
准备开始输出了,数据目的,控制台,显示器,用户指定另一个输出目的;


标准输入流:
 System.in  字节输入流；
// 标准输入流=>转换流=>字符输入流缓冲区->readline() 
 InputStream=>InputStreamReader=>BufferedReader
标准输出流:
system.out 字节输出流;
// 标准输出流=>转换流=>字符输出流缓冲区->newline() 


  //OutputStream=>OutputStreamWriter=>BufferedWriter

案例:

package cn.itcast.iostream;
/*
 *  System.in --> readLine 读取键盘一行
 *  System.out --> newLine 实现换行
 *  标准输入流，输出流 + 转换流+缓冲区，实现读取一行，写一行，写换行
 */
import java.io.*;
public class TranseDemo {
public static void main(String[] args)throws IOException {
//标准输入流-->转换流->缓冲区--readLine
InputStream in = System.in;
InputStreamReader isr = new InputStreamReader(in);
BufferedReader bfr = new BufferedReader(isr);

//标准输出流-->转换流-->缓冲区-->newLine
OutputStream out = System.out;
OutputStreamWriter osw = new OutputStreamWriter(out);
BufferedWriter bfw = new BufferedWriter(osw);

String line = null;
while((line = bfr.readLine())!=null){
if("over".equals(line))
break;
bfw.write(line.toUpperCase());
bfw.newLine();
bfw.flush();
}
bfr.close();
bfw.close();
}
}

对象序列化 -- 写对象
     以机器无关的方式,将对象转成二进制形式,写入文件保存


 对象的反序列化 -- 读对象
  保存在文件中的对象的二进制形式,还原回原有的对象
  
java.io 提供读写对象的流对象,负责序列化,和反序列化


对象的序列化流,写对象
  ObjectOutputStream
  
对象的反序列化流,读取对象
  ObjectInputStream


   ObjectOutputStream
    |-- 构造方法,传递字节输出流
    |-- writeObject 写对象
    |-- 序列化的对象必须实现 java.io.Serializable


  ObjectInputStream
    |-- 构造方法,传递字节输入流
    |-- readObject()
    |-- 读取对象必须有class文件支持

案例:

package cn.itcast.iostream;
/*
 * 进行对象的序列化和反序列化
 * 
 * ObjectOutputStream 写对象
 *   构造方法
 *     ObjectOutputStream(OutputStream out) 传递字节输出流
 *     FileOutputStream("文件名")
 *   
 *    void writeObject(Object obj) 将对象写到文件中
 *    
 * 
 * ObjectInputStream 读取对象
 *   构造方法
 *    ObjectInputStream(InputStream in)传递字节输入流
 *    FileInputStream("文件名")
 *    
 *    Object readObject(); 如果没有对应的class文件,出现类找不到异常
 */
import java.io.*;
public class ObjectStreamDemo {
public static void main(String[] args)throws IOException , ClassNotFoundException{
readObj();
}
/*
* jiang person.txt中的对象进行反序列化
*/
public static void readObj()throws IOException, ClassNotFoundException{
//创建读取对象流对象,传递字节输入流,包装文件
ObjectInputStream ois = 
new ObjectInputStream(new FileInputStream("c:\\person.txt"));
//调用读取对象的方法 readObject()
Object obj = ois.readObject();
System.out.println(obj);
ois.close();
}


/*
* 将Person对象写到文件中,序列化
*/
public static void writeObj()throws IOException{
//创建对象的序列化流,传递字节输出流,包装一个文件
ObjectOutputStream oos = new
ObjectOutputStream(new FileOutputStream("c:\\person.txt"));
Person p = new Person("zhangsan",33);
//调用写对象的方法 writeObject
oos.writeObject(p);
oos.close();
}
}