本篇文章为你整理了File类和IO流（file类是非流类吗）的详细内容，包含有file类属于什么流 file类是非流类吗 file类是对象流 java.io的file类是什么类 File类和IO流，希望能帮助你了解 File类和IO流。
public static void main(String[] args) {
//创建一个路径操作对象 路径包括父路径和子路径
File f = new File("G:\\FileTest\\java.txt");
System.out.println(f);
//创建一个路径操作对象 父路径,子路径
File f1 = new File("G:\\FileTest","java.txt");
System.out.println(f1);
//创建一个父路径操作对象
File f2 = new File("G:\\FileTest");
//从父路径和子路径创建的路径操作对象
File f3 = new File(f2,"java.txt");
System.out.println(f3);
运行结果：
//File类重写了toString()
G:\FileTest\java.txt
G:\FileTest\java.txt
G:\FileTest\java.txt
File类创建功能
运行代码之前
代码
public class FileDemo1 {
public static void main(String[] args) throws IOException {
/*在G:\FileTest目录下，创建一个Hello.txt文件
如果文件不存在就创建文件，返回true
如果文件存在返回false*/
File f1 = new File("G:\\FileTest\\Hello.txt");
System.out.println(f1.createNewFile());
/*在G:\FileTest目录下，创建一个Cat文件夹
如果文件不存在就创建文件，返回true
如果文件存在返回false*/
File f2 = new File("G:\\FileTest\\Cat");
System.out.println(f2.mkdir());
/*在G:\FileTest目录下，创建一个多级目录Eat\egg文件夹
如果文件不存在就创建文件，返回true
如果文件存在返回false*/
File f3 = new File("G:\\FileTest\\Eat\\egg");
System.out.println(f3.mkdirs());
运行结果
true
注意
如果同一目录下存在同名的文件夹，createNewFile()创建文件时会失败；要将同名的文件夹删掉才会创建文件成功。
File类判断和获取功能
运行代码之前，先在此位置创建一个java.txt文件
public class FileDemo2 {
public static void main(String[] args) {
//创建File对象
File f = new File("idea_test\\java.txt");
//抽象路径名表示的File是否为目录
System.out.println("是否为目录："+f.isDirectory());
//抽象路径名表示的File是否为文件
System.out.println("是否为文件："+f.isFile());
//抽象路径名表示的File是否存在
System.out.println("是否存在："+f.exists());
//返回此抽象路径名的绝对路径（字符串）
System.out.println("绝对路径："+f.getAbsolutePath());
//将此抽象路径名转化为字符串
System.out.println("抽象路径："+f.getPath());
//返回此抽象路径名表示的文件名或者目录名
System.out.println("文件名或者目录名："+f.getName());
System.out.println("-------FileTest目录-------------");
File f1 = new File("G:\\FileTest");
//返回此抽象路径名表示的目录中的文件名和目录的名称字符串数组
String[] list = f1.list();
//遍历字符串数组
for (String s : list) {
System.out.println(s);
System.out.println("---------FileTest目录中的文件-----------");
//返回此抽象路径名表示的目录中的文件名和目录的File对象数组
File[] files = f1.listFiles();
for (File file : files) {
//System.out.println(file);
//如果对象是一个文件，输出文件名
if (file.isFile()){
System.out.println(file.getName());
运行结果：
是否为目录：false
是否为文件：true
是否存在：true
绝对路径：G:\Work_Basic\JavaSE_Code\idea_test\java.txt
抽象路径：idea_test\java.txt
文件名或者目录名：java.txt
-------FileTest目录-------------
Hello.txt
java.txt
---------FileTest目录中的文件-----------
Hello.txt
java.txt
File类删除功能
创建一个hello.txt文件
public class FileDemo3 {
public static void main(String[] args) throws IOException {
//在当前模块目录下创建一个hello.txt文件
File f = new File("idea_test\\hello.txt");
//System.out.println(f.createNewFile());
//删除当前模块目录下的hello.txt文件
System.out.println(f.delete());
运行结果：hello.txt文件已经删除
true
//在当前模块目录下创建一个"雀巢"文件夹
File f1 = new File("idea_test\\雀巢");
System.out.println(f1.mkdir());
运行结果：true
//删除当前模块目录下的"雀巢"文件夹
System.out.println(f1.delete());
运行结果：true
//在当前模块目录下创建一个"雀巢"文件夹,文件夹里有个java.txt文件
File f2 = new File("idea_test\\雀巢");
System.out.println(f2.mkdir());
File f3 = new File(f2, "java.txt");
System.out.println(f3.createNewFile());
运行结果:
true
创建多级目录文件
在创建文件之前，应该先创建上一级的目录，否则会报错
删除文件夹
如果要删除的文件夹下有文件，删除操作会不成功，返回false
要先删除该文件夹下的文件，之后才能删除该文件夹
方法中调用方法本身
思路：把一个复杂的问题，层层转化为一个与原问题相似的规模较小的问题来求解，递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算。
public class Demo {
public static void main(String[] args) {
/*不死神兔：求第20个月兔子的对数
* 每个月兔子的对数：1，1，2，3，5，8……*/
//创建长度为20的数组 索引0-19
int[] arr = new int[20];
//第一个月：1对
arr[0] = 1;
//第二个月：1对
arr[1] = 1;
//从第三个月(索引2)开始：兔子的对数等于前两个月之和
for (int i = 2; i arr.length; i++) {
arr[i] = arr[i - 1] + arr[i - 2];
//输出第20个月（索引19）兔子的对数
System.out.println(arr[19]);
运行结果：
6765
使用递归来解决上述问题
public class Demo {
public static void main(String[] args) {
/*不死神兔：求第20个月兔子的对数
* 每个月兔子的对数：1，1，2，3，5，8……*/
//第20个月，兔子的对数
System.out.println(f(20));
* 递归：求第n个月兔子的对数
* @param n 第n个月
* @return 兔子的对数
* StackOverflowError 当由于应用程序而发生堆栈溢出时引发 递归太深。递归需要停止
public static int f(int n) {
if (n == 1 n == 2) {
return 1;
} else {
//从第3个月开始，每个月兔子的对数都是前两个月之和
return f(n - 1) + f(n - 2);
运行结果：
6765
递归解决问题
递归出口：否则会出现内存溢出StackOverflowError
递归规则：与原问题相似的规模较小的问题
用记事本打开，能看懂的内容，使用字符流，否则使用字节流。
如果不知道该使用哪种类型的流，就使用字节流。
public abstract class InputStream：字节输入流的所有类的超类
public abstract class OutputStream：字节输出流的所有类的超类
子类名称特点：子类名称都是以父类名作为子类命的后缀
调用字节输出流对象的写数据方法
释放资源：关闭此文件的输出流并释放与此流关联的任何系统资源
//创建字节输出流对象 第一种
FileOutputStream fo = new FileOutputStream("idea_test\\java.txt");
//创建字节输出流对象 第二种
File file = new File("idea_test\\java.txt");
FileOutputStream fo = new FileOutputStream(file);
//创建字节输出流对象 第三种
FileOutputStream fo = new FileOutputStream(new File("idea_test\\java.txt"));
案例：使用字节输出流写数据的步骤
public class IoDemo {
public static void main(String[] args) throws IOException {
* 创建字节输出流对象
* 1.调用系统功能创建了文件
* 2.创建了字节输出流对象
* 3.让字节输出流对象指向创建好的文件
FileOutputStream fo = new FileOutputStream("idea_test\\java.txt");
//void write(int b):将指定的字节写入此文件输出流
fo.write(97);
//释放资源：关闭此文件的输出流并释放与此流关联的任何系统资源
fo.close();
运行结果：
字节流写数据的三种方式
//写入abcde 第一种
fo.write(97);
fo.write(98);
fo.write(99);
fo.write(100);
fo.write(101);
//写入abcde 第二种
byte[] b = {97,98,99,100,101};
//或者，返回字符串中的字节数组
//byte[] b = "abcde".getBytes();
fo.write(b);
//写入abcde 第三种
byte[] b = {97,98,99,100,101};
//参数：字节数组 索引起始位置 索引结束位置
fo.write(b,0,b.length);
字节流写数据的两个小问题
public static void main(String[] args) throws IOException {
//如果第二个参数为true，将在文件末尾追加内容
//如果第二个参数不为true(不写或者false)，将不是追加，而是从文件开头开始覆盖内容
FileOutputStream fo = new FileOutputStream("idea_test\\java.txt",true);
//FileOutputStream fo = new FileOutputStream("idea_test\\java.txt",false);
//写入十次”hello“
for (int i = 0; i i++) {
// 写入字节流
// getBytes()返回字符串中的字节数组
fo.write("hello".getBytes());
fo.write("\n".getBytes());
fo.close();
字节流写数据加异常处理
public class IoDemo {
public static void main(String[] args) {
//初始化为null
FileOutputStream fo = null;
try {
//可能出现异常的代码
fo = new FileOutputStream("idea_test\\java.txt");
fo.write("世界杯".getBytes());
} catch (IOException e) {
//异常处理的代码
e.printStackTrace();
} finally {//被finally控制的语句，一定会执行，除非JVM退出
//null调方法会报空指针异常，所以fo不为null才能执行close()释放资源操作
if (fo != null) {
try {
//close()有编译时异常，用try...catch()处理一下
fo.close();
} catch (IOException e) {
e.printStackTrace();
字节流读数据（一次读一个字节）
FileInputStream：从文件系统中的文件获取输入字节
FileInputStream(String name)：通过打开与实际文件的连接来创建一个FileInputStream，该文件由文件系统中的路径名name命名。
public static void main(String[] args) {
//需求：把文件java.txt中的内容读取出来在控制台输出
File file = new File("idea_test\\java.txt");
//初始化fi
FileInputStream fi = null;
try {
//创建字节输出流对象
fi = new FileInputStream(file);
//调用字节输入流对象的读数据方法,一次读取一个字节
int read;
while ((read = fi.read()) != -1) {
//输出
System.out.print((char) read);
//释放资源
} catch (IOException e) {
e.printStackTrace();
} finally {
if (fi != null) {
try {
fi.close();
} catch (IOException e) {
e.printStackTrace();
再补充一个一次性读取文件全部内容的：
public class IoDemo {//throws抛出异常
public static void main(String[] args) throws IOException {
//需求：把文件java.txt中的内容读取出来在控制台输出
File file = new File("idea_test\\java.txt");
//创建文件输入流对象
FileInputStream fi = new FileInputStream(file);
//file.length()返回值是long,但byte只能装整形大小的空间，所以要强转
byte[] buffer = new byte[(int) file.length()];
//调用字节输入流对象的读数据方法,读取文件全部内容
fi.read(buffer);
System.out.print(new String(buffer));
//释放资源
fi.close();
注意：文件字节流读取文件，一次读一个字节，遇到中文会乱码；一次读取文件的所有内容，中文不会乱码。
字节流复制文本文件
思路：
根据数据源创建字节输入流对象
根据目的地创建字节输出流对象
读写数据，复制文本文件
public static void main(String[] args) throws IOException {
//需求：把文件G:\FileTest\Hello.txt中的内容复制到模块目录下的java.txt
//1.根据数据源创建输入流对象
InputStream fo = new FileInputStream("G:\\FileTest\\Hello.txt");
//2.根据目的地创建输出流对象
OutputStream fi = new FileOutputStream("idea_test\\java.txt");
//一次读取一个字节，一次写入一个字节
//3.读文件
int read;
while ((read = fo.read()) != -1) {
//4.写入文件
fi.write(read);
//5.释放资源,先关闭输出流，在关闭输入流
fo.close();
fi.close();
字节流读数据（一次读一个字节数组）
使用字节输入流读数据的步骤
创建字节输入流对象
调用字节输入流对象的读数据方法
public class IoDemo1 {
public static void main(String[] args) throws IOException {
//创建字节输入流对象
InputStream fo = new FileInputStream("idea_test\\java.txt");
//创建一个字节数组,长度一般为1024及其整数倍
byte[] bytes = new byte[1024];
//创建字节输入流对象的读数据方法,
// len 一次读取的字节数组的长度
int len;
while ((len = fo.read(bytes)) != -1) {
System.out.print(new String(bytes, 0, len));
//释放资源
fo.close();
注意：读含有中文的文件时，建议一次读完。
因为一个汉字占2~3个字节，如果正好读了半个汉字，那就乱码了（如图）。
后面的内容用字符流就更方便了，因为一个汉字一个字母都是一个字符。
字节流复制图片
思路
根据数据源创建字节输入流对象
根据目的地创建字节输出流对象
读写数据，复制图片
public class IoDemo2 {
public static void main(String[] args) throws IOException {
//需求：把图片G:\FileTest\dog.jpg复制到模块目录下的dog.jpg
//1.根据数据源创建输入流对象
InputStream fo = new FileInputStream("G:\\FileTest\\dog.jpg");
//2.根据目的地创建输出流对象
OutputStream fi = new FileOutputStream("idea_test\\dog.jpg");
//定义一个字节数组
byte[] bytes = new byte[1024];
//一次读取一个字节数组，一次写入一个字节数组
int len;
//3.循环读写图片
while ((len = fo.read(bytes)) != -1) {
//4.写入文件
fi.write(bytes,0,len);
//5.释放资源,先关闭输出流，在关闭输入流
fo.close();
fi.close();
运行结果：
IO字符流
字节缓冲流
字节缓冲输出流写数据
public class Demo {
public static void main(String[] args) throws IOException {
//字节缓冲输出流写数据
//创建字节缓冲输出流
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("idea_test\\java.txt"));
//写入数据
bos.write("hello\r\n".getBytes());
bos.write("java\r\n".getBytes());
//释放资源
bos.close();
字节缓冲输入流读数据
public class Demo {
public static void main(String[] args) throws IOException {
//字节缓冲输入流读数据
//创建字节缓冲输入流，一次性从文件中读取8192个字节
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("idea_test\\java.txt"));
//一次读取的字节流数组长度
//每次读取的1024个字节，是直接从字节缓冲流那8192个字节里拿的，拿完之后字节缓冲流会再次从文件中一次性读取8192个字节
byte[] bytes = new byte[1024];
//读数据
int len;
while ((len = bis.read(bytes)) != -1) {
System.out.print(new String(bytes,0,len));
//释放资源
bis.close();
字节流复制视频
思路
根据数据源创建字节输入流对象
根据目的地创建字节输出流对象
读写数据，复制视频
public static void main(String[] args) throws IOException {
//把G:\FileTest\video.avi复制到模块目录下idea_test\video.avi
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("G:\\FileTest\\video.avi"));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("idea_test\\video.avi"));
byte[] bytes = new byte[1024];
int len;
while ((len = bis.read(bytes)) != -1) {
bos.write(bytes,0,len);
//System.out.println(new String(bytes,0,len));
bos.close();
bis.close();
速度：
基本字节流一次读写一个字节 基本字节流一次读写一个字节数组 字节缓冲流一次读写一个字节 字节缓冲流一次读写一个字节数组
用字节流每次读写一个字节复制文本时，底层操作会自动进行字节拼接中文
汉字在存储的时候，无论选择哪种编码格式，第一个字节都是负数
按照规则，将字符存储到计算机中，称为编码；反之，将存储到计算机中的二进制内容按照规则解析显示出来，称为解码
是一个系统支持的所有字符集的集合，包括各国家文字，标点符号，图形符号，数字等
计算机要存储和识别各种字符集符号，就要进行字符编码，一套字符集必然至少有一套字符编码规则。常见的字符集有ASCII字符集，GBXXX字符集，Unicode字符集等
字符串中的编码解码问题
public class Demo1 {
public static void main(String[] args) throws IOException {
String s = "接化发";
//默认规则编码
byte[] bys = s.getBytes();
System.out.println(Arrays.toString(bys));
//指定规则编码
byte[] bys1 = s.getBytes("GBK");
System.out.println(Arrays.toString(bys1));
//默认规则解码
String s1 = new String(bys);
System.out.println(s1);
//指定规则解码
String s2 = new String(bys1, "GBK");
System.out.println(s2);
运行结果：
[-26, -114, -91, -27, -116, -106, -27, -113, -111]
[-67, -45, -69, -81, -73, -94]
字符流中的编码解码问题
字符流抽象基类
Reader:字符输入流的抽象类
Writer:字符输出流的抽象类
InputStreamReader：是从字节流到字符流的桥梁
OutputStreamWriter：是从字符流到字节流的桥梁
public class Demo1 {
public static void main(String[] args) throws IOException {
//字符输出流对象 默认编码格式
//OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("idea_test\\java.txt"));
//字符输出流对象 指定编码格式
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("idea_test\\java.txt"),"UTF-8");
osw.write("蔬菜");
osw.close();
//字符输入流对象 指定编码格式
InputStreamReader isr = new InputStreamReader(new FileInputStream("idea_test\\java.txt"),"UTF-8");
//一次读取一个字符
int ch;
while ((ch = isr.read()) != -1) {
System.out.print((char)ch);
isr.close();
字符流写数据的5种方式
flush()和close()的区别
flush()刷新流，刷新之后还可以写数据
close()关闭流，关闭流之前会自动执行刷新流操作，关闭之后就不能再继续写数据了
public static void main(String[] args) throws IOException {
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("idea_test\\java.txt"));
osw.write(97);
* 刷新缓冲
* 字符流写数据如果不刷新流，那么数据就在缓冲区中，没close()之前，打开文件java.txt看不到数据
* 字符流相对于字节流是有缓冲的，真正写数据是字节流
osw.flush();
//close():关闭流之前会自动执行刷新流操作
//flush()刷新流之后还可以继续写数据，但是close()关闭流之后就不能继续写数据了
osw.close();
字符流写数据的5种方式：
public class Demo2 {
public static void main(String[] args) throws IOException {
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("idea_test\\java.txt"));
//1.写入一个字符:a
osw.write(97);
//2.写入一个字符数组:abcde
char[] chs = {a, b, c, d, e};
osw.write(chs);
//3.写入一个字符数组的一部分:abc
osw.write(chs, 0, 3);
//4.写入一个字符串:世界杯
String s = "世界杯";
osw.write(s);
//5.写入一个字符串的一部分:界
osw.write(s,1,1);
osw.flush();
osw.close();
字符流读数据的2种方式
public class Demo2 {
public static void main(String[] args) throws IOException {
//创建字符输入流对象
InputStreamReader isr = new InputStreamReader(new FileInputStream("idea_test\\java.txt"));
//1.一次读一个字符
int ch;
while ((ch = isr.read()) != -1) {
System.out.print((char) ch);
//2.一次读取一个字符数组
char[] chs = new char[1024];
int len;
while ((len = isr.read(chs)) != -1) {
System.out.print(new String(chs,0,len));
isr.close();
字符流复制Java文件
思路：
根据数据源创建字符输入流对象
根据目的地创建字符输出流对象
读写数据，复制文件
public static void main(String[] args) throws IOException {
//需求：将模块下的idea_test\java.txt，复制到idea_test\java1.txt
//创建字符输入流对象
InputStreamReader isr = new InputStreamReader(new FileInputStream("idea_test\\java.txt"));
//创建字符输出流对象
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("idea_test\\java1.txt"));
//读写数据，复制文件
char[] chs = new char[1024];
int len;
while ((len = isr.read(chs)) != -1) {
osw.write(chs,0,len);
osw.close();
isr.close();
字符流复制Java文件(改进版)
思路：
根据数据源创建字符输入流对象
根据目的地创建字符输出流对象
读写数据，复制文件
public static void main(String[] args) throws IOException {
//需求：将模块下的idea_test\java.txt，复制到idea_test\java1.txt
//创建字符输入流对象
FileReader fr = new FileReader("idea_test\\java.txt");
//创建字符输出流对象
FileWriter fw = new FileWriter("idea_test\\java2.txt");
//读写数据，复制文件
char[] chs = new char[1024];
int len;
while ((len = fr.read(chs)) != -1) {
fw.write(chs,0,len);
fw.close();
fr.close();
字符缓冲流
构造方法
BufferedWriter(Writer out)
BufferedReader(Reader in)
public static void main(String[] args) throws IOException {
BufferedWriter bw = new BufferedWriter(new FileWriter("idea_test\\java.txt"));
bw.write("hello\n");
bw.write("world\r");
bw.write("java\r\n");
bw.write(97);
bw.write(98);
bw.write(99);
bw.close();
//缓冲流默认一次从文件里读取8192个字符
BufferedReader br = new BufferedReader(new FileReader("idea_test\\java1.txt"));
//每次读取的1024个字符，是直接从缓冲流那8192个字符里拿的，拿完之后缓冲流会再次从文件中一次性读取8192个字符
char[] chs = new char[1024];
int len;
while ((len = br.read(chs)) != -1){
System.out.println(new String(chs, 0, len));
br.close();
换行
/r Mac
/n Unix/Linux
/r/n Windows
不过我在windows11上测试换行，以上三种都可以。
public static void main(String[] args) throws IOException {
//需求：java字符缓冲流复制文件，从idea_test\java.txt复制到idea_test\java3.txt
BufferedReader br = new BufferedReader(new FileReader("idea_test\\java.txt"));
BufferedWriter bw = new BufferedWriter(new FileWriter("idea_test\\java3.txt"));
char[] chs = new char[1024];
int len;
while ((len = br.read(chs)) != -1){
bw.write(chs,0,len);
bw.close();
br.close();
字符缓冲流特有功能
newLine()：就是根据系统，自动识别的换行符
readLine()：一次读一行数据，如果读到了结尾则返回null；只读每行的内容，不读行尾终止符
public class Demo2 {
public static void main(String[] args) throws IOException {
//写数据
BufferedWriter bw = new BufferedWriter(new FileWriter("idea_test\\java.txt"));
for (int i = 0; i i++) {
bw.write("hello-"+i);
//换行
bw.newLine();
bw.flush();
bw.close();
//读数据
BufferedReader br = new BufferedReader(new FileReader("idea_test\\java.txt"));
String s;
while ((s = br.readLine()) != null){
System.out.println(s);
br.close();
字符缓冲流特有功能复制Java文件
思路：
根据数据源创建字符缓冲输入流对象
根据目的地创建字符缓冲输出流对象
读写数据，复制文件（使用字符缓冲流特有功能）
public static void main(String[] args) throws IOException {
//需求：java字符缓冲流(特有功能)复制文件，从idea_test\java.txt复制到idea_test\java3.txt
BufferedReader br = new BufferedReader(new FileReader("idea_test\\java.txt"));
BufferedWriter bw = new BufferedWriter(new FileWriter("idea_test\\java4.txt"));
char[] chs = new char[1024];
String s;
while ((s = br.readLine())!=null){
//每写一行数据，换行，刷新
bw.write(s);
bw.newLine();
bw.flush();
bw.close();
br.close();
IO流小结
1.字节流
字节流小结
字节流可以复制【任意文件】数据，有四种方式，一般采用字节缓冲流一次读写一个字节数组的方式
public static void main(String[] args) throws IOException {
//需求：将ArrayList集合中的字符串数据写入到文本文件。要求每一个字符串元素作为文件中的一行数据
//1.创建ArrayList集合
ArrayList String list = new ArrayList ();
//2.向集合中创建字符串元素
list.add("hello");
list.add("world");
list.add("java");
list.add("世界杯");
//3.创建字符缓冲流输入对象
BufferedWriter bw = new BufferedWriter(new FileWriter("idea_test\\java.txt"));
//4.遍历集合，得到每一个字符串数据
for (String s : list) {
//5.调用字符缓冲流对象的方法写数据
bw.write(s);
bw.newLine();
bw.flush();
//6.释放资源
bw.close();
运行结果：
2.文件到集合
public class Demo1 {
public static void main(String[] args) throws IOException {
//需求：把文本文件中的数据读取到集合中，并遍历集合。要求：文本中每一行数据是一个集合元素
//1.创建字符缓冲输入流对象
BufferedReader br = new BufferedReader(new FileReader("idea_test\\java.txt"));
//2.创建ArrayList集合
ArrayList String list = new ArrayList ();
//3.调用字符缓冲输入流对象的方法读数据
String s;
while ((s = br.readLine()) != null) {
//4.把读到的字符串数据存储到集合
list.add(s);
//5.释放资源
br.close();
//6.遍历集合
for (String s1 : list) {
System.out.println(s1);
运行结果：
hello
world
3.点名器
public class Demo2 {
public static void main(String[] args) throws IOException {
//需求：文件中存储了班级同学的姓名，每一个姓名占一行，要求通过程序实现随机点名
//1.创建字符缓冲输入流对象
BufferedReader br = new BufferedReader(new FileReader("idea_test\\java.txt"));
//2.创建ArrayList集合
ArrayList String list = new ArrayList ();
//3.调用字符缓冲输入流对象的方法读数据
String line;
while ((line = br.readLine()) != null) {
//4.把读到的字符串数据存储到集合
list.add(line);
//5.释放资源
br.close();
//6.使用Random产生一个随机数，随机数的范围在：[0,集合长度)
Random random = new Random();
int i = random.nextInt(list.size());
//7.把产生的随机数作为索引，在集合中获取值
String s = list.get(i);
//8.将获取到的值输出到控制台
System.out.println(s);
4.集合到文件（改进版）
public class Demo1 {
public static void main(String[] args) throws IOException {
//需求：将ArrayList集合中的学生数据写入到文本文件。要求每一个向何生对象的数据作为文件中的一行数据
//格式：学号,姓名,年龄,居住地
//1.定义学生类
//2.创建ArrayList集合
ArrayList Student list = new ArrayList ();
//3.创建学生对象
Student s1 = new Student("初二001", "小明", 15, "西安");
Student s2 = new Student("初二002", "小红", 16, "北京");
Student s3 = new Student("初二003", "小军", 17, "上海");
Student s4 = new Student("初二004", "白展堂", 14, "云南");
Student s5 = new Student("初二005", "史珍香", 13, "广州");
//4.把学生对象添加到集合中
list.add(s1);
list.add(s2);
list.add(s3);
list.add(s4);
list.add(s5);
//5.创建字符缓冲输出流对象
BufferedWriter bw = new BufferedWriter(new FileWriter("idea_test\\java.txt"));
//6.遍历集合，得到每一个学生对象
for (Student stu : list) {
//7.把学生对象的数据拼接成指定格式的字符串
StringBuffer sb = new StringBuffer();
sb.append(stu.getId() + "," + stu.getName() + "," + stu.getAge() + "," + stu.getAddress());
//8.调用字符缓冲输出流对象的方法写数据
bw.write(sb.toString());
bw.newLine();
bw.flush();
//9.释放资源
bw.close();
5.文件到集合（改进版）
public class Demo3 {
public static void main(String[] args) throws IOException {
* 需求：把文本文件中的数据读取到集合中，并遍历集合。
* 要求：文本中每一行数据是一个学生对象的成员变量值
* 格式：学号,姓名,年龄,居住地
//1.定义学生类
//2.创建字符缓冲输入流对象
BufferedReader br = new BufferedReader(new FileReader("idea_test\\java.txt"));
//3.创建ArrayList集合
ArrayList Student list = new ArrayList ();
String line;
//4.调用字符缓冲输入流对象的方法读数据
while ((line = br.readLine()) != null) {
//5.把读取到的字符串用split分割，得到一个字符串数组
String[] s = line.split(",");
//6.创建学生对象
Student stu = new Student();
//7.把字符串数组中的每一个元素取出来，赋值给学生对象的成员变量
stu.setId(s[0]);
stu.setName(s[1]);
stu.setAge(Integer.parseInt(s[2]));
stu.setAddress(s[3]);
//8.把学生对象添加到集合
list.add(stu);
//9.释放资源
br.close();
//10.遍历集合
for (Student s : list) {
//直接输出，因为Student类中重写了toString()
System.out.println(s);
运行结果：
Student{id=初二001, name=小明, age=15, address=西安}
Student{id=初二002, name=小红, age=16, address=北京}
Student{id=初二003, name=小军, age=17, address=上海}
Student{id=初二004, name=白展堂, age=14, address=云南}
Student{id=初二005, name=史珍香, age=13, address=广州}
标准流和打印流
集合到文件数据排序（改进版）
定义学生类：
public class Student {
private String name;
private int yuwen;
private int shuxue;
private int yingyu;
public Student() {
public Student(String name, int yuwen, int shuxue, int yingyu) {
this.name = name;
this.yuwen = yuwen;
this.shuxue = shuxue;
this.yingyu = yingyu;
//定义获取总分的方法
public int getSum() {
return this.yuwen + this.shuxue + this.yingyu;
public String getName() {
return name;
public void setName(String name) {
this.name = name;
public int getYuwen() {
return yuwen;
public void setYuwen(int yuwen) {
this.yuwen = yuwen;
public int getShuxue() {
return shuxue;
public void setShuxue(int shuxue) {
this.shuxue = shuxue;
public int getYingyu() {
return yingyu;
public void setYingyu(int yingyu) {
this.yingyu = yingyu;
@Override
public String toString() {
return "Student{" +
"name=" + name + \ +
", yuwen=" + yuwen +
", shuxue=" + shuxue +
", yingyu=" + yingyu +
};
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null getClass() != o.getClass()) return false;
Student student = (Student) o;
if (yuwen != student.yuwen) return false;
if (shuxue != student.shuxue) return false;
if (yingyu != student.yingyu) return false;
return name != null ? name.equals(student.name) : student.name == null;
@Override
public int hashCode() {
int result = name != null ? name.hashCode() : 0;
result = 31 * result + yuwen;
result = 31 * result + shuxue;
result = 31 * result + yingyu;
return result;
测试类：
public class Demo {
public static void main(String[] args) throws IOException {
* 需求：键盘录入几个学生信息（姓名,语文成绩,数学成绩,英语成绩）
* 要求：按照成绩总分由高到低写入文件(排序规则)
Set Student list = new TreeSet (new Comparator Student () {
//匿名内部类重写排序方法
@Override
public int compare(Student o1, Student o2) {
//总分从低到高
int num = o2.getSum() - o1.getSum();
//如果总分相同，按照语文成绩从高到低
int num1 = num == 0 ? o1.getYuwen() - o2.getYuwen() : num;
//如果总分相同，语文成绩也相同，按照数学成绩从高到低
int num2 = num1 == 0 ? o1.getShuxue() - o2.getShuxue() : num1;
//如果总分相同，语文成绩也相同,数学成绩也相同，说明英语成绩肯定相。
郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。