Java核心技术----IO（输入/输出）

最新推荐文章于 2024-04-10 00:36:17 发布

情绪员Tim

最新推荐文章于 2024-04-10 00:36:17 发布

阅读量450

点赞数 1

分类专栏： JavaSE 文章标签： java 开发语言后端

本文链接：https://blog.csdn.net/QQ675396947/article/details/121088772

版权

JavaSE 专栏收录该内容

59 篇文章 12 订阅

订阅专栏

一、流概述

流是一组有序的数据序列，根据操作的类型，可分为输入流（Input）和输出流（Output）两种。

二、输入输出流

1、输入流

InputStream类是字节输入流的抽象类，是所有字节输入流的父类。

该类中所有方法遇到错误时都会引发IOException异常。

Reader类是字符输入流的抽象类，所有字符输入流的实现都是它的子类，Reader类的具体层次结构如下图所示：

2、输出流

OutputStream类是字节输入流的抽象类，此抽象类是表示输出字节流的所有类的超类。

OutputStream类中的所有方法均返回void，在遇到错误时会引发IOException异常。

Writer类是字符输出流的抽象类，所有字符输出类的实现都是它的子类，Writer类的层次结构如下图所示：

三、File类

1、文件的创建与删除

可以使用File类创建一个文件对象，通常使用以下3种构造方法来创建文件对象。

File(String pathname)

new File(String pathname)

pathname指定途径名称（包含文件名）。

File file=new File("c:/1.txt")

File(String parent , String child)

new File(String parent，String child)

parent：父路径字符串，例如C:/或者C:/doc。

child：子路径字符串，例如letter.txt。

File(File f , String child)

new File(File f,String child)

f：父路径对象，例如E:/doc/。

chilid：子路径字符串，例如letter.txt。

package bao;

import java.io.File;

public class Demo1 {        //创建类
	public static void main(String[] args){     //主方法
	File file=new File("word.txt");
	if(file.exists()) {         //如果文件纯在
		file.delete();        //删除该文件
		System.out.println("文件已删除！");    
	}else {
		try {
			file.createNewFile();    //创建该文件
			System.out.println("文件已创建");
		}catch(Exception e) {
			e.printStackTrace();
		}
	}
	}
}



/*输出结果：
文件已创建
 */

2、获取文件信息

File类提供了很多方法用于获取文件本身的一些信息，File类的常用方法如下表所示。

package bao;

import java.io.File;

public class Demo1 {        //创建类
	public static void main(String[] args){     //主方法
	File file=new File("word.txt");      //创建文件对象
	if(file.exists()) {                  //如果文件纯在
		String name=file.getName();      //获取文件名字
		long length=file.length();       //获取文件长度
		boolean hidden=file.isHidden();     //判断是否为隐藏文件
		System.out.println("文件名称："+name);
		System.out.println("文件长度是："+length);
		System.out.println("该文件是隐藏文件吗？"+hidden);    
	}else {
			System.out.println("改文件不存在！");
	
		}
	}
}



/*输出结果：
文件名称：word.txt
文件长度是：0
该文件是隐藏文件吗？false
 */

四、文件输入输出流

1、FileInputStream与FileOutputStream类（文件字节流）

FileInputStream类与FileOutputStream类都是用来操作磁盘文件。如果用户的文件读取需求比较简单，则可以使用FileInputStream类。该类继承自InputStream类。FileOutputStream类与FileInputStream类对应，提供了基本的文件写入能力。FileOutputStream类是OutoputStream类的子类。

package bao;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;

public class Demo1 {        //创建类
	public static void main(String[] args){     //主方法
	File file=new File("word.txt");      //创建文件对象
	try {
		FileOutputStream out=new FileOutputStream(file);      //创建FileOutputStream对象
		byte bo[]="啦啦啦啦，啦啦黑猫警长。".getBytes();      //创建Byte类型数组
		out.write(bo);           //将数组中的信息写入到文件中
		out.close();            //将流关闭
	}catch(Exception e) {      
		e.printStackTrace();
	}
	try {
		FileInputStream in=new FileInputStream(file);
		byte bi[]=new byte[1024];        //创建Byte类型数组
		int len=in.read(bi);             //从文件中读取信息
		System.out.println("文件中的信息是："+new String(bi,0,len));   //将文件中的信息输出
		in.close();        //关闭流
	}catch(Exception e) {
		e.printStackTrace();
	}
	
	}
}



/*输出结果：
文件中的信息是：啦啦啦啦，啦啦黑猫警长。
 */

2、FileReader类和FileWriter类（文件字符流）

使用FileOutputStream类向文件中写入数据与使用FileInputStream类从文件中将内容读出来，存在一点不足，即这两个类都只提供了对字节或字节数组的读取方法。由于汉字在文件中占用两个字节，如果使用字节流，读取不好可能会出现乱码现象。此时采用字符流Reader或Writer类即可避免这种现象。 FileReader、FileWriter字符流对应了FileInputStream、FileOutputStream类。FileReader流顺序地读取文件，只要不关闭流，每次调用read()方法就顺序地读取源中其余的内容，直到源的末尾或流被关闭。

五、带缓存的输入输出流

1、BufferedInputStream类与BufferedOutputStream类（缓冲字节流）

BufferedInputStream类可以对任何的InputStream类进行带缓存区的包装以达到性能的优化。

BufferedInputStream的两种构造方法：

BufferedInputStream(InputStream in)

BufferedInputStream(InputStream in,int size)

使用BufferedOutputStream输出信息和往OutputStream输出信息完全一样，只不过BufferedOutputStream有一个flush()方法用来将缓存区的数据强制输出完。

BufferedOutputStream(OutputStream in)

BufferedOutputStream(OutputStream in,in size)

2、BufferedReader与BufferedWriter类（缓冲字符流）

BufferedReader类与BufferedWriter类分别继承Reader类与Writer类。这两个类同样具有内部缓存机制，并可以以行为单位进行输入输出。在使用BufferedWriter类的Write()方法时，数据并没有立刻被写入至输出流中，而是首先进入缓存区中。如果想立刻将缓存区中的数据写入输出流中，一定要调用flush()方法。

BufferedReader类常用方法：

read()方法：读取单个字符。

readLine()方法：读取一个文本行，并将其返回为字符串。

write(String s,int off,int len)方法：写入字符串的某一部分。

flush()方法：刷新该流的缓存。

newLine()方法：写入一个分隔符。

package bao;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;

public class Demo1 {        //创建类
	public static void main(String[] args){     //主方法
      String conte[]= {"张三","李四","王五"};
      File file=new File("word.txt");
      try {
    	  FileWriter fw=new FileWriter(file);     //创建FileWriter对象（文件字符输出流）
    	  BufferedWriter bw=new BufferedWriter(fw);   //创建BufferedWriter对象
    	  for(int i=0;i<conte.length;i++) {          //循环遍历数组
    		  bw.write(conte[i]);         //将字符串数组的元素写入到磁盘文件中
    		  bw.newLine();       //将数组的单个元素行的形式写入文件
    	  }
    	  bw.close();           //关闭FileWriter流
    	  fw.close();           //关闭BufferedWriter流
      }catch(Exception e){
    	  e.printStackTrace();
      }
      try {
    	  FileReader fr=new FileReader(file);
    	  BufferedReader br=new BufferedReader(fr);
    	  String s=null;
    	  int a=0;
    	    //如果文件文本行数部位null，则进入循环
    	  while((s=br.readLine())!=null) {
    		  a++;
    		  System.out.println("第"+a+"行："+s);
    	  }
    	  br.close();        //关闭FileReader流
    	  fr.close();        //关闭BufferedReader流
      }catch(Exception e) {
    	  e.printStackTrace();
      }
	}
}



/*输出结果：
第1行：张三
第2行：李四
第3行：王五
 */

六、数据输入输出流

数据输入输出流（DataInputStream类与DataOutputStream类）允许应用程序以与机器无关的方式从底层输入流中读取基本Java数据类型。也就是说，当读取一个数据时，不必再关心这个数值应当是什么字节。

DataOutputStream类字符串方法：

writeBytes(String s)

writechars(String s)

writeUTF(String s)

package bao;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;

public class Demo1 {        //创建类
	public static void main(String[] args){     //主方法
      
      try {
    	 FileOutputStream fs=new FileOutputStream("word.txt");
    	 DataOutputStream ds=new DataOutputStream(fs);
    	
    	 ds.writeUTF("使用writeUTF()");
     	 ds.writeChars("使用writeChars()");
    	 ds.writeBytes("使用writeBytes()");
   
    	
    	 ds.close();
    	 
    	 FileInputStream fi=new FileInputStream("word.txt");
    	 DataInputStream di=new DataInputStream(fi);
    	 
    	 System.out.println(di.readUTF());
      }catch(Exception e){
    	  e.printStackTrace();
      }
	}
}



/*输出结果：
使用writeUTF()
 */

七、ZIP压缩输入输出流

1、压缩文件（ZipOutputStream类）

利用ZipOutputStream类对象，可将文件压缩为“.zip”文件。ZipOutputStream类的构造函数如下所示：

ZipOutputStream(OutputStream out);

ZipOutputStream类的常用方法如下表所示：

在E盘创建hello文件夹，文件夹里面创建hello1.txt和hello2.txt.

package bao;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;

public class Demo1 {        //创建类
	private void zip(String zipFileName, File inputFile) throws Exception {
		ZipOutputStream out = new ZipOutputStream(new FileOutputStream(
				zipFileName)); // 创建ZipOutputStream类对象
		zip(out, inputFile, ""); // 调用方法
		System.out.println("压缩中…"); // 输出信息
		out.close(); // 将流关闭
	}
	
	private void zip(ZipOutputStream out, File f, String base)
			throws Exception { // 方法重载
		if (f.isDirectory()) { // 测试此抽象路径名表示的文件是否是一个目录
			File[] fl = f.listFiles(); // 获取路径数组
			out.putNextEntry(new ZipEntry(base + "/")); // 写入此目录的entry
			base = base.length() == 0 ? "" : base + "/"; // 判断参数是否为空
			for (int i = 0; i < fl.length; i++) { // 循环遍历数组中文件
				zip(out, fl[i], base + fl[i]);
			}
		} else {
			out.putNextEntry(new ZipEntry(base)); // 创建新的进入点
			// 创建FileInputStream对象
			FileInputStream in = new FileInputStream(f);
			int b; // 定义int型变量
			System.out.println(base);
			while ((b = in.read()) != -1) { // 如果没有到达流的尾部
				out.write(b); // 将字节写入当前ZIP条目
			}
			in.close(); // 关闭流
		}
	}
	
	public static void main(String[] temp) { // 主方法
		Demo1 book = new Demo1(); // 创建本例对象
		try {
			// 调用方法，参数为压缩后文件与要压缩文件
			book.zip("E:/hellopp.zip", new File("E:/hello"));
			System.out.println("压缩完成"); // 输出信息
		} catch (Exception ex) {
			ex.printStackTrace();
		}
	}
}



/*输出结果：
E:\hello\hello1.txt
E:\hello\hello2.txt
压缩中…
压缩完成

 */

成果：

2、解压缩ZIP文件（ZipInputStream类）

ZipInputStream类可读取ZIP压缩格式的文件，包括对已压缩和未压缩条目的支持（entry）。ZipInputStream类的构造函数如下所示：

ZipInputStream(InputStream in)

ZipInputStream类的常用方法如下表所示：

package bao;
import java.io.*;
import java.util.zip.*;

public class Demo1 { // 创建文件
	public static void main(String[] temp) {
		ZipInputStream zin; // 创建ZipInputStream对象
		try { // try语句捕获可能发生的异常
			zin = new ZipInputStream(new FileInputStream("E:/hellopp.zip"));
			// 实例化对象，指明要进行解压的文件
			ZipEntry entry = zin.getNextEntry(); // 获取下一个ZipEntry
			while (((entry = zin.getNextEntry()) != null)
					&& !entry.isDirectory()) {
				// 如果entry不为空，并不在同一目录下
				File file = new File( entry.getName()); // 获取文件目录
				System.out.println(file);
				if (!file.exists()) { // 如果该文件不存在
					file.mkdirs();// 创建文件所在文件夹
					file.createNewFile(); // 创建文件
				}
				zin.closeEntry(); // 关闭当前entry
				System.out.println(entry.getName() + "解压成功");
			}
			zin.close(); // 关闭流
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}
/*
 * 输出结果：
 E:\hello\hello1.txt
E:\hello\hello1.txt解压成功
E:\hello\hello2.txt
E:\hello\hello2.txt解压成功

 * */

情绪员Tim

关注

1
点赞
踩
6

收藏

觉得还不错? 一键收藏
打赏
0
评论
Java核心技术----IO（输入/输出）

一、流概述流是一组有序的数据序列，根据操作的类型，可分为输入流（Input）和输出流（Output）两种。二、输入输出流1、输入流InputStream类是字节输入流的抽象类，是所有字节输入流的父类。该类中所有方法遇到错误时都会引发IOException异常。Reader类是字符输入流的抽象类，所有字符输入流的实现都是它的子类，Reader类的具体层次结构如下图所示：2、输出流OutputStream类是字节输入流的抽象类，此抽象类是表示输出字节...
复制链接

扫一扫