java操作文件
java是跨平台语言，在linux上读文件跟在windows上读文件是一样的 只是文件路径不一样，可以用File对象和FileInputSteam来读取。但要注意文件编码问题。x0dx0a如果有中文请做适当的编码转换,通常情况下Linux的默认字符编码为UTF-8编码方式，项目可以直接采用utf8编码方式操作.用System.getProperty("file.encoding")可检查系统编码格式。可改操作系统的文件系统编码，vi /etc/profile，在文件末尾加上x0dx0aexport LANG="zh_CN.GBK"x0dx0aexport LC_ALL="zh_CN.GBK"x0dx0a编码转换代码：new String(files[i].getName().getBytes("GBK"),"UTF-8");x0dx0ax0dx0a文件操作的核心代码请参考下面代码:x0dx0ax0dx0aString path= "/home/";x0dx0apath= "/home/multiverse/Repository/PMEPGImport";x0dx0aFile file=new File(path);x0dx0aFile[] tempList = file.listFiles();x0dx0afor (int i = 0; i < tempList.length; i++) {x0dx0a if (tempList[i].isFile()) {x0dx0a//FileInputStream fis = new FileInputStream("fileName");x0dx0ax0dx0a//InputStreamReader isr = new InputStreamReader(fis,"utf-8");x0dx0aStringBuffer buffer = new StringBuffer();x0dx0aString text;x0dx0ax0dx0aBufferedReader input = new BufferedReader (new FileReader(tempList[i]));x0dx0ax0dx0awhile((text = input.readLine()) != null)x0dx0a buffer.append(text +"/n"); }x0dx0ax0dx0aif (tempList[i].isDirectory()) {x0dx0a System.out.println("文件夹："+tempList[i]);x0dx0a }x0dx0a }
2. java中,文件输入操作由下面哪个
Java 操作文件包括了两个层面：
在文件系统的层面上来操作文件，包括创建文件、删除文件、创建目录、拷贝文件等等。
操作文件里保存的数据，包括读文件、写文件。
1. 在文件系统层面操作文件
1.1 File 类介绍
Java 中通过 java.io.File 类来对一个文件（包括目录）进行抽象的描述。不过有 File 对象，并不代表对应的文件真实存在。
1.2 File 常见属性
属性 修饰符及类型 说明
pathSeparator static String 依赖于系统的路径分隔符，String 类型的表示
pathSeparator static char 依赖于系统的路径分隔符，char 类型的表示
1.3 File 构造方法
构造方法 说明
File(File parent, String child) 根据父目录+孩子文件路径，创建一个新的 File 实例
File(String pathname) 根据文件路径创建一个新的 File 实例，路径可以是绝对路径或者相对路径
File(String parent, String child) 根据父目录路径+孩子文件路径，创建一个新的 File 实例
1.4 File 常用方法
方法 返回值类型 说明 注意
getParent() String 返回 File 对象的父目录文件路径
getName() String 返回 File 对象的纯文件名称
getPath() String 返回 File 对象的文件路径
getAbsolutePath() String 返回 File 对象的绝对路径
getCanonicalPath() String 返回 File 对象的修饰过的绝对路径 如果绝对路径的值为：d:/././test.txt，那么修饰过的绝对路径就为：d:/test.txt。
exists() boolean 判断 File 对象描述的文件是否真实存在
isDirectory() boolean 判断 File 对象代表的文件是否是一个目录
isFile() boolean 判断 File 对象代表的文件是否是一个普通文件
createNewFile() boolean 根据 File 对象，自动创建一个空文件。成功创建后返回 true 如果文件路径不正确或者没有权限，则可能创建失败。
delete() boolean 根据 File 对象，删除该文件。成功删除后返回 true 如果文件路径不正确或者没有权限，则可能删除失败。
deleteOnExit() void 根据 File 对象，标注文件将被删除，删除动作会到 JVM 运行结束时才会进行
list() String[] 返回 File 对象代表的目录下的所有文件名
listFiles() File[] 返回 File 对象代表的目录下的所有文件，以 File 对象表示
mkdir() boolean 创建 File 对象代表的目录
mkdirs() boolean 创建 File 对象代表的目录，如果必要，会创建中间目录
renameTo(File dext) boolean 重命名文件或移动文件，当目录为空时也可以重命名目录
canRead() boolean 判断用户是否对文件有可读权限
canWrite() boolean 判断用户是否对文件有可写权限
2. 操作文件里的数据
文件内容的操作包括读文件和写文件，而对于这两种操作 Java 又提供了两种不同的类：
读类 写类 说明
InputStream OutputStream 字节流，针对二进制文件进行读写，操作基本单位是字节
Reader Writer 字符流，针对文本文件进行读写，操作基本单位是字符
字节流： 它处理单元为1个字节，操作字节和字节数组，存储的是二进制文件，如果是音频文件、图片、歌曲，就用字节流。
字符流： 它处理的单元为2个字节的 Unicode 字符，分别操作字符、字符数组或字符串，字符流是由 Java 虚拟机将字节转化为2个字节的 Unicode 字符为单位的字符而成的，如果是关系到中文（文本）的，用字符流更好。
所有文件都是以字节的形式储存，在磁盘上保留的并不是文件的字符而是先把字符编码成字节，再储存这些字节到磁盘。在读取文件（特别是文本文件）时，也是一个字节一个字节地读取以形成字节序列。
字节流可用于任何类型的对象，包括二进制对象，而字符流只能处理字符或者字符串。
字节流提供了处理任何类型的 IO 操作的功能，但它不能直接处理 Unicode 字符，而字符流就可以。
字节流在操作的时候本身不会用到缓冲区的，是与文件本身直接操作的；而字符流在操作的时候会使用到缓冲区的。
其中 InputStream/OutputStream 和 Reader/Writer 都实现了 Closeable 接口，所以可以不主动通过 close 方法去关闭该资源，而是通过代码可读性更高的 try-with-resource 操作在 try 中的内容结束后，无论是否有异常都关闭该资源。
使用 OutputStream 或 writer 打开文件默认会清空之前的文件内容
2.1 操作字节流数据
2.1.1 InputStream
InputStream 是一个抽象类，使用时需要使用具体的实现类。InputStream 的实现类很多，针对不同的输入设备都可以对应一个实现类，其中针对文件读取的实现类是 FileInputStream。
FileInputStream 构造方法：
构造方法 说明
FileInputStream(File file) 利用 File 构造对应文件输入流
FileInputStream(String name) 利用文件路径构造对应文件输入流
InputStream 核心方法：
方法 返回值类型 说明
read() int 一次读取一个字节的数据，如果返回 -1 表示文件读完了
read(byte[] b) int 一次最多读取 b.length 字节的数据到 b 中，返回值为实际读到的字节数量，如果返回 -1 表示文件读完了
read(byte[] b, int off, int len) int 一次最多读取 len 个字节到 b 中，并从 off 的位置开始存放，返回值为实际读到的字节数量，如果返回 -1 表示文件读完了
close() void 关闭字节流
为什么 read 方法的返回值是 Int 类型？
对于 read 方法的返回值，当读取的是数字和英文时，返回值是对应的 ascii 码；当读取的是汉字时，返回的是汉字的机内码，比如使用的是 GBK 编码方式，返回的就是 GBK 的内部编码。read 方法每次从 inputstream 中读取一个字节，而一个字节是8位，但当最高位是1的时候，二进制对应的 ascii 码值就是复数，而 ascii 是没有负数的，所以用 byte 类型表示不了。并且 11111111 对应的十进制值是 -1，而返回 -1 表示文件读取完毕了，则后面的数据就不会读了，因此 byte 类型不适合，int 类型则可以解决这个问题。
示例代码： 使用 read() 方法读取文件内容
public class Demo1 {
public static void main(String[] args) throws IOException {
File file = new File("./test.txt");
StringBuilder sb = new StringBuilder();
try (InputStream inputStream = new FileInputStream(file)){
while(true) {
int b = inputStream.read();
if(b == -1){
break;
}
sb.append((char) b);
}
} catch (IOException e) {
e.printStackTrace();
}
System.out.println(sb.toString());
}
}
登录后复制
示例代码： 使用 read(byte[] b) 方法读取文件内容
public class Demo1 {
public static void main(String[] args) throws IOException {
File file = new File("./test.txt");
byte[] buffer = new byte[1024];
try (InputStream inputStream = new FileInputStream(file)){
while(true) {
int len = inputStream.read(buffer);
if(len == -1){
break;
}
String s = new String(buffer, 0, len, "utf-8");
System.out.println(s);
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
登录后复制
2.1.2 OutputStream
OutputStream 是一个抽象类，使用时需要使用具体的实现类。OutputStream 的实现类很多，针对不同的输出设备都可以对应一个实现类，其中针对文件读取的实现类是 FileOutputStream。
FileOutputStream 构造方法：
构造方法 说明
FileOutputStream(File file) 利用 File 构造对应文件输出流
FileOutputStream(String name) 利用文件路径构造对应文件输出流
FileOutputStream(File file, boolean append) append 表示是否追加数据到文件的末尾，为 true 表示追加，为 false 表示情空之前的内容重新加入
FileOutputStream(String name, boolean append) append 表示是否追加数据到文件的末尾，为 true 表示追加，为 false 表示情空之前的内容重新加入
OutputStream 核心方法：
方法 返回值类型 说明
write() int 一次写入一个字节的数据
write(byte[] b) int 一次最多写入 b.length 字节的数据到 b 中，返回值为实际写入的字节数量
write(byte[] b, int off, int len) int 一次最多写入 len 个字节到 b 中，并从 off 的位置开始存放，返回值为实际写入到的字节数量
close() void 关闭字节流
示例代码：
public class Demo1{
public static void main(String[] args) throws IOException {
File in = new File("./in.txt");
File out = new File("./out.txt");
byte[] buffer = new byte[1024];
try (InputStream inputStream = new FileInputStream(in);
OutputStream outputStream = new FileOutputStream(out)) {
while (true) {
int len = inputStream.read(buffer);
if (len == -1) {
break;
}
outputStream.write(buffer, 0, len);
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
登录后复制
2.1.3 BufferedInputStream
BufferedInputStream 也是 InputStream 的具体实现类，相比于 FileInputStream 优化了系统调用，即通俗解释为：将数据保存了缓存区，但是减少磁盘 IO 并不是 BufferedInputStream 来做的，而是 OS 来做的。OS 根据局部性原理，会预读部分的数据到内存缓存区，这样下次 IO 如果读取数据在缓存命中了，就不需要等待磁盘的寻址，而是直接返回数据，效率就会快很多。
2.1.4 BufferedOutputStream
BufferedOutPutStream 也是 OutputStream 的具体实现类，相比于 FileOutputStream 优化了系统调优，即每次写数据的时候，都会将数据放入缓存区中，等缓存区满了之后，才会一次性写入到磁盘中，大大提高了效率。
2.2 操作字符流数据
2.2.1 Reader
Reader 是实现字符输入流的一种类型，其本身属于一个抽象类，使用时需要使用具体的实现类。Reader 的实现类很多，针对不同的输入设备都可以对应一个实现类，其中针对文件读取的实现类是 FileReader。Reader 的使用方式和 InputStream 相仿。
示例代码：
public class Demo2 {
public static void main(String[] args) throws FileNotFoundException {
File file = new File("./test.txt");
StringBuilder sb = new StringBuilder();
try (Reader reader = new FileReader(file)) {
while (true) {
int read = reader.read();
if (read == -1) {
break;
}
sb.append((char) read);
}
} catch (IOException e) {
e.printStackTrace();
}
System.out.println(sb.toString());
}
}
登录后复制
2.2.2 Writer
Writer 是实现字符输出流的一种类型，其本身属于一个抽象类，使用时需要使用具体的实现类。Writer 的实现类很多，针对不同的输出设备都可以对应一个实现类，其中针对文件读取的实现类是 FileWriter。Writer 的使用方式和 OutputStream 相仿。
FileWriter 构造方法：
构造方法 说明
FileWriter(File file) 利用 File 构造对应文件输出流
FileWriter(String name) 利用文件路径构造对应文件输出流
FileWriter(File file, boolean append) append 表示是否追加数据到文件的末尾，为 true 表示追加，为 false 表示情空之前的内容重新加入
FileWriter(String name, boolean append) append 表示是否追加数据到文件的末尾，为 true 表示追加，为 false 表示情空之前的内容重新加入
示例代码：
public class Demo2 {
public static void main(String[] args) throws FileNotFoundException {
File in = new File("./in.txt");
File out = new File("./out.txt");
try (Reader reader = new FileReader(in);
Writer writer = new FileWriter(out)) {
while (true) {
int read = reader.read();
if (read == -1) {
break;
}
writer.write(read);
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
登录后复制
2.2.3 BufferedReader
BufferedReader 也是 Reader 的具体实现类，相比于 Reader 优化了系统调用，即通俗解释为：将数据保存了缓存区，但是减少磁盘 IO 并不是 BufferedReader 来做的，而是 OS 来做的。OS 根据局部性原理，会预读部分的数据到内存缓存区，这样下次 IO 如果读取数据在缓存命中了，就不需要等待磁盘的寻址，而是直接返回数据，效率就会快很多。
2.2.4 BufferedWriter
BufferedWriter 也是 Writer 的具体实现类，相比于 Writer 优化了系统调优，即每次写数据的时候，都会将数据放入缓存区中，等缓存区满了之后，才会一次性写入到磁盘中，大大提高了效率。
2.3 Scanner 和 PrintWriter
Java 标准库中提供的 Scanner 和 PrintWriter 类能够像文件中读取文本数据和写入文本数据。
2.3.1 Scanner
java.util.Scanner 类常用来从控制台中读取字符串和基本类型的数值。Scanner 可以将输入的值以空白字符分割标记。
Scanner 的构造方法：
构造方法 说明
Scanner(Readable source) 创建一个 Scanner，从指定的可读资源中扫描标记，包括文件、文件路径、字符串等。
Scanner(InputStream source) 创建一个 Scanner，从指定的字节输入流中扫把标记。
Scanner 常用方法：
方法 返回值类型 说明
hasNext() boolean 如果 Scanner 还要更多的数据可读取，则返回 true
next() String 从 Scanner 中读取下一个标记作为字符串返回
nextLine() String 从 Scanner 中读取一行，以换行符结束
close() void 关闭 Scanner
System.in 为系统自带的标准输入流，该流是一直打开并准备提供输入数据。通常，这个流对应于键盘输入或由主机环境或用户指定的另一个输入源。
使用 Scanner 没有必要关闭输入文件，但是关闭能够释放文件占有的资源。
示例代码：
public class Demo3 {
public static void main(String[] args) {
try (Scanner scanner = new Scanner(new File("./test.txt"))) {
while (scanner.hasNext()) {
String s = scanner.next();
System.out.println(s);
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
登录后复制
2.3.2 PrintWriter
java.io.PrintWriter 类可用来创建一个文件并向文本文件中写入数据。通常使用 System.out.println 向控制台输入文本。
PrintWriter 构造方法：
构造方法 说明
PrintWriter(Writer out) 为指定的字符输入流创建一个 PrintWriter。
PrintWriter(Writer out, boolean autoFlush) 为指定的字符输入流创建一个 PrintWriter，如果 autoFlush 为 true，则 println、printf 或 format 方法将刷新输出缓冲区。
PrintWriter(OutputStream out) 为指定的字节输入流创建一个 PrintWriter。
PrintWriter(OutputStream out, boolean autoFlush) 为指定的字节输入流创建一个 PrintWriter，如果 autoFlush 为 true，则 println、printf 或 format 方法将刷新输出缓冲区。
PrintWriter(String fileName) 为指定的文件路径创建一个 PrintWriter
PrintWriter(String fileName, String csn) 为指定的文件路径创建一个 PrintWriter，并且通过指定的字符集对字符进行编码。
PrintWriter(File file) 为指定的文件对象创建一个 PrintWriter。
PrintWriter(File file, String scn) 为指定的文件对象创建一个 PrintWriter，并且通过指定的字符集对字符进行编码。
PrintWriter 常用方法：
方法 返回值类型 说明
print(String s) void 将字符串写入文件中
println(String s) void 将字符串写入文件中，多打印一个换行
printf(String s) void 将字符串写入文件中，按照指定格式写文件中
System.out 为系统自带的 printStream，表示控制台的标准 Java 对象，通过它能够向控制台输入数据。
使用 PrintWriter 必须使用 close 方法关闭文件，或者使用 try-with-resources 自动关闭资源，狗则数据就不能正确地保存在文件中。
示例代码：
3. JAVA文件操作问题
文件没有找到?
貌似你的路径写的有问题么
说实话 你这段代码我没看完
你能不能把异常栈贴上来给我们看看
就能很明显的找到是哪行报的错...
朋友 我建议你用
System.out.println(fm);
把这个东西打印出来看看是什么值
你对一个List类型的对象用toString()方法
得到的结果的形式应该是
[***,***,...]
4. java的几种IO流读取文件方式
一、超类：
字节流： InputStream（读入流） OutputStream(写出流）
字符流： Reader（字符 读入流） Writer （字符写出流）
二、文件操作流
字节流： FileInputStream ，FileOutputStream
字符流： FileReader, FileWriter(用法与字节流基本相同，不写）
//1.指定要读 的文件目录及名称
File file =new File("文件路径");
//2.创建文件读入流对象
FileInputStream fis =new FileInputStream(file);
//3.定义结束标志,可用字节数组读取
int i =0 ;
while((i = fis.read())!=-1){
//i 就是从文件中读取的字节，读完后返回-1
}
//4.关闭流
fis.close();
//5.处理异常
//1.指定要写到的文件目录及名称
File file =new File("文件路径");
//2.创建文件读入流对象
FileOutputStream fos =new FileOutputStream(file);
//3.定义结束标志
fos.write(要写出的字节或者字节数组);
//4.刷新和关闭流
fos.flush();
fos.close();
//5.处理异常
三、缓冲流：
字节缓冲流： BufferedInputStream,BufferedOutputStream
字符缓冲流：BufferedReader ,BufferedWriter
缓冲流是对流的操作的功能的加强，提高了数据的读写效率。既然缓冲流是对流的功能和读写效率的加强和提高，所以在创建缓冲流的对象时应该要传入要加强的流对象。
//1.指定要读 的文件目录及名称
File file =new File("文件路径");
//2.创建文件读入流对象
FileInputStream fis =new FileInputStream(file);
//3.创建缓冲流对象加强fis功能
BufferedInputStream bis =new BufferedInputStream(fis);
//4.定义结束标志,可用字节数组读取
int i =0 ;
while((i = bis.read())!=-1){
//i 就是从文件中读取的字节，读完后返回-1
}
//5.关闭流
bis.close();
//6.处理异常
//1.指定要写到的文件目录及名称
File file =new File("文件路径");
//2.创建文件读入流对象
FileOutputStream fos =new FileOutputStream(file);
//3.创建缓冲流对象加强fos功能
BufferedOutputStream bos=new BufferedOutputStream(fos);
//4.向流中写入数据
bos.write(要写出的字节或者字节数组);
//5.刷新和关闭流
bos.flush();
bos.close();
//6.处理异常
四、对象流
ObjectInputStream ,ObjectOutputStream
不同于以上两种类型的流这里只能用字节对对象进行操作原因可以看上篇的编码表比照原理
ObjectOutputStream对象的序列化：
将java程序中的对象写到本地磁盘里用ObjectOutputStream
eg：将Person类的对象序列化到磁盘
创建Person类
注1：此类要实现Serializable接口，此接口为标志性接口
注2：此类要有无参的构造函数
注3：一旦序列化此类不能再修改
class Person implements Serializable{
public Person(){}
}
2.创建对象流对象
注：要增强功能可以将传入文件缓冲流
ObjectOutputStream oos =new ObjectOutputStream(
new FileOutputStream(new File("文件路径")));
3.写入对象 ，一般会将对象用集合存储起来然后直接将集合写入文件
List<Person> list =new ArrayList<>();
list.add(new Person());
...(可以添加多个）
oos.writeObject(list);
4.关闭流，处理异常
oos.flush();
oos.close();
五、转换流：
这类流是用于将字符转换为字节输入输出，用于操作字符文件，属于字符流的子类，所以后缀为reader，writer；前缀inputstream，outputstream；
注 ：要传入字节流作为参赛
InputStreamReader: 字符转换输出流
OutputStreamWriter：字符转换输入流
//1.获取键盘输入的字节流对象
inInputStream in =Stream.in;
/*2.用转换流将字节流对象转换为字符流对象，方便调用字符缓冲流的readeLine()方法*/
InputStreamReader isr =new InputStreamReader(in);
/*5.创建字符转换输出流对象osw，方便把输入的字符流转换为字节输出到本地文件。*/
OutputStreamWriter osw =new OutputStreamWriter(new
FileOutputStream(new File("文件名")));
/*3.现在isr是字符流，可以作为参数传入字符缓冲流中*/
BufferedReader br =new BufferedReader(isr);
/*4.可以调用字符缓冲流br的readLine()方法度一行输入文本*/
String line =null;
while((line =br.readLine()){
osw.write(line);//osw是字符流对象，可以直接操作字符串
}
注：InputStreamReader isr =new InputStreamReader(new "各种类型的字节输入流都行即是：后缀为InputStream就行");
OutputStreamWriter osw =new OutputStreamWriter(new
"后缀为OutputStream就行");
六、区别记忆
1.对象流是可以读写几乎所有类型的只要是对象就行，而字节字符流，只能读写单个字节字符或者字节字符数组，以上没有读写字节字符数组的；注意对象流只有字节流！
2.字符和字节循环读入的结束条件int i=0; (i =fis.read())!=-1
用字符数组复制文件(fr 读入流 ，fw写出流）,字节流也是相同的用法
int i = 0; char[] c = new char[1024];
while((i = fr.reade()) !=-1)）{
fw.write(c,0,i);
}
123456
3.对象流里面套缓冲流的情景：
new ObjectInputStream(new BufferedInputStream(new FileInputStream(new File(“文件路径”))));
4.记忆流及其功能的方法：
前缀表示功能，后缀表示流的类型；
比如说FileInputStream 前缀：File,表示操作的磁盘，后缀：intputstream,表示是字节输入流。
同理 FileReader：表示操作文件的字符流
ObjectInputStream ：操作对象的字节输入流
5.拓展：获取键盘输入的字符的缓冲流的写法：
new BufferedReader(new InputStreamReader(System.in)));
将字节以字符形式输出到控制台的字符缓冲流的写法：
new BufferedWriter（ new OutputStreamWriter（System.out))
5. 【高额奖赏】用java实现文件操作。
1、执行代码如下，因不支持插入代码故放图片
6. java 文件夹操作
你好，按照你的要求代码编写如下，可以直接运行
import java.io.File;
public class test {
public static void main(String[] args) {
File root = new File("d:\\");
for (File file : root.listFiles()) {
if (file.isDirectory()) {
for (File f : file.listFiles()) {
String fileName = f.getName();
if (fileName.endsWith(".png")) {
System.out.println(file.getName());
break;
}
}
}
}
}
}
7. java 根据一个文件内容同时操作多个文件
可以用多线程来操作，java8的异步多线程CompletionStage接口，就可以实现，或者不使用多线程使用单线程版反应器模式Reactor（反应器）定制几个处理器接口，根据第一个文件的内容来分发到不同的处理器来处理你具体的需求，具体代码有空可以写给你
8. Java读写文件的几种方法
java读取配置文件的几种方法如下：
方式一：采用ServletContext读取，读取配置文件的realpath，然后通过文件流读取出来。因为是用ServletContext读取文件路径，所以配置文件可以放入在web-info的classes目录中，也可以在应用层级及web-info的目录中。文件存放位置具体在eclipse工程中的表现是：可以放在src下面，也可放在web-info及webroot下面等。因为是读取出路径后，用文件流进行读取的，所以可以读取任意的配置文件包括xml和properties。缺点：不能在servlet外面应用读取配置信息。
方式二：采用ResourceBundle类读取配置信息，
优点是：可以以完全限定类名的方式加载资源后，直接的读取出来，且可以在非Web应用中读取资源文件。缺点：只能加载类classes下面的资源文件且只能读取.properties文件。
9. Java怎么使用表格输入数据并保存为文件
在 Java 中使用表格输入数据并保存为文件，可以使用 Swing 包中的 JTable 组件和 I/O 类库中的文件操作方法。
首先，你需要创建一个 JTable 对象，并在表格中输入数据。例如：
String[] columnNames = {"Name", "Age", "Gender"};Object[][] data = {{"Alice", 20, "Female"}, {"Bob", 25, "Male"}};JTable table = new JTable(data, columnNames);
然后，你需要使用 I/O 类库中的文件操作方法，将表格中的数据保存到文件中。例如，你可以使用 FileWriter 类来写入文件：
FileWriter writer = new FileWriter("table.txt");for (int i = 0; i < table.getRowCount(); i++) { for (int j = 0; j < table.getColumnCount(); j++) {
writer.write(table.getValueAt(i, j).toString());
writer.write("\t");
}
writer.write("\n");
}
writer.close();
上面的代码会将表格中的数据写入文件 "table.txt" 中，每行数据之间用制表符隔开，每列数据之间用换行符隔开。
注意，在使用文件操作方法时，你需要处理文件读写可能出现的异常。你可以使用 try-catch 语句将文件操作代码包装起来，以便在发生异常时能够正确处理。
这是一个简单的例子，你可以根据自己的需求来调整代码。例如，你可以使用其他的 I/O 类，比如 BufferedWriter 或 PrintWriter 等，来更方便地写入文件。你还可以使用其他的文件格式，比如 CSV、Excel 等，来保存数据。
10. java如何读取txt文件
读取txt文件（一整个获取）