java File文件操作和文件流的详解(福哥出品)
java file方法
java file方法
Javafile方法是JavaIOAPI中的一组方法，它们允许我们对文件系统中的文件和目录进行操作。
可以使用这些方法来创建、读取、写入、删除文件和目录，或者获取它们的属性。
File类是表示文件或目录的抽象表示，提供了与文件系统交互的方法。
File类的一些常用方法包括：
1. 创建文件或目录：可以使用createNewFile()方法创建新文件，使用mkdir()或mkdirs()方法创建新目录。
2. 读取文件或目录信息：可以使用exists()方法判断文件或目录是否存在，使用getName()和getPath()方法获取文件或目录的名称和路径。
3. 写入文件：可以使用FileOutputStream或FileWriter类来写入文件。
4. 读取文件：可以使用FileInputStream或FileReader类来读取文件。
5. 删除文件或目录：可以使用delete()方法来删除文件或目录。
6. 获取文件属性：可以使用lastModified()方法获取文件最后修改时间，使用length()方法获取文件大小。
使用Java file方法可以方便地进行文件系统操作，例如创建或删除文件、读写文件内容等。
在编写Java程序时，我们经常需要使用这些方法来处理文件和目录，以实现文件读写、文件备份等操作。
- 1 -。
javafile的使用
javafile的使用1.引言1.1 概述在Java 编程中，Java 文件（.java 文件）扮演着重要的角色。
Java 文件包含了用Java 语言编写的源代码，通过编译可以生成可执行的Java 程序。
Java 文件的使用对于开发Java 应用程序至关重要。
概述部分将会介绍Java 文件的基本概念和用途。
Java 文件可以看作是一个独立的实体，用来存储Java 程序中的类和接口。
每个Java 文件只能包含一个公共类，而文件名必须与该公共类的名称相同。
这样设计的目的是为了方便编译器和开发者进行代码的管理和维护。
Java 文件中的代码按照一定的规范进行编写，通常包含类的定义、字段（变量）的声明、方法的实现等。
在Java 编程中，编写规范的Java 文件非常重要，良好的代码结构和命名规范可以提高代码的可读性和可维护性，有利于团队合作和项目的发展。
随着Java 编程的不断发展，也出现了一些特殊类型的Java 文件，如接口文件（.java）和抽象类文件（.java），它们在使用上有一些特殊的限制和规范。
总之，通过对Java 文件的合理使用，我们可以更好地组织和管理Java 代码，提高代码的可读性和可维护性，为开发高质量的Java 应用程序奠定基础。
1.2 文章结构文章结构部分的内容：文章结构是指整篇文章的组织和安排，它对于读者来说非常重要，能够让读者清晰地了解文章的整体架构和内容安排。
本文将按照以下结构展开讨论：引言、正文和结论。
引言部分（Introduction）是文章的开头部分，主要目的是引入读者，概述文章的主题和内容，并提供背景信息，使读者能够更好地理解后续的内容。
在本文的引言部分，我们将包括概述、文章结构和目的三个方面的内容。
正文部分（Main Body）是文章的主体部分，包括了文章核心的讨论和论证内容。
在本文的正文部分，我们将介绍javafile的使用的两个要点。
第一个要点将讨论javafile的基本概念、作用和用法，帮助读者了解什么是javafile以及如何使用它。
file类常用的方法以及 文件流的分类
一、File类常用的方法File类是Java中的一个核心类，用来表示文件或目录的抽象路径名。
以下是File类常用的方法：1. 创建File对象可以通过以下构造方法创建File对象：- File(String pathname)：使用给定的路径名字符串或URI创建一个File实例。
- File(String parent, String child)：从父路径名字符串和子路径名字符串创建一个新的File实例。
- File(File parent, String child)：从父抽象路径名和子路径名字符串创建一个新的File实例。
2. 文件操作- boolean createNewFile()：创建一个新的空文件。
- boolean delete()：删除文件或目录。
- boolean exists()：测试文件或目录是否存在。
- boolean isFile()：测试是否为文件。
- boolean isDirectory()：测试是否为目录。
- boolean renameTo(File dest)：重命名文件或目录。
3. 文件属性- String getName()：返回文件或目录的名称。
- String getPath()：将文件的路径名转换成字符串。
- long lastModified()：返回最后一次修改时间的毫秒数。
- long length()：返回文件的长度。
4. 目录操作- String[] list()：返回目录中的文件和目录的名称数组。
- File[] listFiles()：返回目录中的文件和目录的File对象数组。
- boolean mkdir()：创建此抽象路径名指定的目录。
- boolean delete()：删除目录。
二、文件流的分类文件流是Java中用来对文件进行读写操作的流。
根据操作模式不同，可以分为输入流和输出流。
1. 输入流（InputStream）输入流用于从文件中读取数据。
javafiles的常用方法
Java文件的常用方法Java是一种面向对象的编程语言，广泛用于开发各种应用程序。
在Java开发中，处理文件是一个常见的任务。
本文将介绍Java中处理文件的常用方法，包括文件的读取、写入、复制、删除等操作。
1. 文件的读取在Java中，可以使用java.io包中的File类来读取文件。
以下是一些常用的文件读取方法：1.1 读取文本文件import java.io.BufferedReader;import java.io.FileReader;import java.io.IOException;public class FileReadExample {public static void main(String[] args) {try (BufferedReader br = new BufferedReader(new FileReader("file.txt "))) {String line;while ((line = br.readLine()) != null) {System.out.println(line);}} catch (IOException e) {e.printStackTrace();}}}1.2 读取二进制文件import java.io.FileInputStream;import java.io.IOException;public class FileReadExample {public static void main(String[] args) {try (FileInputStream fis = new FileInputStream("file.bin")) {byte[] buffer = new byte[1024];int bytesRead;while ((bytesRead = fis.read(buffer)) != -1) {// 处理读取的数据}} catch (IOException e) {e.printStackTrace();}}}2. 文件的写入Java中写入文件的方法与读取文件类似。
JAVA中FILE类对文件的几个常见操作实例总结
//遍历文件夹 String targetPath="I:\\FGOSI";
//testFile.searchFile(targetPath);
//拷贝一个文件夹 testFile.copyDir(targetPath, "I:\\FGOSI-bak"); }
} class TestFile{
/**新建一个文件 * * @param path */
} } }
}
new File(file2.getParent()).mkdirs(); } file1.renameTo(file2);//修改文件名称及路径 System.out.println(fromPath+"文件已移动及重命名到"+toPath); } /**复制一个文件 * * @param src * @param to */ public void copyFile(String src, String des) { File file1 = new File(src);
Java File类的讲解
Java File类的讲解1. File类的使用(java.io.File)1.1 描述•一个File对象代表硬盘或网络中可能存在的一个文件或者文件目录（俗称文件夹），与平台无关。
（体会万事万物皆对象）•File 能新建、删除、重命名文件和目录，但 File 不能访问文件内容本身。
如果需要访问文件内容本身，则需要使用输入/输出流。
–File对象可以作为参数传递给流的构造器。
•想要在Java程序中表示一个真实存在的文件或目录，那么必须有一个File 对象，但是Java程序中的一个File对象，可能没有一个真实存在的文件或目录。
•File类及本章下的各种流，都定义在java.io包下。
1.2 构造器•public File(String pathname)：以pathname为路径创建File对象，可以是绝对路径或者相对路径，如果pathname是相对路径，则默认的当前路径在系统属性user.dir中存储。
•public File(String parent, String child)：以parent为父路径，child 为子路径创建File对象。
•public File(File parent, String child)：根据一个父File对象和子文件路径创建File对象关于路径：•绝对路径：从盘符开始的路径，这是一个完整的路径。
•相对路径：相对于项目目录的路径，这是一个便捷的路径，开发中经常使用。
–IDEA中，main中的文件的相对路径，是相对于"当前工程"–IDEA中，单元测试方法中的文件的相对路径，是相对于"当前module"举例：package com.atguigu.file;import java.io.File;public class FileObjectTest {public static void main(String[] args){// 文件路径名String pathname ="D:\\aaa.txt";File file1 =new File(pathname);// 文件路径名String pathname2 ="D:\\aaa\\bbb.txt";File file2 =new File(pathname2);// 通过父路径和子路径字符串String parent ="d:\\aaa";String child ="bbb.txt";File file3 =new File(parent, child);// 通过父级File对象和子路径字符串File parentDir =new File("d:\\aaa");String childFile ="bbb.txt";File file4 =new File(parentDir, childFile);}public void test01()throws IOException{File f1 =new File("d:\\atguigu\\javase\\HelloIO.java");//绝对路径System.out.println("文件/目录的名称："+ f1.getName());System.out.println("文件/目录的构造路径名："+ f1.getPath());System.out.println("文件/目录的绝对路径名："+ f1.getAbsolutePath ());System.out.println("文件/目录的父目录名："+ f1.getParent());}public void test02()throws IOException{File f2 =new File("/HelloIO.java");//绝对路径，从根路径开始System.out.println("文件/目录的名称："+ f2.getName());System.out.println("文件/目录的构造路径名："+ f2.getPath());System.out.println("文件/目录的绝对路径名："+ f2.getAbsolutePath ());System.out.println("文件/目录的父目录名："+ f2.getParent());}public void test03()throws IOException{File f3 =new File("HelloIO.java");//相对路径System.out.println("user.dir ="+System.getProperty("user.dir "));System.out.println("文件/目录的名称："+ f3.getName());System.out.println("文件/目录的构造路径名："+ f3.getPath());System.out.println("文件/目录的绝对路径名："+ f3.getAbsolutePath ());System.out.println("文件/目录的父目录名："+ f3.getParent());}public void test04()throws IOException{File f5 =new File("HelloIO.java");//相对路径System.out.println("user.dir ="+System.getProperty("user.dir "));System.out.println("文件/目录的名称："+ f5.getName());System.out.println("文件/目录的构造路径名："+ f5.getPath());System.out.println("文件/目录的绝对路径名："+ f5.getAbsolutePath ());System.out.println("文件/目录的父目录名："+ f5.getParent());}}注意：1.无论该路径下是否存在文件或者目录，都不影响File对象的创建。
file类讲解
file类讲解File类是Java中用于操作文件和目录的类，它提供了一系列方法来创建、删除、重命名、复制、移动文件和目录，以及获取文件和目录的属性等功能。
在Java中，文件和目录都被抽象成了File对象，通过File类可以对它们进行各种操作。
首先，我们可以使用File类来创建文件和目录。
通过File类的构造方法，我们可以传入文件或目录的路径来创建一个File对象。
例如，我们可以使用以下代码创建一个名为"test.txt"的文件：```File file = new File("test.txt");```如果我们需要创建一个目录，可以使用以下代码：```File dir = new File("testDir");dir.mkdir();```在创建文件或目录之后，我们可以使用File类的方法来进行各种操作。
例如，我们可以使用以下代码来判断文件或目录是否存在：```boolean exists = file.exists();```如果文件或目录存在，exists方法将返回true，否则返回false。
我们还可以使用以下代码来判断File对象表示的是否是一个目录：```boolean isDirectory = dir.isDirectory();```如果是目录，isDirectory方法将返回true，否则返回false。
类似地，我们还可以使用isFile方法来判断File对象表示的是否是一个文件。
除了判断文件或目录的存在和类型之外，File类还提供了一系列方法来获取文件和目录的属性。
例如，我们可以使用以下代码来获取文件的大小：```long size = file.length();```size方法将返回文件的大小，单位是字节。
我们还可以使用以下代码来获取文件的最后修改时间：```long lastModified = stModified();```lastModified方法将返回文件的最后修改时间，以毫秒为单位。
JAVA输入输出流和文件操作
JAVA输入输出流和文件操作
1、JAVA输入输出流
Java的输入/输出流机制是Java中最基本的控制机制，它是把Java 程序和外部文件和网络服务之间建立的数据传输通道，是Java程序访问来自外部资源的基本手段。
Java的输入/输出流机制是Java中最基本的控制机制，它是把Java 程序和外部文件和网络服务之间建立的数据传输通道，是Java程序访问来自外部资源的基本手段。
Java的输入/输出流机制是将不同的数据源统一到同一结构，从而使Java程序与各种外部资源（文件、网络服务）之间可以进行输入/输出操作。
普通的Java程序可以使用这些IO流来读取和写入文件，从而实现文件的操作。
Java的输入/输出流系统分为字节流和字符流两种。
字节流是用来处理二进制数据流的，可以用来处理原始数据流；而字符流是用来处理字符流的，可以用来处理文本文件。
2、JAVA文件操作
文件是操作系统中用来存储信息的基本单位，在JAVA编程中，我们使用File来操作文件，File类是java.io包中的类，它是为了访问底层操作系统提供的文件和目录的操作方法。
File类可以用来操作一些文件系统相关的信息，比如：文件名、文件大小、文件是否存在等等，我们可以使用File类来实现文件的创建、删除、复制、移动等操作。
另外，如果要实现文件的读写操作。
java文件操作知识点总结
java文件操作知识点总结Java 文件操作知识点总结：1. 文件路径：文件路径是指文件的绝对路径或相对路径。
在 Java 中，可以使用字符串来表示文件路径。
2. 文件类：Java 提供了一个 File 类，用于表示文件或目录的路径名。
可以使用 File 类的方法来创建、删除、重命名文件或目录，以及获取文件或目录的信息。
3. 文件输入输出流：Java 中的文件输入输出流是指从文件中读取数据或向文件中写入数据的方式。
Java 提供了多种文件输入输出流，如FileInputStream、FileOutputStream、FileReader、FileWriter 等。
4. 缓冲流：缓冲流可以提高文件输入输出流的读写效率。
Java 中的BufferedInputStream、BufferedOutputStream、BufferedReader、BufferedWriter 等都是缓冲流。
5. 随机访问文件：Java 中的 RandomAccessFile 类可以用于随机访问文件。
它允许从文件的任意位置读取或写入数据。
6. 序列化：Java 中的序列化是指将对象的状态信息转换为可以存储或传输的形式的过程。
可以将对象序列化为字节流，以便将其写入文件或通过网络发送。
7. 文件锁：Java 中的 FileLock 类可以用于对文件进行加锁，以实现并发访问控制。
8. 文件属性：Java 中的包提供了访问文件属性的 API，如文件的创建时间、修改时间、访问时间等。
9. 文件过滤器：Java 中的 FileFilter 接口可以用于过滤文件列表。
可以通过实现 FileFilter 接口来定义自己的文件过滤器。
10. 文件监听器：Java 中的 FileListener 接口可以用于监听文件变化事件，如文件的创建、删除、重命名等事件。
以上是 Java 文件操作的一些知识点总结，希望对您有所帮助。
【JAVA：File类的用法（一）】File类的构造方法-File类创建文件与文件夹
【JAVA：File类的⽤法（⼀）】File类的构造⽅法-File类创建⽂件与⽂件夹1.File(String pathname):根据⼀个路径得到File对象2.File(String parent,String child):根据⼀个⽬录和⼀个⼦⽂件/⽬录得到File对象3.File(File parent,String child):根据⼀个⽗File对象和⼀个⼦⽂件/⽬录得到File对象package File;import java.io.File;public class javaseFileDemo01 {// File(String pathname):根据⼀个路径得到File对象// File(String parent,String child):根据⼀个⽬录和⼀个⼦⽂件/⽬录得到File对象// File(File parent,String child):根据⼀个⽗File对象和⼀个⼦⽂件/⽬录得到File对象public static void main(String[] args) {// TODO Auto-generated method stub// File(String pathname):根据⼀个路径得到File对象File File01=new File("F:\\javaseDemo01\\File01.txt");// File(String parent,String child):根据⼀个⽬录和⼀个⼦⽂件/⽬录得到File对象//JAVA中认为⽂件夹都是⼀种特殊的⽂件,只不过其内容是其他⽂件或⽂件夹，⽂件中是数据File File02=new File("F:\\javaseDemo01","File01.txt");// File(File parent,String child):根据⼀个⽗File对象和⼀个⼦⽂件/⽬录得到File对象File File=new File("F:\\javaseDemo01");File File03=new File(File,"File01.txt");//上⾯三种⽅法都是在Java中同⼀个File01.txt的⽂件但是是三种不同的表现形式}}File类的成员⽅法：创建、删除、重命名、判断、获取创建功能：public boolean createNewFile()://创建⼀个⽂件，如果该⽬录下有相同的⽂件则不会被创建PS：①如果未指明明确的创建位置，该⽂件会默认创建在该项⽬路径下（如下图）②如果路径不存在则会创建失败 createNewFile只能创建⽂件，不能创建⽂件夹//java.io.Exception:系统找不到指定的路径public boolean mkdir();//创建⼀个⽂件夹，如果该⽬录下有相同的⽂件则不会被创建 //make dirctoryPS：①该⽅法不能创建多个⽗⼦类⽂件夹public boolean mkdirs();//创建多层⽂件夹（如果⽗类不存在此⽂件夹也会帮你创建），如果该⽬录下有相同的⽂件则不会被创建（以createNewFile、mkdir、mkdirs创建的⽂件和⽂件夹不能重名）package File;import java.io.File;import java.io.IOException;public class javaseFileDemo02 {// public boolean createNewFile()://创建⼀个⽂件，如果该⽬录下有相同的⽂件则不会被创建// public boolean mkdir();//创建⼀个⽂件夹，如果该⽬录下有相同的⽂件则不会被创建 //make dirctory// public boolean mkdirs();//创建多层⽂件夹（如果⽗类不存在此⽂件夹也会帮你创建），如果该⽬录下有相同的⽂件则不会被创建public static void main(String[] args) throws Exception {// TODO Auto-generated method stub// public boolean createNewFile()://创建⼀个⽂件，如果该⽬录下有相同的⽂件则不会被创建File File01=new File("F:\\javaseDemo01\\File0XX.txt");boolean file =File01.createNewFile();System.out.print(file);//如果未指明明确的创建位置，该⽂件会默认创建在该项⽬路径下File File02=new File("File0X.txt");boolean file01 =File02.createNewFile();System.out.print(file01);//创建默认路径下的⽂件夹File File03=new File("File");boolean file02=File03.mkdir();System.out.print(file02);//创建没有路径的⽂件夹File File04=new File("F:\\javaseDemo01\\Fileset\\001");boolean file03=File04.mkdirs();System.out.print(file03);}}。
java File文件操作和文件流的详解(福哥出品)
一. 创建文件（1）最常用的（获得一个固定路径下的文件对象）File parentFile = new File(“D:\\My Documents\\.....”);//参数是一个路径的字符串。
（2）在父目录创建一个名为child的文件对象，child 为文件对象的名字File chileFile= new File(“D:\\My Documents\\.....”,String child);或File chileFile= new File(parentFile,String child);二,常见文件夹属性和方法（1）createNewFile（）；该方法的作用是创建指定的文件。
该方法只能用于创建文件，不能用于创建文件夹，且文件路径中包含的文件夹必须存在File file=new ("D:\\My Document\\text.txt");file.createNewFile();这样就会在D盘下的My Document 创建text.txt的记事本（注意：首先得保证D盘下有My Documen这个文件夹）（2）mkdir();根据File对象的名字(路径)创建一个目录(文件夹)，如果是相对目录，则新建的目录在当前目录下（3）mkdirs();如果File对象名字有多级目录，则可以调用该方法一次性创建多级目录。
（4）exists();判断File对象指向的文件是否存在，返回一个boolean类型（5）isDirectory（）；判断File对象指向的文件是否为目录，返回一个boolean类型的值，true或者false。
（6）getName();获得文件名称（不带路径）（7）length（）；得到File对象指向文件的长度，以字节计算，返回一个长整形的值(long);注意：在系统中，文件夹(目录)的大小为零，也就是不占用空间，使用length()时返回的是0（8）delete（）;删除File对象所指定的文件（9）isFile（）；判断File对象指向的文件是不是标准文件（就像图片，音乐文件等）三,文件的属性和方法1.File.separator 当前操作系统的名称分隔符，等于字符串“\”.2.File.pathSeparator当前操作系统的路径分隔符，等于字符串“;”.3. File file=new ("D:\\My Document\\text.txt");file.canExecute();测试应用程序是否可以执行该文件;4.File file=new ("D:\\My Document\\text.txt");file.canRead();测试用用程序是否可以读取该文件5.file.canWrite();测试用程序是否可以修改文件6.file.exists();测试此抽象路径名表示的文件或目录是否存在pareTo（file1）；按字母顺序比较两个抽象路径。
Java基础之File类的使用
Java基础之File类的使用Java基础之File类的使用导语：Java是一门面向对象编程语言，不仅吸收了C++语言的各种优点，还摒弃了C++里难以理解的多继承、指针等概念，因此Java 语言具有功能强大和简单易用两个特征。
下面我们来看看Java基础之File类的使用，希望对大家有所帮助。
一、File类java.io.File类只能用于表示文件或目录的信息(名称、大小等)，不能用于文件内容的访问语法：File file = new File();()中可以填入多种参数，最常见的是填入文件或目录的路径，例如：File file = new File("e:\FileTest\test.txt")注意：如果不指定父目录，则该文件或目录直接生成在项目目录下File类常见API介绍：·exists：file.exists()，判断文件或目录是否存在，存在返回true，不存在返回false·mkdir/mkdirs：file.mkdir()/file.mkdirs，创建目录，mkdirs用于创建多级目录·isDirectory：file.isDirectory()，判断文件是否为目录，是目录返回true，不是目录或者目录不存在返回false·isFile：file.isFile()，判断文件是否为文件，是文件返回true，不是文件或者文件不存在返回false·：file.()，删除文件或目录二、RandomAccessFile类Java提供的对文件内容的访问类，既可以读文件，也可以写文件并且，RandomAccessFile支持随机访问文件，可以访问文件的任意位置Java文件模型：再硬盘上的文件是以byte byte byte的形式存储，是数据的.集合打开文件有两种模式："rw"读写方式，"r"只读方式语法：RandomAccessFile raf = new RandomAccessFile(File, String);()中两个参数，File指要访问的文件，String指文件的打开方式"rw"或"r"文件指针：打开文件时会生成一个文件指针，并且再开头位置，pointer = 0 写方法：raf.write()，一次只写一个字节并且从后8位开始写。
Java中File类中常用方法详解
Java中File类中常⽤⽅法详解java.io包下的File类⽤于描述和创建⼀个⽂件或⽂件夹对象，只能对⽂件或⽂件夹做⼀些简单操作，不能修改⽂件的内容，功能⽐较有限。
下⾯是对于File类中常⽤⽅法的程序演⽰。
[1] 演⽰程序⼀package pack01;import java.io.*;import java.sql.Date;public class FileTest {public static void main(String[] args) {File file1 = new File("d:/TEST/MyFile1.txt"); //该⽂件存在File file2 = new File("d:/TEST/MyFile2.txt"); //该⽂件不存在sop( file1.getName() ); //获取⽂件名sop( file1.getPath() ); //获取⽂件路径sop( file1.getAbsoluteFile() ); //获取⽂件的绝对路径，getAbsoluteFile返回File类对象sop( file1.getAbsolutePath() ); //获取⽂件的绝对路径，getAbsolutePath返回代表路径的字符串sop( file1.getParent() ); //获取所在的⽂件夹的名字sop( file1.renameTo(file2) );//将对象file1代表的⽂件MyFile1.txt重命名，并传送到对象file2指定的路径下//使⽤要求：对象file1代表的⽂件MyFile1.txt必须存在//....对象file2代表的⽂件所处的⽬录必须存在，但是⽂件本⾝MyFile2.txt不能存在sop( file1.exists() ); //判断⽂件是否存在sop( file1.isFile() ); //判断是否是⼀个⽂件sop( file1.isDirectory() ); //判断是否是⼀个⽂件夹sop( file1.canRead() ); //判断是否可读sop( file1.canWrite() ); //判断是否可写sop( new Date( stModified() ) );//最后修改时间(创建⼀个Date类对象输出)sop( file1.length() ); //⽂件的⼤⼩}public static void sop(Object obj) {System.out.println(obj);System.out.println();}}[2] 演⽰程序⼆/*--------------------createNewFile()----创建新的⽂件夹delete()-----------删除已存在的⽂件或⽂件夹mkdir()------------在已有的⽬录下创建新的⽬录mkdirs()-----------创建⼀个完整的路径，即包括所有的上层⽬录list()-------------获取⽬录下的所有内容，返回String类型数组listFiles()--------获取⽬录下的所有内容，返回File类型数组----------------------*/package pack01;import java.io.*;public class FileTest02 {public static void main(String[] args) throws IOException {File file1 = new File("d:/TEST/MyFile1.txt"); //该⽂件已存在File folder1 = new File("d:/TEST/MyFolder1"); //该⽂件夹已存在File folder2 = new File("d:/TEST/MyFolder2"); //该⽂件夹已存在File folderNO = new File("d:/TESTNO/MyFolderNO");//⽂件夹TEST2和MyFolder2均不存在sop( file1.delete() ); //将对象file1代表的⽂件MyFile1.txt删除，返回值为truesop( file1.createNewFile() ); //创建对象file1代表的⽂件MyFile1.txt，返回值为truesop( folder1.delete() ); //删除对象folder代表的⽂件夹MyFolder，返回值为truesop( folder1.mkdir() ); //创建对象folder代表的⽂件夹MyFolder，返回值为truesop( folderNO.mkdir() ); //返回值为falsesop( folderNO.mkdirs() );//返回值为true//当想要创建的⽂件夹的上层⽬录不存在时，要使⽤⽅法mkdirs();//list()⽅法返回String类型数组String s[] = folder2.list();for( int i=0; i<s.length; ++i ) {System.out.print(s[i] + " ");}System.out.println();//listFiles()⽅法返回File类型数组File f[] = folder2.listFiles();for( int i=0; i<f.length; ++i ) {System.out.print( f[i].getName() + " " ); //使⽤getName()⽅法获取File对象名字}}public static void sop(Object obj) {System.out.println(obj);System.out.println();}}注：希望与各位读者相互交流，共同学习进步。
JAVA——输入、输出流（File类）
JAVA——输⼊、输出流（File类）⼀、File类1、File类的对象主要⽤来获取⽂件本⾝的⼀些信息，例如⽂件所在的⽬录、⽂件的长度或⽂件读写权限等，不涉及对⽂件的读写操作。
2、创建⼀个File对象的构造⽅法有3个：File（String filename）；//filename：⽂件名File（String directoryPath，String filename）；//directoryPath：⽂件路径File（File dir，String filename）；//dir：⼀个⽬录3、⽂件的属性经常使⽤File类的下列⽅法获取⽂件本⾝的信息package Test;import java.io.File;import java.io.IOException;/*File类//获取⽂件的名字public String getName() {return null;}//判断⽂件是否可读public boolean canRead(){return true;}//判断⽂件是否可被写⼊public boolean canWrite(){return true;}//判断⽂件是否存在public boolean exists(){return true;}//获取⽂件的长度（单位是字节）public void length(){}//获取⽂件的绝对路径public String getAbsolutePath(){return null;}//获取⽂件⽗母录public String getParent(){return null;}//判断是否是⼀个普通⽂件，⽽不是⽬录public boolean ifFile(){return true;}//判断⽂件是否是⼀个⽬录public boolean isDirectory(){return true;}//判断⽂件是否是隐藏⽂件public boolean isHidden(){return true;}//获取⽂件的最后修改时间public Object lastModified(){return null;}*///以下是例⼦：public class Test_1 {public static void main(String[] args) {String path = "E:\\soft";File f = new File(path,"E:\\soft");System.out.println(f.getName()+"是可读的吗:"+f.canRead());System.out.println(f.getName()+"的长度:"+f.length());System.out.println(f.getName()+"的绝对路径:"+f.getAbsolutePath());File file = new File(path,"b.txt");System.out.println("在当前⽬录下创建新⽂件"+file.getName());if(!file.exists()){try{file.createNewFile();System.out.println("创建成功");} catch (IOException e) {e.printStackTrace();}}}}4、⽬录例⼦：1package Test;23import java.io.File;45public class dir {6public static void main(String[] args) {7 File dirFile = new File(".");8 FileAccept fileAccept = new FileAccept() ;9 fileAccept.setExtendName("java");10 String filename[] = dirFile.list(fileAccept);11for(String name:filename){12 System.out.println(name);13 }14 }15 }1package Test;23import java.io.File;4import java.io.FilenameFilter;56public class FileAccept implements FilenameFilter { 7private String extendName;8public void setExtendName(String s){9 extendName = "."+s;10 }11public boolean accept(File dir, String name){12return name.endsWith(extendName);13 }14 }。
Java中File类的概述和方法
Java中File类的概述和⽅法1.0 File类的概述和构造⽅法学习IO的⽬的是处理电脑磁盘上的各种⽂件（⽂本，⾳频，视频），所有的程序运⾏都是加载到内存中进⾏的。
⽽Java的IO类可以完成内存和磁盘的数据交换功能，即通过IO类把磁盘上的⽂件加载到内存当中进⾏程序的处理。
* A:File类的概述* File更应该叫做⼀个路径* ⽂件路径或者⽂件夹路径* 路径分为绝对路径和相对路径* 绝对路径是⼀个固定的路径,从盘符开始C:\Users\Administrator\Desktop\你好* 相对路径相对于某个位置,在eclipse下是指当前项⽬下,在dos下指的当前路径，光标前的路径。
指的是当前路径* 查看API i in o out输⼊和输出* ⽂件和⽬录路径名的抽象表⽰形式* B:构造⽅法* File(String pathname)：根据⼀个路径得到File对象* File(String parent, String child):根据⼀个⽬录和⼀个⼦⽂件/⽬录得到File对象* File(File parent, String child):根据⼀个⽗File对象和⼀个⼦⽂件/⽬录得到File对象封装成File对象这样更好的取使⽤file类⾥⾯的⽅法。
Exits()是否存在1.1 File类的创建功能* A:创建功能创建好以后点着项⽬F5刷新下。
或者点着项⽬右击选点Refresh--F5* public boolean createNewFile():创建⽂件如果存在这样的⽂件，就不创建了* public boolean mkdir():创建⽂件夹如果存在这样的⽂件夹，就不创建了* public boolean mkdirs():创建⽂件夹,如果⽗⽂件夹不存在，会帮你创建出来1.2 File类的重命名和删除功能* A:重命名和删除功能* public boolean renameTo(File dest):把⽂件重命名为指定的⽂件路径* public boolean delete():删除⽂件或者⽂件夹* B:重命名注意事项* 如果路径名相同，就是改名。
javaFile类的基本使用方法
javaFile类的基本使用方法java File类的基本使用方法Java IO中File的使用是比较频繁的，在文件的上传和删除中都会用到的。
比如我们在写管理系统的时候有可能会用到图片的上传和删除。
那么我们就会用到Java的 File来处理。
本文是店铺搜索整理的.关于java File类的基本使用方法，给大家做个参考，希望对大家有所帮助!想了解更多相关信息请持续关注我们店铺!Java中File的基本使用创建和删除文件：public class FileDemo {public static void main(String[] args) {File f=new File("d:"+File.separator+"io.txt");//File.separator 得到“\”//File.pathSeparator得到是“;”try {f.createNewFile();} catch (IOException e) {// TODO Auto-generated catch blocke.printStackTrace();}//等等一段时间，可以查看文件的生成try {Thread.sleep(3000);} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}if(f.exists()){f.delete();}else{System.out.println("文件不存在");}}}Java File示例使用：在J2EE开发中使用的图片上传功能代码：public void fileUpload(@RequestParam MultipartFile[] myfiles,HttpServletRequest request, HttpServletResponse response) throws IOException {String imgPath = "/uploads" + "/";File directory = new File(request.getSession().getServletContext().getRealPath("/")+ imgPath);String desFileName = null;String fileNewName = null;response.setContentType("text/html; charset=UTF-8");PrintWriter out = response.getWriter();String originalFilename = null;for (MultipartFile myfile : myfiles) {if (myfile.isEmpty()) {out.write("请选择文件后上传");out.flush();} else {originalFilename = myfile.getOriginalFilename();if (null != originalFilename && originalFilename.length() > 0) {fileNewName = UUID.randomUUID() + originalFilename;desFileName = directory.toString() + "/" + fileNewName;}try {FileUtils.copyInputStreamToFile(myfile.getInputStream(), new File(desFileName));} catch (IOException e) {e.printStackTrace();out.write("文件上传失败，请重试！！");out.flush();}}}out.print(fileNewName);out.flush();}并且其中文件夹生成的代码如下：File f1=new File("d:"+File.separator+"test");f1.mkdir();//获取文件夹名称的方法f1.getName();这是Java IO中的基础使用，也是使用比较频繁的部分。
Java之File类详解
Java之File类详解常⽤操作：1 File f = new File("C:\\testdata\\filedir\\a\\b\\c");2 f.mkdir(); //建⽴单级⽬录3 f.mkdirs(); //建⽴多级⽬录1 File f = new File("C:\\testdata\\filedir\\a.txt");2 f.createNewFile(); //创建⽂件3 System.out.println("⽂件是否存在：" + f.exists());4 System.out.println("是否是⽂件：" + f.isFile());5 f.delete(); //删除file6 f.exists(); //⽂件或⽬录是否存在7 f.getName(); //得到file名字8 f.getPath(); //获取⽂件的完整路径9 f.isDirectory(); //file是否是⽂件夹10 f.isFile(); //file是否是⽂件11 f.length(); //file的长度，返回long，单位字节创建File对象的另⼀种⽅式：1/*创建File对象的另⼀种⽅式*/2// 此时f2是⽂件,parent⽂件夹下的child⽂件3 File f2 = new File("parent","child");4// 注意:此时会在c盘下创建⽂件“d.txt”5 File f3 = new File("c:\\", "d.txt");6 f3.createNewFile();list()和listFiles()的区别：1 File f = new File("C:\\testdata\\filedir");2/* 返回String[]数组.⾥⾯包含了f⼀级⽬录下的⽂件和⽂件夹名.3注意: 如果f:\\a\\b.那么b不会包含在数组中 */4 String[] fileStrs = f.list();5for (String s : fileStrs) {6 System.out.println(s);7 }8/* 返回File[] 数组.⾥⾯包含了f⼀级⽬录下的⽂件和⽂件夹.9注意:如果f:\\a\\b.那么b不会包含在数组中 */10 File[] files = f.listFiles();11for (File ff : files) {12 System.out.println(ff);13 }⽂件过滤：1/*⽂件过滤器*/2 File f1 = new File("C:\\testdata\\filedir");3 String[] fileStrs = f1.list(new FilenameFilter() {4/**5 * dir：需要被过滤的⽂件夹6 * name：需要别被过滤的⽂件名，此名是相对路径7 * 如果返回true，则证明是符合条件的⽂件，会将改⽂件名返回到数组中8*/9 @Override10public boolean accept(File dir, String name) {11 File f = new File(dir, name);12if (f.isDirectory()) {13return false;14 }1516if (f.getName().endsWith("txt")) {17return true;18 }19return false;20 }21 });22for (String s : fileStrs) {23 System.out.println(s);24 }。
java中File文件读取的区别和用法
四、用法总结
1）
File file = new File ("file.txt");
FileInputStream in=new FileInputStream(file);
2）
File file = new File ("file.txt");
BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("file.txt"))); String data = null; while((data = br.readLine())!=null) {
FileReader 与 InputStreamReader 涉及编码转换，可能在不同的平台上出现 乱码现象。
（FileInputStream 以二进制方式处理，不会出现乱码现象。）
FileReader 是 InputStreamReader 类的子类。
InputStreamReader 的构造函数参数为 InputStream 和编码方式，当要指定编 码方式时，必须使用 InputStreamReader 类。
FileInputStream in=new FileInputStream(file);
InputStreamReader inReader=new InputStreamReader(in);
BufferedReader bufReader=new BufferedReader(inReader);
System.out.print((char)ch); }
3、BufferedReader 的用法。
java file类案例
java file类案例File类是Java中用于操作文件和目录的类，它提供了一系列的方法来创建、删除、重命名、复制文件或目录，以及获取文件或目录的属性信息等。
下面将以File类为例，介绍一些常用的文件操作方法。
1. 创建文件或目录使用File类可以通过调用其构造方法来创建文件或目录。
例如，通过调用File(String pathname)构造方法可以创建一个表示指定路径名的File对象。
然后，可以通过调用createNewFile()方法来创建一个文件，或调用mkdir()方法来创建一个目录。
2. 删除文件或目录使用File类可以删除指定的文件或目录。
例如，通过调用delete()方法可以删除指定的文件或目录。
需要注意的是，删除目录时必须确保目录为空，否则删除操作将失败。
3. 重命名文件或目录使用File类可以将指定的文件或目录重命名。
例如，通过调用renameTo(File dest)方法可以将文件或目录重命名为指定的目标文件或目录。
4. 复制文件或目录使用File类可以复制指定的文件或目录。
例如，通过调用copyTo(File dest)方法可以将文件或目录复制到指定的目标位置。
5. 判断文件或目录是否存在使用File类可以判断指定的文件或目录是否存在。
例如，通过调用exists()方法可以判断文件或目录是否存在，返回一个布尔值。
6. 获取文件或目录的属性信息使用File类可以获取指定的文件或目录的属性信息。
例如，通过调用length()方法可以获取文件的长度，返回一个long类型的值，表示文件的字节数。
另外，通过调用isFile()方法可以判断指定的路径是否表示一个文件，返回一个布尔值。
7. 列出目录中的文件和子目录使用File类可以列出指定目录中的文件和子目录。
例如，通过调用list()方法可以返回一个字符串数组，包含目录中的文件和子目录的名称。
8. 过滤文件列表使用File类可以根据指定的条件过滤文件列表。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
一. 创建文件（1）最常用的（获得一个固定路径下的文件对象）File parentFile = new File(“D:\\My Documents\\.....”);//参数是一个路径的字符串。
（2）在父目录创建一个名为child的文件对象，child 为文件对象的名字File chileFile= new File(“D:\\My Documents\\.....”,String child);或File chileFile= new File(parentFile,String child);二,常见文件夹属性和方法（1）createNewFile（）；该方法的作用是创建指定的文件。
该方法只能用于创建文件，不能用于创建文件夹，且文件路径中包含的文件夹必须存在File file=new ("D:\\My Document\\text.txt");file.createNewFile();这样就会在D盘下的My Document 创建text.txt的记事本（注意：首先得保证D盘下有My Documen这个文件夹）（2）mkdir();根据File对象的名字(路径)创建一个目录(文件夹)，如果是相对目录，则新建的目录在当前目录下（3）mkdirs();如果File对象名字有多级目录，则可以调用该方法一次性创建多级目录。
（4）exists();判断File对象指向的文件是否存在，返回一个boolean类型（5）isDirectory（）；判断File对象指向的文件是否为目录，返回一个boolean类型的值，true或者false。
（6）getName();获得文件名称（不带路径）（7）length（）；得到File对象指向文件的长度，以字节计算，返回一个长整形的值(long);注意：在系统中，文件夹(目录)的大小为零，也就是不占用空间，使用length()时返回的是0（8）delete（）;删除File对象所指定的文件（9）isFile（）；判断File对象指向的文件是不是标准文件（就像图片，音乐文件等）三,文件的属性和方法1.File.separator 当前操作系统的名称分隔符，等于字符串“\”.2.File.pathSeparator当前操作系统的路径分隔符，等于字符串“;”.3. File file=new ("D:\\My Document\\text.txt");file.canExecute();测试应用程序是否可以执行该文件;4.File file=new ("D:\\My Document\\text.txt");file.canRead();测试用用程序是否可以读取该文件5.file.canWrite();测试用程序是否可以修改文件6.file.exists();测试此抽象路径名表示的文件或目录是否存在pareTo（file1）；按字母顺序比较两个抽象路径。
8.file.getAbsolutePath()返回此抽象路径名的绝对路径名字字符串。
9.file.getCanonicalPath();返回此抽象路径名的规范路径名字符串。
10.file.getName();返回抽象路径名表示的文件和目录名称。
11.file.getParent（）；返回抽象路径父目录的名字。
如果此路径名没有指定父目录名字则返回null。
12.free = file.getUsableSpace();返回此抽象路径名指定的分区上可用于此虚拟机的字节数13 . = file.hashCode() ；计算此抽象路径名的哈希码14 . = file.isAbsolute();测试此抽象路径名是否为绝对路径名15.ong length = file.length()返回由此抽象路径名表示的文件的长度16.String[] array = file2.list();返回一个字符串数组，这些字符串指定此抽象路径名表示的目录中的文件和目录17. File[] array1 = file2.listFiles()返回一个抽象路径名数组，这些路径名表示此抽象路径名表示的目录中的文件18.File[] roots = File.listRoots();列出可用的文件系统根,静态方法比如C:/，D：/19.file.setReadOnly()设置文件只读；20.files.setWritable(true)设置文件可写；三读取文件FileReader fr=new FileReader(参数)BufferedReader br = new BufferedReader(fr); String a=br.readLine();while(a!=null){操作}br.close();fr.close();四.写入文件// 将数据写入文件FileWriter fw = new FileWriter(%%1);fw.write(%%2);fw.close();五杂项1，提取扩展名String %%2=(new File(%%1)).getName().split(".")[1]; 2，提取文件名String %%2=(new File(%%1)).getName().split("//")[1];3. 提取文件路径String %%2=(new File(%%1)).getPath();4. 替换扩展名File replaceExt=new File(%%1);replaceExt.renameTo(replaceExt.getName().split(".")[0]+"."+%%2); 例子1.枚举一个文件夹中的所有文件夹//import java.io.*;//import java.util.*;ArrayList<String> folderList = new ArrayList<String>(); folderList.add(%%1);for (int j = 0; j < folderList.size(); j++) {File file = new File(folderList.get(j));File[] files = file.listFiles();ArrayList<File> fileList = new ArrayList<File>();for (int i = 0; i < files.length; i++) {if (files[i].isDirectory()) {folderList.add(files[i].getPath());} else {fileList.add(files[i]);}}for (File f : fileList) {%%2=f.toString();%%3 }}例子2复制文件int bytesum = 0;int byteread = 0;File oldfile = new File(%%1);try {if (oldfile.exists()) { //文件存在时InputStream inStream = new FileInputStream(oldfile); //读入原文件FileOutputStream fs = new FileOutputStream(new File(%%2,oldfile.getName()));byte[] buffer = new byte[5120];int length;while ( (byteread = inStream.read(buffer)) != -1) {bytesum += byteread; //字节数文件大小System.out.println(bytesum);fs.write(buffer, 0, byteread);}inStream.close();}}catch (Exception e) {System.out.println("复制单个文件操作出错");e.printStackTrace();}六，数据流的详细介绍1, 在java中stream代表一种数据流（源），javaio的底层数据元，－－－（想像成水龙头）2,任何能够产生流和数据源的javaio对象都看成inputStream对象，它既然可以产生流，我们就可用read（）的封装方法来进行（将数据从水龙头进行读取数据）3任何能够接受数据（源）流的对象javaio的叫做outputStream，他能就收流的数据，我们调用write方法来进行数据收集4我们可以在inputStream和outputstram的基础上，从实际出发从新封装不同属性的输入输出数据流，javaio提供了很多丰富的输入输出对象七,字节流和字符流的区别（字节：是一种计量单位，字符：常使用汉字和符号一个字符等于两个字节）1以Stream结尾的都是字节流，都已reader 和writer结尾的都是字符流，两者的区别就是一个在读写的时候按照字符，一个是按照字节2在读写的过程当中要对内容安行进行处理，比如特定行字符或者是一行数据时一般会选择字符流3如果对内容没有要求一般选择字节流八，字符流的介绍基于Stream的字节流DataInputStream-------DataOutputStreamFileInputStream-------FileOutputStream基于Stream的字符流FileWriter--------FileReaderStringWriter--------StringReaderInputStream:是一个出水龙头（把水封装在里头）的一个实物对象，该对象的read方法呢，就想成这个出水龙头这一机制对象的开关钮，你read或openStream（其他对象包容InputStream对象的对象方法）一下呢，就等于打开了出水龙头的按钮，水就出来了，里头封装的水是什么性质的呢，你就用相应的容器来装，如string或byte[].....OutputStream:你就在InputStream基础上反着想就ok了OutputStream流1，fo为流变量fo.write(int b)//往流当中写入一个字符fo.write(byte b[])往流当中写乳一个字符数组fo.write(byte b[],int begin,int len) 写入数组b从下标begin开始，长度为len的字节流2.fo.flush()刷空数据流，并输出所有被缓存的字节，由于某些流支持缓存的功能，该方法吧缓存中所有的字节强制输出到流中3，fo.close()流操作完必须关闭流（比如在读文件的时候流不关闭，之后不能对文件进行删除操作）InputStream 流1,ip为输出流对象Ip.read(); 读取一个字节，返回的是一个字节Ip.read(byte b[])读取一个字节数组，返回一个字节数组串Ip.read(byte b[],int bengin,int len) 读取len个字节从下标为begin开始2，ip.available() 返回字节流中尚未读取的字节数量3,ip.mark(int readlimit)记录当前指针所在的位置readlimit指指针读取的第readlimit个字节后Ip.reset()把读的指针重新指向mark方法记录的位置字节流：处理字节的输入和输出。