java中io流浅析

时间：2022-12-19 17:48:41

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流分类　：

java中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 支持任意位置的“插入”。

相关文章