欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

Java中的IO流之输入流|乐字节

程序员文章站 2022-07-05 08:42:54
亲爱的乐字节的小伙伴们,小乐又来分享Java技术文章了。上一篇写到了IO流,这篇文章着重 谈谈输入流,再下次再说输出流。 点击回顾上一篇:乐字节Java之file、IO流基础知识和操作步骤 一、 输入流 字节流和字符流的操作方式几乎完全一样,只是操作的数据单元不同而已 。字节流可 以操作所有文件,字 ......

亲爱的乐字节的小伙伴们,小乐又来分享java技术文章了。上一篇写到了io流,这篇文章着重 谈谈输入流,再下次再说输出流。

点击回顾上一篇:乐字节java之file、io流基础知识和操作步骤

 

一、 输入流

字节流和字符流的操作方式几乎完全一样,只是操作的数据单元不同而已 。字节流可

以操作所有文件,字符流仅操作纯文本。

1、抽象类:inputstream 和 reader

inputstream和reader是所有输入流的基类,它们是两个抽象类,是所有输入流的模版,其中定义的方法在所有输入流中都可以使用。

在inputstream里包含如下三个方法:

Java中的IO流之输入流|乐字节

在reader中包含如下三个方法:

Java中的IO流之输入流|乐字节

对比inputstream和reader 所提供的方法,可以看出这两个基类的功能基本相似。返回结果为-1 时表明到了输入流的结束点。 inputstream 和 reade 都是抽象的,不能直接创建它们的实例,可以使用它们的子类。

2、文件节点类: fileinputstream 和 filereader

fileinputstream 和 filereader,它们都是节点流,直接和指定文件关联。 操作方式

基本一致。

1)、单个字节读取

以fileinputstream为例:

public class singlefileread {
	public static void main(string[] args) {
		// 1、建立联系 file对象
		file file = new file("f:/io/test.txt");
		// 2、选择流
		inputstream in = null;// 提升作用域
		try {
			in = new fileinputstream(file);
			// 3、操作 单个字节读取
		long filelength = file.length(); // 接收实际读取的字节数
			// 计数器
			system.out.println(filelength);
			long num = 0;
			// 循环读取
			while (num < filelength) {
				char ch = (char) in.read();
				system.out.println(ch);
				num++;
			}
		} catch (filenotfoundexception e) {
			// todo auto-generated catch block
			e.printstacktrace();
			system.out.println("文件不存在,不能进行下一步操作");
		} catch (ioexception e) {
			// todo auto-generated catch block
			e.printstacktrace();
			system.out.println("读取文件失败");
		} finally {
			try {
				// 4、释放资料
				if (in != null) {
					in.close();
				}
			} catch (ioexception e) {
				// todo auto-generated catch block
				e.printstacktrace();
				system.out.println("关闭文件输入流失败");
			}
		}
	}
}

乐字节原创

 

2)、批量读取(字节|字符重点)

public class readfile {
	public static void main(string[] args) {
		//1、字节读取:建立联系    file对象
		file file=new file("f:/io/test.txt");
		//2、选择流
		inputstream in=null;//提升作用域
		try {
			in=new fileinputstream(file);
			//3、操作   不断读取   缓冲数组
			byte[]car=new byte[1024];
			int len=0;	//接收实际读取的大小
			//循环读取
			while(-1!=(len=in.read(car))){
				//输出,字节数组转成字符串
				string info=new string(car,0,len);
				system.out.println(info);
			}
		} catch (filenotfoundexception e) {
			// todo auto-generated catch block
			e.printstacktrace();
			system.out.println("文件不存在");
		} catch (ioexception e) {
			// todo auto-generated catch block
			e.printstacktrace();
			system.out.println("读取文件失败");
		}finally{
			try {
				//4、释放资料
				if(in!=null){
					in.close();
				}
			} catch (ioexception e) {
				// todo auto-generated catch block
				e.printstacktrace();
				system.out.println("关闭文件输入流失败");
			}
		}
	}
}
//字符读取1、创建源
		file src=new file("f:/char.txt");
		//2、选择流
		reader reader=new filereader(src);
             //3、读取操作
		char[] flush=new char[1024];
		int len=0;
		while(-1!=(len=reader.read(flush))){
			//字符数组转换为字符串
			string str=new string(flush,0,len);
			system.out.println(str);
		}
//4、释放资源 
	      reader.close();
乐字节原创

 

3、缓冲处理类:bufferedinputstream和 bufferedreader(重点)

缓冲提高性能: 字节流直接套上即可;字符缓冲流 +新增方法(不能使用多态)

//1、创建源,建立联系   
file src =new file("test.txt"); 
//2、选择缓冲流   
    inputstream is =new bufferedinputstream(new fileinputstream(src));   //3、操作  :  多个读取        
    byte[] car =new byte[2]; 
    int len =0;       
while(-1!=(len=is.read(car))){          
//获取数组的内容   字节数组转字符串  new string(字节数组,0,length) 
      system.out.println(new string(car,0,len));           
    } 
    //4、释放资源 
    is.close(); 
//创建源:   
    file src =new file("test.txt"); 
//使用字符缓冲流  提高性能读取文件  +新增方法(不能使用多态) 
    bufferedreader br =new bufferedreader(new filereader(src)); 
//操作  行读取
string line=null; 
while(null!=(line=br.readline())){ 
        system.out.println(line); 
} 
//释放资源     
br.close();

 

4、转换处理流: inputstreamreader

转换流:将字节流转为字符流 处理乱码(编码集、解码集)。

//读取文件 
    file src =new file("test.txt"); 
//转换流 
    bufferedreader br =new bufferedreader( 
          new inputstreamreader( 
                new bufferedinputstream( 
                      new fileinputstream( 
                            src 
                          )             
       
                    ),"utf-8" 
              )         
        ); 
//行读取 
    string msg =null; 
    while(null!=(msg =br.readline())){ 
      system.out.println(msg); 
    } 
    br.close();

5、字节数组节点类: bytearrayinputstream

操作的节点为字节数组,数组在jvm 内存中,由垃圾回收机制管理,不需要手动关闭

//1、创建源 
    byte[] src ="io 学习入门".getbytes(); 
//2、选择流 
inputstream is = new bytearrayinputstream(src);
//3、操作 与文件一致 
  byte[] flush =new byte[10]; 
  int len =0; 
  while(-1!=(len =is.read(flush))){ 
    system.out.println(new string(flush,0,len)); 
  } 
//4、释放  
  is.close();

6、数据处理流:datainputstream

可以处理基本类型+string,保留数据的类型。前提是读取顺序与写出顺序一致,否则读取数据不正确

/**
	 * 数据+类型	输出到文件
	 * @param destpath
	 * @throws ioexception 
	 */
	public static void write(string destpath) throws ioexception{
		int point=2;
		long num=100l;
		string str="数据类型";
		//创建源
		file dest=new file(destpath);
		//选择流
		dataoutputstream dos=new dataoutputstream(new bufferedoutputstream(new fileoutputstream(dest)));
		//操作	写出的顺序 		为读取作准备
		dos.writeint(point);
		dos.writelong(num);
		dos.writeutf(str);
		dos.flush();
		//释放资源
		dos.close();
	}

 

7、对象处理流(反序列化):objectinputstream

/**
	 * 反序列化:
	 * 1、先写入再读取
	 * 2、读取对象需要知道具体类型,依次读取
	 * 注意:
	 * 1)不是所有的对象都可以序列化	serializable
	 * 2)不是所有的属性都需要序列化	transient	
	 */	
public static void read(string srcpath) throws filenotfoundexception, ioexception, classnotfoundexception{
		//创建源
		file src=new file(srcpath);
		//选择流	ojbectinputstream
		objectinputstream dis=new objectinputstream(
				new bufferedinputstream(
						new fileinputstream(src)
						)
				);
		//操作	读取的顺序与写出的顺序一致		必须存在才能读取
		object obj=dis.readobject();
		if(obj instanceof employee){
			employee emp=(employee)obj;
			system.out.println(emp.getname());
			system.out.println(emp.getsalary());
		}
		obj=dis.readobject();
		int[]arr=(int[])obj;
		system.out.println(arrays.tostring(arr));
		//释放资源
		dis.close();
	}

java中的io流-输入流就介绍到这里了,下次再说输出流。

乐字节原创,更多java技术干货持续更新,欢迎关注。