java中io流浅析

Posted superficial。

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了java中io流浅析相关的知识,希望对你有一定的参考价值。

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

以上是关于java中io流浅析的主要内容,如果未能解决你的问题,请参考以下文章

java内存流:java.io.ByteArrayInputStreamjava.io.ByteArrayOutputStreamjava.io.CharArrayReaderjava.io(代码片段

java缓冲字符字节输入输出流:java.io.BufferedReaderjava.io.BufferedWriterjava.io.BufferedInputStreamjava.io.(代码片段

芯学苑:浅析Java字节流和字符流

Java NIO

来了!PostgreSQL 同步流复制原理和代码浅析,请签收

.26-浅析webpack源码之事件流make