Java基础：文件管理与I/O流

最新推荐文章于 2024-03-21 23:55:03 发布
最新推荐文章于 2024-03-21 23:55:03 发布
阅读量515 收藏 4
点赞数
分类专栏： Java基础 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sssxlxwbwz/article/details/122497847
版权

Java语言使用File类对文件和目录进行操作，查找文件时需要实现FilenameFilter或FileFilter接口。另外，读写文件内容可以通过FileInputStream、FileOutputStream、FileReader和FileWriter类实现。

一、File类

File 类是 Java 处理文件 I/O 的基础。这个抽象既能表示文件，也能表示目录。也就是说文件和目录是可以通过File封装成对象的。

1.1 File类构造函数

  • File(String path)：如果path是实际存在的路径，则该File对象表示的是目录；如果path是文件名，则该File对象表示的是文件
  • File(String path, String name)：path是路径名，name是文件名。
  • File(File dir, String name)：dir是路径对象，name是文件名
	public void test(){
		// File(String pathname)：通过一个路径名创建File对象
		File file = new File("D:\\demo\\a.txt"); 
		System.out.println(file.toString());
		// File(String parent, String child)： 通过父路径和子路径名创建File对象
		File file2 = new File("D:\\demo", "a.txt");
		System.out.println(file2.toString());
		// File(File parent, String child)：通过父路径File对象和子路径名创建File对象
		File file3 = new File("D:\\demo");
		System.out.println(file3.toString());
		File file4 = new File(file3, "a.txt");
		System.out.println(file4.toString());
	}

         程序运行结果：

1.2 File类创建功能

方法名说明
boolean createNewFile()

当具有该名称的文件不存在时，创建一个由该抽象路径命名的新空文件

如果文件不存在，就创建文件并返回true

如果文件存在，就返回false

boolean mkdir()

创建由此抽象路径名命名的目录

如果目录不存在，就创建文件并返回true

如果目录存在，就返回false

boolean mkdirs()

创建由此抽象路径名命名的目录，包含任何必须但不存在的父目录

如果目录不存在，就创建文件并返回true

如果目录存在，就返回false

	/*
	 * 创建功能：
	 * A:创建文件,如果文件不存在，就创建。存在，就不创建。
	 * 		public boolean createNewFile() throws IOException
	 * 		
	 * B:创建文件夹，如果文件夹不存在，就创建。存在，就不创建。
	 * 	 public boolean mkdir() 单级文件夹
	 *   public boolean mkdirs() 多级文件夹
	 *   
	 * 到底创建的是文件还是文件夹，取决于你使用的方法。不取决于后缀名。
	 */
	 public void CreatFile() throws IOException{
		// 创建File文件
		File file = new File("d:\\a.txt");  //File：文件和目录名的抽象表现形式
		// public boolean createNewFile() throws IOException
		System.out.println("createNewFile:" + file.createNewFile());
		
		// 创建目录
	    File file2 = new File("d:\\demo");
		System.out.println("mkdir:" + file2.mkdir());
		
		// 创建多级目录
		File file3 = new File("d:\\ccc\\dddd\\eee\\fff");
		System.out.println("mkdirs:" + file3.mkdirs());
	 }

1.3 File类判断和获取功能

方法名说明
public boolean isDirectory()测试此抽象路径名表示的File是否为目录
public boolean isFile()测试此抽象路径名表示的File是否为文件
public boolean exists()测试此抽象路径名表示的File是否存在
public String getAbsolutePath()返回抽象路径名的绝对路径名字符串
public String getPath()将此抽象路径名转换为路径名字符串
public String getName()返回由此抽象路径名表示的文件或目录的名称
public String[] list()返回此抽象路径名表示的目录中的文件和目录的名称字符串数组
public File[] listFiles()返回此抽象路径名表示的目录中的文件和目录的File对象数组

1.4 File类的删除功能

方法名说明
public boolean delete()删除由此抽象路径名表示的文件或目录

二、流

        Java将数据的输入输出（I/O）操作当作“流”来处理，“流”是一组有序的数据序列。“流”分为两种形式：输入流和输出流，从数据源中读取数据是输入流，将数据写入到目的地是输出流。

2.1 Java流的设计理念

       如下图，数据输入的数据源有多种形式，如文件、网络和键盘等，键盘是默认的标准输入设备。而数据输出的目的地也有多种形式，如文件、网络和控制台，控制台是默认的标准输出设备。

 所有的输入形式都抽象为输入流，所有的输出形式都抽象为输出流，它们与设备无关。

2.2 流的分类

        以字节为单位的流称为字节流，以字符为单位的流称为字符流。Java SE提供4个顶级抽象类，两个字节流抽象类：InputStream和OutputStream；两个字符流抽象类：Reader和Writer。 

字节输入流：

        字节输入流根类是InputStream，其子类如下图所示：

yH5BAAAAAAALAAAAAAOAA4AAAIMhI+py+0Po5y02qsKADs=wAAACH5BAEKAAAALAAAAAABAAEAAAICRAEAOw==

InputStream主要方法如下：

  • int read()：读取一个字节，返回0到255范围内的int字节值。如果已经到达流末尾，而且没有可用的字节，则返回值-1。 
  • int read(byte b[] )：读取多个字节，数据放到字节数组b中，返回值为实际读取的字节的数
    量，如果已经到达流末尾，而且没有可用的字节，则返回值-1。
  • int read(byte b[ ], int off, int len)：最多读取len个字节，数据放到以下标off开始字节数组b中，将读取的第一个字节存储在元素b[off]中，下一个存储在b[off+1]中，依次类推。返回值为实际读取的字节的数量，如果已经到达流末尾，而且没有可用的字节，则返回值-1。
  • void close()：流操作完毕后必须关闭。

字节输入流FileInputStream类使用示例：


/*
 * 字节输入流读数据步骤：
 * A:创建字节输入流对象
 * B:调用方法，读取数据
 * C:释放资源
 * 
 * 字节输入流读取数据有两种方式:
 * A:一次读取一个字节
 * B:一次读取一个字节数组
 * 
 * 一次读取一个字节：public int read()
 */
public class InputStreamTest {

	public static void main(String[] args) {
		InputStreamTest inStream = new InputStreamTest();
		try {
			inStream.CopyFileTest();
		} catch (IOException e) {
			// TODO 自动生成的 catch 块
			e.printStackTrace();
		}
	}
	
	/**
	 * 一次读取一个字节，循环读取。当读取到文件末尾时，返回值为-1
	 * @throws IOException
	 */
    public void InputTest() throws IOException{
    	File file = new File("F:\\a.txt");
    	// 创建字节输入流对象
    	// FileInputStream fis = new FileInputStream("fis.txt");
    	FileInputStream fis = new FileInputStream(file);
		
		int by = 0;
		//fis.read() 从输入流中读取一个字节返回int型变量，若到达文件末尾，则返回-1
		//读取的是字节，为何返回int型数据:
		/*   1、方法解释中的-1相当于是数据字典告诉调用者文件已到底，可以结束读取了，这里的-1是Int型
         *   2、那么当文件未到底时，我们读取的是字节，若返回byte类型，那么势必造成同一方法返回类型不同的情况，这是不允许的
         *   3、我们读取的字节实际是由8位二进制组成，二进制文件不利于直观查看，可以转成常用的十进制进行展示，因此需要把读取的字节从二进制转成十进制整数，故返回int型
         *   4、 因此结合以上3点，保证返回类型一致以及直观查看的情况，因此该方法虽然读取的是字节但返回int型
		 * 
		 * */
		while ((by = fis.read()) != -1) {  //从输入流中读取一个字节返回int型变量，若到达文件末尾，则返回-1
			System.out.print((char) by);
		}
		
		fis.close();
    }
    
    /*
     * 为了提高读取数据的效率，就有了第二种方案。
     * 一次读取一个字节数组：public int read(byte[] b):返回的是实际的读取长度，把数据读取到字节数组中
     */
    public void InputTest2() throws IOException{
    	// 创建字节输入流对象
    	FileInputStream fis = new FileInputStream("C:\\Users\\lenovo\\Pictures\\变形记.txt");
        
		byte[] bys = new byte[1024 * 1024]; // 这里的数据一般是1024或者其整数倍
		int len = 0;
		while ((len = fis.read(bys)) != -1) {
			System.out.println(new String(bys, 0, len));
			System.out.println();
		}
		fis.close();
    }
    
    public void CopyFileTest() throws IOException{
    	File file = new File("C:\\Users\\lenovo\\Pictures\\变形记.txt");
    	File file2 = new File("F:\\b.txt");
    	
    	FileInputStream fis = new FileInputStream(file);
    	FileOutputStream fos = new FileOutputStream(file2);
    	
    	//读取数据的存放地址
    	byte by[] = new byte[1024];
    	int len=0;
    	while((len = fis.read(by))!=-1){
    		System.out.println(new String(by, 0, len));
    		//写数据
    		fos.write(by,0,len);
    	}
    	//释放资源
    	fos.close();
    	fis.close();
    }
}

字节输出流

         字节输出流根类是OutputStream，其子类如下图所示：

OutputStream主要方法如下：

  •  void write(int b)：将b写入到输出流，b是int类型占有32位，写入过程是写入b 的8个低位，b的24个高位将被忽略。
  • void write(byte b[ ])：将b.length个字节从指定字节数组b写入到输出流。
  • void write(byte b[ ], int off, int len)：把字节数组b中从下标off开始，长度为len的字节写入到输出流。
  • void flush()：刷空输出流，并输出所有被缓存的字节。由于某些流支持缓存功能，该方法将把缓存中所有内容强制输出到流中
  • void close( )：流操作完毕后必须关闭。

 字节输出流FileOutputStream类使用示例： 

/*
 * 
 * 需求：请把一句话："helloworld"写入一个文本文件。
 * 通过简单的分析后，我们找到了OutputStream。
 * 由于OutputStream是一个抽象类，所以我们应该找其子类来学习。
 * 学习前，我们先回想一个问题，就是硬盘上的文件，java提供了哪个类表示呢?File
 * 再结合现在的字节输出流OutputStream，两个拼接一下就有了一个新的名字：FileOutputStream
 * 
 * FileOutputStream的构造方法：
 * 		FileOutputStream(File file)
 * 		FileOutputStream(String name)
 * 
 * 字节输出流操作步骤：
 * 		A:创建字节输出流对象
 * 		B:调用写数据功能写数据
 * 		C:释放资源
 * 
 * 练习：请把字节的名字写到一个文本文件
 */
public class OutStreamTest {
	
	public void WriteTxt() throws IOException{
		//创建字节输出流
		/*
		 * 创建字节输入流对象做了哪些事情呢? A:调用系统功能创建了一个文件a.txt B:创建了一个对象fos
		 * C:把fos对象指向了a.txt文件
		 */
		FileOutputStream fos = new FileOutputStream("F:\\a.txt");  
		// 写数据
		// public void write(int b):一次写一个字节的数据
		// fos.write(57);
		// fos.write(55);
		// fos.write(97);

		// public void write(byte[] b):一次写一个字节数组的数据
		// byte[] bys = {97,98,99,100,101};
		// fos.write(bys);
		// 曾经我们讲解过，可以通过String得到byte[]
		// byte[] bys = "abcde".getBytes();
		// fos.write(bys);
		fos.write("wyf12".getBytes());
		
		// public void write(byte[] b,int off,int len):一次写一个字节数组的一部分
		// fos.write("helloworld".getBytes(), 0, 5);
		// fos.write("helloworld".getBytes(), 0, "helloworld".length());
		
		//释放资源
		//关闭此文件输出流并释放与此流有关的所有系统资源。
		/*
		 * 两件事情：
		 * A:关闭流对象(流对象不可以继续在写数据了)
		 * B:释放与此流相关的资源(通知系统去释放与此流相关的资源)
		 */
		fos.close();
		System.out.println("完成！");
	}
	
	/*
	 * 两个小问题：
	 * A:实现数据的换行?
	 * 		不同的系统，针对换行符号的识别是不一样的。
	 * 		Mac:		\r
	 * 		linux:		\n
	 * 		windows:	\r\n
	 * 		系统自带的记事本软件，只能识别该系统能够识别的换行。
	 * 		而Eclipse自带的记事本，以及Editplus却可以识别任意的换行符。
	 * 
	 * B:实现数据的追加写入? 
	 * 		public FileOutputStream(String name,boolean append)
	 * 		如果第二个参数为 true，则将字节写入文件末尾处，而不是写入文件开始处。
	 */
	public void WriteEnter() throws IOException{
		File file = new File("F:\\a.txt");
		FileOutputStream fos = new FileOutputStream(file,true);  //写入的方式是向末尾追加数据
		
		for(int i=0;i<10;i++){
			fos.write(("hello!"+String.valueOf(i)+" \r\n").getBytes());
		}
		
		// 释放资源
		fos.close();
	}
	
	public static void main(String[] arg){
		OutStreamTest test = new OutStreamTest();
		try {
			test.WriteTxt();
			test.WriteEnter();
		} catch (IOException e) {
			// TODO 自动生成的 catch 块
			e.printStackTrace();
		}
	}
}

        由上面的FileInputStream示例和FileOutputStream示例可以看出，以数组的方式读写数据比一次一个字节的读写方式快的多，因此Java本身在设计的时候，就设计出内置数组的缓冲区流！

        字节缓冲输入流BufferedInputStream和字节缓冲输出流BufferedOutputStream示例代码如下：

/*
 * 由于数组的方式一次比一个字节的方式快很多，所以，java本身在设计的时候，也考虑到了。
 * 就设计出了内置数组的缓冲区流。
 * 字节缓冲输入流
 * 		BufferedInputStream
 * 字节缓冲输出流
 * 		BufferedOutputStream
 * 
 * 通过看构造方法，我们发现，缓冲流不能直接操作文件。
 * 是建立在基本的操作流之上的。
 * 所以，这种流也被称之为高级流。
 */
public class BufferInOutputTest {
	
	//输入缓冲流。
	public void BufferInTest() throws IOException{
		// 读数据
		BufferedInputStream bis = new BufferedInputStream(new FileInputStream("F:\\a.txt"));
		int by=0;
		while((by=bis.read())!=-1){  //一个字节一个字节读
			System.out.print((char)by);
		}
		System.out.println("---------------------------");
		
		bis = new BufferedInputStream(new FileInputStream("F:\\a.txt"));
		byte[] bys = new byte[1024];
		int len = 0;
		while ((len = bis.read(bys)) != -1) {  
			System.out.print(new String(bys, 0, len));
		}
		bis.close();
	}
	
	//输出缓冲流
	public void BufferOutTest() throws IOException{
		//写数据
		BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("F:\\a.txt",true));
		bos.write("WangYunfei\r\n".getBytes());
	    bos.close(); //释放资源
	}
	
	public static void main(String[] arg){
		BufferInOutputTest bf = new BufferInOutputTest();
		try {
			bf.BufferOutTest();
			bf.BufferInTest();
		} catch (IOException e) {
			// TODO 自动生成的 catch 块
			e.printStackTrace();
		}
	}
}

对比四种不同读写数据方式的效率：


/*
 * 数据源：
 * 		F:\\哥有老婆.mp4
 * 目的地：
 * 		项目路径下D:\\copy.mp4
 * 
 * 四种方式：
 * A:基本字节流一次读写一个字节	37100毫秒
 * B:基本字节流一次读写一个字节数组	共耗时：51毫秒
 * C:高效字节流一次读写一个字节	共耗时：368毫秒
 * D:高效字节流一次读写一个字节数组	共耗时：16毫秒
 */
public class IOReadWrite {

	public static void main(String[] arg){
		IOReadWrite ioRw = new IOReadWrite();
		try {
			ioRw.method4();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
	
	//方法1： 基本字节流一次读写一个字节(FileInputStream\FileOutputStream)
	public void method1() throws IOException{
		File file = new File("F:\\哥有老婆.mp4");
		File file2 = new File("D:\\copy1.mp4");
		//基本文件输入字节流
		FileInputStream fis = new FileInputStream(file);
		//基本文件输出字节流
		FileOutputStream fos = new FileOutputStream(file2);
		
		int by;
		long startTime = System.currentTimeMillis(); //获取开始时间
		while((by = fis.read())!=-1){  //一个字节一个字节读取
			//将读出的一个字节利用输出流写入文件
			fos.write(by);
		}
		long endTime = System.currentTimeMillis(); //获取结束时间
		//释放资源
		fis.close();
		fos.close();
		System.out.println("程序运行时间：" + (endTime - startTime) + "ms");
	}
    
	//方法2： 基本字节流一次读写一个字节数组(FileInputStream\FileOutputStream)
	public void method2() throws IOException{
		File file = new File("F:\\哥有老婆.mp4");
		File file2 = new File("D:\\copy2.mp4");
		
		//定义基本字节输入输出流
		FileInputStream fis = new FileInputStream(file);
		FileOutputStream fos = new FileOutputStream(file2);
		
		byte[] by = new byte[1024];
		int len=0;
		long startTime = System.currentTimeMillis(); //获取开始时间
		while((len = fis.read(by))!=-1){
			fos.write(by, 0, len);
		}
		long endTime = System.currentTimeMillis(); //获取结束时间
		fos.close();
		fis.close();
		System.out.println("程序运行时间：" + (endTime - startTime) + "ms");
	}
	
	//方法3：  高效字节流一次读写一个字节 (BufferedInputStream\BufferedOutputStream)
	public void method3() throws IOException{
		File file = new File("F:\\哥有老婆.mp4");
		File file2 = new File("D:\\copy3.mp4");
		
		//定义输入输出高效字节流
		BufferedInputStream bis = new BufferedInputStream(new FileInputStream(file));
		BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(file2));
		
		int by;
		long startTime = System.currentTimeMillis(); //获取开始时间
		while((by = bis.read())!=-1){
			bos.write(by);
		}
		long endTime = System.currentTimeMillis(); //获取结束时间
		
		//释放资源
		bos.close();
		bis.close();
		System.out.println("程序运行时间：" + (endTime - startTime) + "ms");
	}
	
	//方法4： 高效字节流一次读写一个字节数组 (最快的方式)(BufferedInputStream\BufferedOutputStream)
	public void method4() throws IOException{
		File file = new File("F:\\哥有老婆.mp4");
		File file2 = new File("D:\\copy4.mp4");
		
		BufferedInputStream bis = new BufferedInputStream(new FileInputStream(file));
		BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(file2));
		
		byte[] by=new byte[1024];
		int len;
		long startTime = System.currentTimeMillis();
		while((len = bis.read(by))!=-1){
			bos.write(by, 0, len);
		}
		long endTime = System.currentTimeMillis();
		
		//释放资源
		bis.close();
		bos.close();
		System.out.println("程序运行时间：" + (endTime - startTime) + "ms");
	}
}

字符输入流

        字符输入流根类是Reader，这类流以16位的Unicode编码表示的字符为基本处理单位。其子类如下图所示：

Reader主要方法如下：

  • int read()：读取一个字符，返回值范围在0~65535(0x00~0xffff)之间。如果因为已经到达流末尾，则返回值-1。
  • int read(char[] cbuf)：将字符读入到数组cbuf中，返回值为实际读取的字符的数量，如果因为已经到达流末尾，则返回值-1。
  • int read(char[] cbuf, int off, int len)：最多读取len个字符，数据放到以下标off开始字符数组 cbuf中，将读取的第一个字符存储在元素cbuf[off]中，下一个存储在cbuf[off+1]中，依次类推。返回值为实际读取的字符的数量，如果因为已经到达流末尾，则返回值-1。
  • void close()：流操作完毕后必须关闭。

 字符输出流

        字符输出流根类是Writer，这类流以16位的Unicode编码表示的字符为基本处理单位，下图为其子类。

 Writer主要方法如下：

  • void write(int c)：将整数值为c的字符写入到输出流，c是int类型占有32位，写入过程是写入c的16个低位，c的16个高位将被忽略。
  • void write(char[] cbuf)：将字符数组cbuf写入到输出流。
  • void write(char[] cbuf, int off, int len)：把字符数组cbuf中从下标off开始，长度为len的字符写入到输出流。
  • void write(String str)：将字符串str中的字符写入输出流。
  • void write(String str,int off,int len)：将字符串str中从索引off开始处的len个字符写入输出流。
  • void flush()：刷空输出流，并输出所有被缓存的字符。由于某些流支持缓存功能，该方法将把缓存中所有内容强制输出到流中。
  • void close( )：流操作完毕后必须关闭。 

InputStreamReader、BufferedReader及OutputStreamWriter、BufferedWriter使用示例：

public class IOReadWriteTest {

	public static void main(String[] arg){
		IOReadWriteTest ioRw = new IOReadWriteTest();
		File file = new File("C:\\Users\\lenovo\\Pictures\\格列佛游记.txt");
		//File file = new File("F:\\a.txt");
		try {
			ioRw.GetTxt(file);
			//ioRw.GetDataToArray(file);
		} catch (IOException e) {
			// TODO 自动生成的 catch 块
			e.printStackTrace();
		}
	}
	
	//获取Txt文件
	public void GetTxt(File file) throws IOException{
		//InputStreamReader(字节流与字符流之间的桥梁，可以指定编码格式)(因此InputStreamReader构造函数中有FileInputStream(字节流))
		InputStreamReader isr = new InputStreamReader(new FileInputStream(file),"UTF-8");
		//定义高效字符流
		BufferedReader br = new BufferedReader(isr);
		
		//方法1：高效字符流一行一行获取
//		String line = null;
//		while((line = br.readLine())!=null){
//			System.out.println(line);
//		}
		//方法2： 高效字符流一次获取一个数组
//		char[] ch = new char[1024];
//		int len=0;
//		while((len=br.read(ch))!=-1){
//			System.out.print(new String(ch,0,len));
//		}
		//方法3：高效字符流一次获取一个字符
		int len = 0;
		while((len = br.read())!=-1){
			System.out.print((char)len);
		}
		
		br.close();
	}
	/*
	 * 把ArrayList集合中的字符串数据存储到文本文件
	 * 
	 * 数据源：
	 * 		ArrayList
	 * 目的地：
	 * 		array.txt
	 */
	public void GetArrayString(File file) throws IOException{
		ArrayList<String> arr = new ArrayList<String>();
		arr.add("wang");
		arr.add("yun");
		arr.add("fei");
		
		//创建OutputStreamWriter类，将arr中的字符串按照指定的编码格式写入文本文件
		OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(file,true),"UTF-8");
		BufferedWriter bw =new BufferedWriter(osw);
		
		for(String s:arr){
			bw.write(s);
			bw.newLine();
			bw.flush();
		}
		bw.flush();
		//释放资源，在释放资源之前要先刷新
		bw.close();
	}
	
	/*
	 * 从文本文件中读取数据(每一行为一个字符串数据)到集合中，并遍历集合
	 * 
	 * 数据源：
	 * 		array.txt
	 * 目的地：
	 * 		ArrayList
	 */
	public void GetDataToArray(File file) throws IOException{
		//创建InputStreamReader类，读取txt文件中的内容
		InputStreamReader isr = new InputStreamReader(new FileInputStream(file),"UTF-8");
		BufferedReader br =new BufferedReader(isr);
		
		ArrayList<String> arr = new ArrayList<String>();
		String line = null;
		while((line = br.readLine())!= null){
			arr.add(line);
		}
		
		isr.close();
		br.close();
		
		//遍历集合
		for(String s:arr){
			System.out.println(s);
		}
	}
	
}

 结束：

 IO流分类：
            A:数据流向
               输入流    读数据
               输出流    写数据
            B:数据类型
               字节流
               字符流
            默认情况下，IO流分类说的是按照数据类型分。
   
 IO流的四个基类：
           字节流
               字节输入流    InputStream
               字节输出流    OutputStream
           字符流
                字符输入流    Reader

                字符输出流    Writer

溪午闻璐
关注
专栏目录
JAVA实现GUI文件管理器
09-06
运行方法： 运行\src\waves\chj包下面的FileManager.java文件就可以了。 没积分的朋友： https://pan.baidu.com/s/1mxTHQjohm1hHY5OB4vQEsA lxe8 运用面向对象程序设计思想，基于Java文件管理和I/O框架，实现基于图形界面的GUI文件管理器。 1、实现文件夹创建、删除、进入。 2、实现当前文件夹下的内容罗列。 3、实现文件拷贝和文件夹拷贝（文件夹拷贝指深度拷贝，包括所有子目录和文件）。 4、实现指定文件的加密和解密。 5、实现指定文件和文件夹的压缩。 6、实现压缩文件的解压。 7、文件管理器具有图形界面。 建议使用Eclipse打开项目。
Java文件管理与IO流（初学者的整理**超详细）
weixin_44627629的博客
07-26 1156
文件管理与IO文件管理File类一.File类内的三种构造方法二.File类内的常用方法File的createNewFile方法File的mkdir方法和mkdirsgetAbsoluteFile()getName()、getPath()getParent()、getParentFile()length()exists() 、isFile()、 isDirectory()list()、listFile()renameTo​(File dest)File练习 文件管理 File类 import java.io
Java 实现类似于网盘一样的文件管理功能
weixin_43832166的博客
06-09 1004
需求是使用阿里云oss存储，实现一个文件管理功能,支持新建文件夹、文件的上传、下载、批量下载、删除、批量删除、预览、移动、名称搜索、文件路径搜索等。
java学习-文件管理与IO流
weixin_49349476的博客
04-21 240
程序经常需要访问文件和目录，读取文件信息或写入信息到文件，在Java语言中对文件的读写是通过I/O流技术实现的。本文章介绍文件管理和I/O流
Java笔记19——文件管理与I/O流
来自82年的博客
07-14 748
Java学习——Java异常处理（上） 文章目录Java学习——Java异常处理（上）一、抽象类与抽象方法(1).(2).二、(1).(2).总结 一、抽象类与抽象方法 (1). (2). 二、 (1). (2). 总结 高级面向对象方法（下），（￣︶￣）↗　！！！ ...
java文件管理操作
qq_53999102的博客
02-10 1460
java文件管理操作知识点
Java使用I/O流读取文件内容的方法详解
08-25
Java使用I/O流读取文件内容的方法详解 Java使用I/O流读取文件内容的方法是Java编程中常用的文件读取方式。该方法可以将文件内容读取到程序中，并对其进行处理和分析。在Java中，I/O流是指数据流向某个对象的数据...
java基础之I/O流
10-12
Java中的I/O流是程序与外部数据交互的重要机制，它允许数据在程序、文件、网络等之间流动。I/O流分为两大类：字符流（Character Stream）和字节流（Byte Stream），每类又分为输入流（Input Stream）和输出流...
java基础知识I/O流使用详解
09-04
Java中的I/O流是编程中不可或缺的一部分，它允许程序与外部世界进行数据交换，无论是读取文件、网络通信还是处理标准输入输出。本篇将详细讲解Java中的I/O流系统，帮助你理解其基本概念、分类以及常用类的使用。 ...
java文件与I/O流
08-09
高效的课件，详细的内容介绍，针对性的代码展示，提高性的练习题目。适合新手或者基础薄弱人员学习，一个PPT解决你编程中常见的错误，最重要的是一人下载多人使用，不受限制，没有隐藏密码
Java文件的管理
最新发布
hitmengfanchao的博客
03-21 934
本节介绍了Java中文件的管理，包括：File对象的创建、获取文件或文件夹的属性、文件夹的管理、文件的创建与删除、运行可可执行文件等。
Java整合MinIO实现文件管理
北漂码农有话说
06-17 4616
MinIoMinIO基于Apache License 2.0开源协议的对象存储服务。它兼容Amazon S3云存储接口。适合存储非结构化数据，如图片，音频，视频，日志等。MinIo。
Java实现文件管理系统（附源码）
热门推荐
踮脚敲代码
04-21 2万+
文件管理越来越受到企业的重视，最近自己也做了个简单的文件管理系统，现与大家分析交流。 一.系统演示
[案例7-1]批量操作文件功能
qq_58652572的博客
04-07 6172
任务描述 在日常工作中，经常会遇到批量操作系统文件的事情，通常情况下，只能手动重复的完成批量文件的操作，这样很是费时费力。本案例要求编写一个文件管理器，实现文件的批量操作。文件管理器具体功能要求如下： 用户输入指令1，代表“指定关键字检索文件”，此时需要用户输入检索的目录和关键字，系统在用户指定的目录下检索出文件名中包含关键字的文件，并将其绝对路径展示出来。 用户输入指令2，代表“指定后缀名检索文件”，此时需要用户输入检索的目录和后缀名（多个后缀名用逗号分隔），系统在用户指定的目录下检索出指定后缀名的
文件管理，io流
m0_48281518的博客
07-16 369
文件管理、io流
文件，IO流（超详细）
W_A_Hao的博客
02-19 1296
文件和IO流总结
【Java IO流】File文件管理及IO流（基本流）
StuLearn-LJC的博客
02-06 756
在电子设备的日常使用中，我们无时不刻在对各个应用的数据进行存储和读取，正因为有了这个技术，对我们的信息存储带来了极大便利。在Java中，IO流就是用于读写文件中的数据（读写文件，或网络中的数据）。而IO流的使用，离不开文件操作，它们间存在密切的联系，通常一起用来实现文件的读取、写入和处理。总之，文件管理提供了对文件系统的操作能力，而I/O流则提供了对文件内容的读取和写入能力，二者结合使用可以实现对文件的全面管理和处理。在Java中，java.io和包提供了丰富的类和方法，支持文件管理和I/O流的操作。
文件操作 和 IO 流
m0_62269512的博客
03-26 128
文件操作 和 IO 流
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值