java中io流浅析

Posted 2020-09-30 superficial。

1.java.io包下
File类：java程序中的此类的一个对象，就对应着硬盘中的一个文件或网络中的一个资源。
File file1 = new File("d:\\\\io\\\\helloworld.txt");
File file2 = new File("d:\\\\io\\\\io1");
>1.File既可以表示一个文件（.doc .xls .mp3 .avi .jpg .dat），也可以表示一个文件目录！
>2.File类的对象是与平台无关的。
>3.File类针对于文件或文件目录，只能进行新建、删除、重命名、上层目录等等的操作。如果涉及到访问文件的内容，File
是无能为力的，只能使用IO流下提供的相应的输入输出流来实现。
>4.常把File类的对象作为形参传递给相应的输入输出流的构造器中！

file类下的基本常用方法：

boolean exists();判断这个文件是否存在

boolean mkdir();创建文件夹路径（只能一层）

directory

boolean mkdirs();创建文件夹路径（可过层的）

creatNewFile创建一个文件

delete删除一个文件

renameTo(File File)重命名

getName获取文件名称

getPath获取文件路径

length文件的长度

isDirectory：判断是不是一个目录

isFile是不是一个文件

File[]   listFiles获取当前文件夹下的所有文件与文件目录

import java.io.File;

public class TestFile {
	public static void main(String[] args){
File filet=new File("E:\\\\BaiduYunDownload");
/*Boolean b=filet.isDirectory();
System.out.println(b);
File[] fil=filet.listFiles();
for(File f:fil){
	System.out.println(f);
}*/
TestFile.printf(filet,1);

}
	public static void printf(File f,int len){
	if(f.exists()){//文件是否存在
	 File[] file=f.listFiles();//创建文件数组
	 for(File fi:file){//遍历数组
		 if(fi.isDirectory()){//如果是数组继续进入方法并打印出文件夹名
			 kongge(len);
			 System.out.println(fi.getName());
			 printf(fi,len+1);
		 }else{
			 kongge(len);
			 System.out.println(fi.getName());
		 }
	 }
	}}
	public static void kongge(int len){//给文件夹前边加空格
		for(int i=0;i<len;i++){
			System.out.print("  ");
		}
	}
}

io流分类　：

　

3.IO流的划分
1) 按照流的流向的不同：输入流 输出流 (站位于程序的角度)
2) 按照流中的数据单位的不同：字节流 字符流 （纯文本文件使用字符流 ，除此之外使用字节流）
3) 按照流的角色的不同：节点流 处理流 （流直接作用于文件上是节点流（4个），除此之外都是处理流）

4.重点掌握
* 抽象基类（InputStream、OurputStream、Reader、Writer）   节点流（文件流） 缓冲流（处理流的一种,可以提升文件操作的效率）
* InputStream FileInputStream （int read(byte[] b)） BufferedInputStream (int read(byte[] b))
* OutputStream FileOutputStream (void write(b,0,len)) BufferedOutputStream (flush()) (void write(b,0,len))
* Reader FileReader (int read(char[] c)) BufferedReader (readLine()) (int read(char[] c))或String readLine()
* Writer FileWriter (void write(c,0,len)) BufferedWriter (flush()) (void write(c,0,len)或void write(String str))
注： 1.从硬盘中读入一个文件，要求此文件一定得存在。若不存在，报FileNotFoundException的异常
2.从程序中输出一个文件到硬盘，此文件可以不存在。若不存在，就创建一个实现输出。若存在，则将已存在的文件覆盖
3.真正开发时，就使用缓冲流来代替节点流
4.主要最后要关闭相应的流。先关闭输出流，再关闭输入流。将此操作放入finally

package day31;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Reader;
import java.io.Writer;

public class iotext {
public static void main(String[] args){
File fi=new File("C:\\\\Users\\\\gaofangquan\\\\Desktop\\\\新建文件夹\\\\新建文本文档.txt");
File fi1=new File("C:\\\\Users\\\\gaofangquan\\\\Desktop\\\\新建文件夹\\\\新建文本文档 (3).txt");
try {
	Reader r=new FileReader(fi);
	Writer w=new FileWriter(fi1);
	BufferedReader br=new BufferedReader(r);
	BufferedWriter bw=new BufferedWriter(w);
	//char[] c=new char[5];
	String str=null;
	@SuppressWarnings("unused")
	int len=0;
	//while((len=br.read(c))!=-1){//可以使用字符数组接收
	while((str=br.readLine())!=null){
	    bw.write(str);
	    bw.newLine();
	    bw.flush();//刷新一下
	    }
	bw.close();
	br.close();
} catch (FileNotFoundException e) {
	
	e.printStackTrace();
} catch (IOException e) {
	
	e.printStackTrace();
}
   
}
}

　　

5.其它的流
1.转换流：实现字节流与字符流之间的转换
InputStreamReader:输入时，实现字节流到字符流的转换，提高操作的效率（前提是，数据是文本文件） ===>解码：字节数组--->字符串
OutputStreamWriter：输出时，实现字符流到字节流的转换。 ===>编码： 字符串---->字节数组
例子：从键盘输入字符串，要求将读取到的整行字符串转成大写输出。然后继续进行输入操作，直至当输入“e”或者“exit”时，退出程序。

package day31;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.Writer;

public class zhuanhuan {
	public static void main(String[] args){
		InputStreamReader isr=new InputStreamReader(System.in);
		BufferedReader br=new BufferedReader(isr);
		try {
			Writer w=new FileWriter("C:\\\\Users\\\\gaofangquan\\\\Desktop\\\\新建文件夹\\\\新建文本文档 (5).txt");
			BufferedWriter bw=new BufferedWriter(w);
			String s=null;
			while((s=br.readLine())!=null){
				if(s.equalsIgnoreCase("exit")){
					break;
				}
				bw.write(s);
				bw.newLine();//换行
				bw.flush();
			}
			bw.close();
			br.close();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

}
}

　　

2.标准的输入输出流
System.in: The "standard" input stream:从键盘输入数据
System.out:The "standard" output stream：从显示器输出数据

3.打印流 (都是输出流) PrintStream(处理字节) PrintWriter(处理字符)
可以使用System.setOut（PrintStream p）重新设置一下输出的位置。
PrintStream p = new PrintStream(new FileOutputStream("hello.txt"),true);

package print;

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.PrintStream;
import java.io.Reader;

public class TestPrintStream2 {
	public static void main(String[] args) {
		String fileName = "C:\\\\Users\\\\gaofangquan\\\\Desktop\\\\新建文件夹\\\\新建文本文档 (6).txt";
		
		list(fileName, System.out);
	}

	private static void list(String fileName, PrintStream ps) {
		try {
			Reader r=new FileReader(fileName);
			BufferedReader br = new BufferedReader(r);
			String s = null;
			
			while((s = br.readLine()) != null) {
				// System.out.println();
				ps.println(s);//等同于System.out.println();
			}
			br.close();
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			ps.println("无法读取文件 !");
			e.printStackTrace();
		}
	}
}

　　

4.数据流（处理基本数据类型、String类、字节数组）
DataInputStream DataOutputStream

package data;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;

public class TestDataStream {
	public static void main(String[] args) {
		
		ByteArrayOutputStream baos = new ByteArrayOutputStream();
		
		DataOutputStream dos = new DataOutputStream(baos);
		
		try {
			dos.writeDouble(Math.random());
			dos.writeBoolean(true);
			ByteArrayInputStream bais = 
					new ByteArrayInputStream(baos.toByteArray());
			System.out.println(bais.available());
			DataInputStream dis = new DataInputStream(bais);
			/*
			 * 先进先出---队列
			 * 先进后出---栈
			 */
			System.out.println(dis.readBoolean());
			System.out.println(dis.readDouble());//两种数据占用的空间不同必须遵守先进后出
			dos.close();
			dis.close();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

　　

5.对象流(用来处理对象的)
>对象的序列化机制：允许把内存中的Java对象转换成平台无关的二进制流，从而允许把这种二进制流持久地保存在磁盘上，
或通过网络将这种二进制流传输到另一个网络节点。当其它程序获取了这种二进制流，就可以恢复成原来的Java对象
ObjectInputStream（Object readObject();） ObjectOutputStream (void writeObject(Object obj))
如何创建流的对象：ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(new File("person.txt")));
ObjectInputStream ois = new ObjectInputStream(new FileInputStream(new File("person.txt")));

实现序列化机制的对象对应的类的要求：①要求类要实现Serializable接口②同样要求类的所有属性也必须实现Serializable接口
③ 要求给类提供一个序列版本号：private static final long serialVersionUID;
④属性声明为static 或transient的，不可以实现序列化

package object;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

public class TestObjectStream {
	public static void main(String[] args) {
		try {
			Test t = new Test();
			t.i += 5;
			FileOutputStream fos = 
					new FileOutputStream("C:\\\\Users\\\\gaofangquan\\\\Desktop\\\\新建文件夹\\\\新建文本文档 (6).txt");
			ObjectOutputStream oos = 
					new ObjectOutputStream(fos);
			oos.writeObject(t);
			oos.flush();
			oos.close();
			
			FileInputStream fis = 
					new FileInputStream("C:\\\\Users\\\\gaofangquan\\\\Desktop\\\\新建文件夹\\\\新建文本文档 (6).txt");
			ObjectInputStream ois = 
					new ObjectInputStream(fis);
			Test t_read = (Test)ois.readObject();
			
			System.out.println(t_read);
			
			ois.close();
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

// Serializable--标记型接口, 没有实际的方法, 只是用来表示这个类可以被序列化
class Test implements Serializable {
	
	private static final long serialVersionUID = 1L;
	
	String name = "hanqi";
	int i = 3;
	int j = 15;
	transient // 透明的, 表示这个属性在写入流的时候不予考虑
		double d = 12.345;
	
	@Override
	public String toString() {
		return "Test [name=" + name + ", i=" + i + ", j=" + j + ", d=" + d + "]";
	}
}

　　

6.随机存取文件流:RandomAccessFile
6.1既可以充当一个输入流，又可以充当一个输出流：public RandomAccessFile(File file, String mode)
6.2支持从文件的开头读取、写入。若输出的文件不存在，直接创建。若存在，则是对原有文件内容的覆盖。
6.3 支持任意位置的“插入”。