java中的文件_java中的文件相当于什么-优快云博客

本文详细介绍Java中文件的读写方法，包括使用FileInputStream、BufferedReader等进行文本文件读取，以及FileOutputStream、BufferedWriter等进行写入。同时，讲解了文件的基本属性操作，如创建、删除、获取路径等。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

先讲txt的处理其他内容在后面

读txt文件：1.打开文件2.读取文件。3.关闭文件

！！！txt文件的后缀！！！.txt！！！

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.InputStreamReader;
import java.util.HashMap;

public class a1 {
	public static void main(String[] args) {
		readFile1();
		System.out.println("===================");
		//readFile2(); //JDK 7及以上才可以使用
	}

	public static void readFile1() {
		FileInputStream fis = null;
		InputStreamReader isr = null;
		BufferedReader br = null;
		try {
			fis = new FileInputStream("c:/temp/1.txt"); // 节点类
			isr = new InputStreamReader(fis, "UTF-8"); // 转化类
			//isr = new InputStreamReader(fis);
			br = new BufferedReader(isr); // 装饰类
			// br = new BufferedReader(new InputStreamReader(new
			// FileInputStream("c:/temp/abc.txt")))
			String line;
			while ((line = br.readLine()) != null) // 每次读取一行
			{
				System.out.println(line);
			}
		} catch (Exception ex) {
			ex.printStackTrace();
		} finally {
			try {
				br.close(); // 关闭最后一个类，会将所有的底层流都关闭
			} catch (Exception ex) {
				ex.printStackTrace();
			}
		}
	}

	public static void readFile2() {
		String line;
		//try-resource 语句，自动关闭资源
		try (BufferedReader in = new BufferedReader(new InputStreamReader(new FileInputStream("c:/temp/1.txt")))) {
			while ((line = in.readLine()) != null) {
				System.out.println(line);
			}
		}
		catch(Exception ex)
		{
			ex.printStackTrace();
		}
	}
}

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.InputStreamReader;
import java.util.HashMap;

public class TxtFileRead {
	public static void main(String[] args) {
		readFile1();
		System.out.println("===================");
		//readFile2(); //JDK 7及以上才可以使用
	}

	public static void readFile1() {
		FileInputStream fis = null;
		InputStreamReader isr = null;
		BufferedReader br = null;
		try {
			fis = new FileInputStream("c:/temp/abc.txt"); // 节点类
			isr = new InputStreamReader(fis, "UTF-8"); // 转化类
			//isr = new InputStreamReader(fis);
			br = new BufferedReader(isr); // 装饰类
			// br = new BufferedReader(new InputStreamReader(new
			// FileInputStream("c:/temp/abc.txt")))
			String line;
			while ((line = br.readLine()) != null) // 每次读取一行
			{
				System.out.println(line);
			}
		} catch (Exception ex) {
			ex.printStackTrace();
		} finally {
			try {
				br.close(); // 关闭最后一个类，会将所有的底层流都关闭
			} catch (Exception ex) {
				ex.printStackTrace();
			}
		}
	}

	public static void readFile2() {
		String line;
		//try-resource 语句，自动关闭资源
		try (BufferedReader in = new BufferedReader(new InputStreamReader(new FileInputStream("c:/temp/abc.txt")))) {
			while ((line = in.readLine()) != null) {
				System.out.println(line);
			}
		}
		catch(Exception ex)
		{
			ex.printStackTrace();
		}
	}
}

写文件的步骤：1.创建文件2.写入文件3.关闭文件（文件未关闭其他进程便无法再对文件进行操作）

import java.io.*;

public class TxtFileWrite {
	public static void main(String[] args) {
		writeFile1();
		System.out.println("===================");
		//writeFile2(); // JDK 7及以上才可以使用
	}

	public static void writeFile1() {
		FileOutputStream fos = null;
		OutputStreamWriter osw = null;
		BufferedWriter bw = null;
		try {
			fos = new FileOutputStream("c:/temp/abc.txt"); // 节点类
			osw = new OutputStreamWriter(fos, "UTF-8"); // 转化类
			//osw = new OutputStreamWriter(fos); // 转化类
			bw = new BufferedWriter(osw); // 装饰类
			// br = new BufferedWriter(new OutputStreamWriter(new
			// FileOutputStream("c:/temp/abc.txt")))
			bw.write("我们是");
			bw.newLine();
			bw.write("Ecnuers.^^");
			bw.newLine();
		} catch (Exception ex) {
			ex.printStackTrace();
		} finally {
			try {
				bw.close(); // 关闭最后一个类，会将所有的底层流都关闭
			} catch (Exception ex) {
				ex.printStackTrace();
			}
		}
	}

	public static void writeFile2() {
		//try-resource 语句，自动关闭资源
		try (BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("c:/temp/abc.txt")))) {
			bw.write("我们是");
			bw.newLine();
			bw.write("Ecnuers.^^");
			bw.newLine();
		} catch (Exception ex) {
			ex.printStackTrace();
		}
	}

}

关闭的时候关闭最外层的bw上面的包含于bw的就都结束了

1.基本知识点

1.文件概述

文件系统和java进程在计算机中是平行的两套系统，文件由OS管理
window中用 \ 表达文件的层次关系，但是在语言中 \ 会被认为是转译。eg \n . 所以在程序中用 \ 或 / 代替

文本文件：若干个字符构成的文件eg.txt
特殊格式的二进制文件：eg.ppt

文件包括文件的名称和文件基本属性

2.1java中的文件

java.io.File是文件和目录中会用到的类

File类和OS无关，但是会受到OS限制

常用方法：–createNewFile,delete,exists, getAbsolutePath, getName, getParent,getPath, isDirectory, isFile, length, listFiles, mkdir, mkdirs

java读写文件只能以数据流的方式进行读写（因为文件可能会非常大，所以只能每次取一些，以流的形式进行操作）

2.2java io包中的内容：

节点类：直接对文件进行读写
包装类：1.转化类：可以把字节和数据类型做转化，把字节和字符做转化。（字节：byte，存储单位。字符：书写上的概念：eg.a 数据类型:eg.int）2.装饰类：负责写字符到缓存区

节点类：eg.

stream结尾的是对字节进行操作的

InputStream：从文件读到java中,
OutputStream：从java写到文件中
FileInputStream,FileOutputStream 上面两个类的子类

字符的后面没有stream

Reader,Writer(字符)
FileReader, FileWriter

转换类：字符到字节之间的转化
InputStreamReader：文件读取时字节，转化为Java能理解的字符
OutputStreamWriter：Java将字符转化为字节输入到文件中
•装饰类：装饰节点类
DataInputStream,DataOutputStream: 封装数据流 BufferedInputStream,BufferOutputStream：缓存字节流
BufferedReader, BufferedWriter：缓存字符流

一般来说对文件的操作会涉及到buffer（缓存，从硬盘缓存到内存）

在这里插入图片描述

3.实例

import java.io.*;
public class FileAttributeTest{
  public static void main(String[] args){
	//创建目录
	File d=new File("c:/temp");
	if(!d.exists())
	{
		d.mkdirs();  //mkdir 创建单级目录  mkdirs 连续创建多级目录
	}
	System.out.println("Is d directory? " + d.isDirectory());
	
	//创建文件  
    File f=new File("C:/temp/abc.txt");    
    if(!f.exists())
    {    	
      try
      {
        f.createNewFile(); //创建abc.txt
      }
      catch(IOException e){ //可能会因为权限不足或磁盘已满报错
    	  e.printStackTrace();
      }
    }  
    
    //输出文件相关属性
    System.out.println("Is f file? " + f.isFile());
    System.out.println("Name: "+f.getName());
    System.out.println("Parent: "+f.getParent());
    System.out.println("Path: "+f.getPath());
    System.out.println("Size: "+f.length()+" bytes");
    System.out.println("Last modified time: "+f.lastModified()+"ms");
    
    //遍历d目录下所有的文件信息
    System.out.println("list files in d directory");
    File[] fs = d.listFiles();  //列出d目录下所有的子文件，不包括子目录下的文件
    for(File f1:fs)
    {
    	System.out.println(f1.getPath());
    }
    
    //f.delete(); //删除此文件
    //d.delete(); //删除目录
  }
}

代码解析：

1.在java中的file对象相当于对文件和目录的映射

File d=new File("c:/temp");

2.判断文件是否为空
用file.exists()检查目录是否为空

if(!d.exists())
	{
		d.mkdirs();  //mkdir 创建单级目录  mkdirs 连续创建多级目录
	}

3.创建目录

创建单级目录用mkdir，即只能创建一级

if(!d.exists())
	{
		d.mkdirs();  //mkdir 创建单级目录  mkdirs 连续创建多级目录
	}

创建多级目录用skdirs

File d=new File("c:/temp/a/b/c");//多级目录
	if(!d.exists())
	{
		d.mkdirs();  //mkdir 创建单级目录  mkdirs 连续创建多级目录
	}

4.判断file是否是目录用file.isDirectory()

System.out.println("Is d directory? " + d.isDirectory());

import java.io.File;
import java.nio.file.FileSystems;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;

public class PathTest {
	public static void main(String[] args) {
		// Path 和 java.io.File 基本类似
		// 获得path方法一,c:/temp/abc.txt
		Path path = FileSystems.getDefault().getPath("c:/temp", "abc.txt");
		//将文件名和目录名隔开
		System.out.println(path.getNameCount());

		// 获得path方法二，用File的toPath()方法获得Path对象
		File file = new File("c:/temp/abc.txt");
		Path pathOther = file.toPath();
		// 0,说明这两个path是相等的
		System.out.println(path.compareTo(pathOther));

		// 获得path方法三
		Path path3 = Paths.get("c:/temp", "abc.txt");
		System.out.println(path3.toString());

		// 合并两个path
		Path path4 = Paths.get("c:/temp");
		System.out.println("path4: " + path4.resolve("abc.txt"));

		if (Files.isReadable(path)) {
			System.out.println("it is readable");
		} else {
			System.out.println("it is not readable");
		}
	}
}

import java.io.IOException;
import java.nio.file.DirectoryStream;
import java.nio.file.Files;
import java.nio.file.LinkOption;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardCopyOption;
import java.nio.file.attribute.BasicFileAttributes;
import java.util.Date;

public class FilesTest {
	
	public static void main(String[] a)
	{
		moveFile();
		fileAttributes();
		createDirectory();
	}

	public static void moveFile() {
		Path from = Paths.get("c:/temp", "abc.txt");
		//移动c:/temp/abc.txt到c:/temp/test/def.txt，如目标文件已存在，就替换
		Path to = from.getParent().resolve("test/def.txt");
		try {
			//文件的大小bytes
			System.out.println(Files.size(from));
			//调用文件移动方法  如果目标文件已经存在，就替换
			Files.move(from, to, StandardCopyOption.REPLACE_EXISTING);
		} catch (IOException e) {
			System.err.println("移动文件错误" + e.getMessage());
		}
	}
	
	
	public static void fileAttributes(){
		Path path = Paths.get("c:/temp");
		//1
		System.out.println(Files.isDirectory(path, LinkOption.NOFOLLOW_LINKS));
		//2
		try {
			//获得文件的基础属性
			BasicFileAttributes attributes = Files.readAttributes(path, BasicFileAttributes.class);
			System.out.println(attributes.isDirectory());
			System.out.println(new Date(attributes.lastModifiedTime().toMillis()).toLocaleString());
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
	
	public static void createDirectory(){
		Path path = Paths.get("c:/temp/test");
		try {
			//创建文件夹
			if(Files.notExists(path)){
				Files.createDirectories(path);
				System.out.println("create dir");
			}else{
				System.out.println("dir exists");
			}
			Path path2 = path.resolve("A.java"); 
			Path path3 = path.resolve("B.java");
			Path path4 = path.resolve("C.txt");
			Path path5 = path.resolve("D.jpg");
			Files.createFile(path2);
			Files.createFile(path3);
			Files.createFile(path4);
			Files.createFile(path5);
			
			//不加条件遍历
			DirectoryStream<Path> paths = Files.newDirectoryStream(path);
			for(Path p : paths){
				System.out.println(p.getFileName());
			}
			System.out.println();
			
			//创建一个带有过滤器,过滤文件名以java txt结尾的文件
			DirectoryStream<Path> pathsFilter = Files.newDirectoryStream(path, "*.{java,txt}");
			for(Path p : pathsFilter){
				System.out.println(p.getFileName());
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

import java.io.IOException;
import java.nio.file.FileSystems;
import java.nio.file.FileVisitOption;
import java.nio.file.FileVisitResult;
import java.nio.file.FileVisitor;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.PathMatcher;
import java.nio.file.Paths;
import java.nio.file.attribute.BasicFileAttributes;
import java.util.EnumSet;

class Search implements FileVisitor {

	private final PathMatcher matcher;

	public Search(String ext) {
		matcher = FileSystems.getDefault().getPathMatcher("glob:" + ext);
	}

	public void judgeFile(Path file) throws IOException {
		Path name = file.getFileName();
		if (name != null && matcher.matches(name)) {
			//文件名字已经匹配
			System.out.println("Searched file was found: " + name + " in " + file.toRealPath().toString());
		}
	}

	@Override
	public FileVisitResult postVisitDirectory(Object dir, IOException exc) throws IOException {
		System.out.println("Visited: " + (Path) dir);
		return FileVisitResult.CONTINUE;
	}

	@Override
	public FileVisitResult preVisitDirectory(Object dir, BasicFileAttributes attrs) throws IOException {
		return FileVisitResult.CONTINUE;
	}

	@Override
	public FileVisitResult visitFile(Object file, BasicFileAttributes attrs) throws IOException {
		judgeFile((Path) file);
		return FileVisitResult.CONTINUE;
	}

	@Override
	public FileVisitResult visitFileFailed(Object file, IOException exc) throws IOException {
		// report an error if necessary
		return FileVisitResult.CONTINUE;
	}
}
//查找某一个目录下所有的jpg文件，包括子文件夹
public class SearchJPGFiles {

	public static void main(String[] args) throws IOException {
		//定义扩展名，和待查找目录
		String ext = "*.jpg";
		Path fileTree = Paths.get("C:/temp/");
		Search walk = new Search(ext);
		EnumSet<FileVisitOption> opts = EnumSet.of(FileVisitOption.FOLLOW_LINKS);

		Files.walkFileTree(fileTree, opts, Integer.MAX_VALUE, walk);

	}
}