java.io.File 类是文件和目录路径名的抽象表示,主要用于文件和目录的创建、查找和删除等操作
// 文件路径名
String pathname = "D:\\fmjava.txt";
File file1 = new File(pathname);
// 文件路径名
String pathname2 = "D:\\aaa\\fmjava.txt";
File file2 = new File(pathname2);
// 通过父路径和子路径字符串
String parent = "d:\\aaa";
String child = "fmjava.txt";
File file3 = new File(parent, child);
// 通过父级File对象和子路径字符串
File parentDir = new File("d:\\aaa");
String child2 = "fmjava.txt";
File file4 = new File(parentDir, child2);
一个File对象代表硬盘中实际存在的一个文件或者目录。 无论该路径下是否存在文件或者目录,都不影响File对象的创建。
File f = new File("d:/aaa/fmjava.txt");
System.out.println("文件绝对路径:"+f.getAbsolutePath());
System.out.println("文件构造路径:"+f.getPath());
System.out.println("文件名称:"+f.getName());
System.out.println("文件长度:"+f.length()+"字节");
File f2 = new File("d:/aaa");
System.out.println("目录绝对路径:"+f2.getAbsolutePath());
System.out.println("目录构造路径:"+f2.getPath());
System.out.println("目录名称:"+f2.getName());
System.out.println("目录长度:"+f2.length());
绝对路径:从盘符开始的路径,这是一个完整的路径 相对路径:相对于项目目录的路径,不是盘符开始,从项目名称的位置开始,不带项目名称
File f = new File("d:\\aaa\\fmjava.txt");
File f2 =new File("d:\\aaa");
// 判断是否存在
System.out.println("d:\\aaa\\fmjava.txt 是否存在:"+f.exists());
System.out.println("d:\\aaa 是否存在:"+f2.exists());
// 判断是文件还是目录
System.out.println("d:\\aaa 是否是文件:"+f2.isFile());
System.out.println("d:\\aaa 是否是目录:"+f2.isDirectory());
// 文件的创建
File f = new File("aaa.txt");
System.out.println("是否存在:"+f.exists());// false
/*createNewFile方法只能当文件不存在的时候创建,如果已经存在了,返回false,不创建文件*/
System.out.println("是否创建:"+f.createNewFile()); // true
System.out.println("是否存在:"+f.exists()); // true
// 目录的创建
File f2= new File("newDir");
System.out.println("是否存在:"+f2.exists());// false
System.out.println("是否创建:"+f2.mkdir()); // true
System.out.println("是否存在:"+f2.exists());// true
//创建多级目录
File f3= new File("newDira\\newDirb");
System.out.println(f3.mkdir());//只能创建一级目录 false
File f4= new File("newDira\\newDirb");
System.out.println(f4.mkdirs());//使用mkdirs创建多级目录 true
// 文件的删除
System.out.println(f.delete());// true
// 目录的删除
System.out.println(f2.delete());// true
System.out.println(f4.delete());// false
File dir = new File("d:\\aaa");
//获取当前目录下的文件以及文件夹的名称。
String[] names = dir.list();
for(String name : names){
System.out.println(name);
}
System.out.println("-----------");
//获取当前目录下的文件以及文件夹对象,只要拿到了文件对象,那么就可以获取更多信息
File[] files = dir.listFiles();
for (File file : files) {
System.out.println(file);
}
注意事项:调用listFiles方法的File对象,表示的必须是实际存在的目录,否则返回null,无法进行遍历
指在当前方法内调用自己的这种现象。 调用时,要有一个退出的条件,否则会死循环
示例
1到3的和 1+2+3
public static void main(String[] args) {
int num = 3;
// 调用求和的方法
int sum = getSum(num);
//输出结果
System.out.println(sum);
}
private static int getSum(int num) {
/*
num 为1时 返回1 相当于函数的出口
* */
if (num == 1){
return 1;
}
/*
不为1时, 返回num和num-1的累加和
递归调用getSum
* */
return num + getSum(num-1);
}
10的阶乘10! 1098765432*1
public static void main(String[] args) {
int num = 4;
// 调用求和的方法
int sum = getJieCheng(num);
//输出结果
System.out.println(sum);
}
private static int getJieCheng(int num) {
/*
num 为1时 返回1 相当于函数的出口
* */
if (num == 1){
return 1;
}
/*
不为1时, 返回num和num-1的累加和
递归调用getSum
* */
return num * getJieCheng(num-1);
}
又称黄金分割数列、因数学家列昂纳多·斐波那契(Leonardoda Fibonacci)以兔子繁殖为例子而引入,故又称为“兔子数列” 指的是这样一个数列:1、1、2、3、5、8、13、21、34、……
递归分析
当位数为1和2时,当前返回的值应该是1;
当位数为3时,返回值应该=2=1+1;
当位数为4时,返回值=3=2+1;
当位数为5时,返回值=5=3+2;
大于等于3的情况下,当前位数(n)的数值=f(n-1)+f(n-2)
实现过程图解
示例代码
public static void main(String[] args) {
int f = f(3);
System.out.println(f);
//数列:1,1,2,3,5,8......
for (int i=1;i<=15;i++){ //输出15个斐波那契数列
System.out.print(f(i)+"\t");
}
}
public static int f(int n){
if( n == 1 || n == 2 )
return 1;
else
return f( n - 1 )+f( n - 2 );
}
搜索指定目录下指定扩展名的文件 D盘下 aaa目录中所有的 .txt文件
public static void printDir(File dir) {
// 获取子文件和目录
File[] files = dir.listFiles();
// 循环打印
for(File file : files){
if(file.isFile()){
// 是文件,判断文件名并输出文件绝对路径
if(file.getName().endsWith(".txt")){
System.out.println("文件名:"+file.getAbsolutePath());
}
}else{
// 是目录,继续遍历,形成递归
printDir(file);
}
}
}
把与计算机之间数据的传输,可以看做是一种数据的流动,按照流动的方向 以内存为基准,分为 输入input 和 输出 output ,即流向内存是输入流,流出内存的输出流 可以理解 把程序当中的数据保存到电脑磁盘,为输出流,把电脑磁盘当中的数据加载到程序当中为输入流
示例图
IO的分类 根据数据的流向分:
根据数据的类型分:
顶级父类 字节输入流 :InputStream 字节输出流:OutputStream 字符输入流 :Reader 字符输出流:Writer
一切文件数据(文本、图片、视频等)在存储时,都是以二进制数字的形式保存,都一个一个的字节 在传输时也是使用字节进行传输,我们称之为字节流 字节流可以传输任意文件数据 无论使用什么样的流对象,底层传输的始终为二进制数据
OutputStream 有很多子类, 以上方法子类都可以调用
//使用File对象创建流对象
File file = new File("a.txt");
/*此处抛出异常*/
FileOutputStream fos = new FileOutputStream(file);
// 使用文件名称创建流对象
FileOutputStream fos2 = new FileOutputStream("b.txt");
当你创建一个流对象时,必须传入一个文件路径
该路径下,如果没有这个文件,会创建该文件。如果有这个文 件,会清空这个文件的数据,写入新的信息
写出字节 每次可以写出一个字节数据
//使用File对象创建流对象
File file = new File("a.txt");
//使用文件名称创建流对象
FileOutputStream fos = new FileOutputStream(file);
//写出数据
fos.write(97);//一次只能写一个字节数据
fos.write(98);
fos.write(99);
// 关闭资源
fos.close();
注意事项 1. 虽然参数为int类型四个字节,但是只会保留一个字节的信息写出。 2. 流操作完毕后,必须释放系统资源,调用close方法,千万记得。
写出字节数组 可以通过getBytes方法把汉字转成字节数组
//使用File对象创建流对象
File file = new File("a.txt");
//使用文件名称创建流对象
FileOutputStream fos = new FileOutputStream(file);
// 字符串转换为字节数组
byte[] b = "疯狂代码".getBytes();
fos.write(b);
// 关闭资源
fos.close();
写出指定长度字节数组 每次写出从off索引开始,len个字节
//使用File对象创建流对象
File file = new File("a.txt");
//使用文件名称创建流对象
FileOutputStream fos = new FileOutputStream(file);
// 字符串转换为字节数组
byte[] b = "abcde".getBytes();
fos.write(b,2,2); //cd
// 关闭资源
fos.close();
每次程序运行,创建输出流对象,都会清空目标文件中的数据
参数介绍 参数中都需要传入一个boolean类型的值 true 表示追加数据 false 表示清空原有数据
Windows系统里,换行符号是 \r\n 示例
java.io.InputStream 抽象类是表示字节输入流的所有类的超类,可以读取字节信息到内存中。它定义了字节输入 流的基本共性功能方法
java.io.FileInputStream 类是文件输入流,从文件中读取字节
FileInputStream(File file)
FileInputStream(String name)
示例
File file = new File("a.txt");
FileInputStream fileInputStream = new FileInputStream(file);
FileInputStream fileInputStream1 = new FileInputStream("a.txt");
注意事项 当你创建一个流对象时,必须传入一个文件路径。该路径下,如果没有该文件,会抛出 FileNotFoundException 。
read()方法 作用:每次可以读取一个字节的数据,提升为int类型,读取到文件末尾,返回 -1
示例 方式1
// 使用文件名称创建流对象
FileInputStream fis = new FileInputStream("a.txt");
int read = fis.read();
System.out.println((char)read);
int read2 = fis.read();
System.out.println((char)read2);
int read3 = fis.read();
System.out.println((char)read3);
int read4 = fis.read();
System.out.println((char)read4);
int read5 = fis.read();
System.out.println(read5);//-1
方式2
// 使用文件名称创建流对象
FileInputStream fis = new FileInputStream("a.txt");
int b;
while ((b = fis.read())!= -1){
System.out.println((char)b);
}
read(byte[] b)方法 作用:每次读取b的长度个字节到数组中,返回读取到的有效字节个数,读 取到末尾时,返回 -1
public static void main(String[] args) throws Exception {
// 使用文件名称创建流对象
FileInputStream fis = new FileInputStream("a.txt");//abcd
//定义变量作为有效个数
int len;
// 定义字节数组,作为装字节数据的容器
byte[] b = new byte[2];
while ((len=fis.read(b)) != -1){
//每次读取后,把数组变成字符串打印
System.out.println(new String(b));
}
fis.close();
}
public static void main(String[] args) throws Exception {
//指定数据源
FileInputStream fis = new FileInputStream("D:\\logo.jpg");
//指定目的地
FileOutputStream fos = new FileOutputStream("copyLogo.jpg");
byte[] b = new byte[1024];
int len;//在外面声明变量, 不用每次循环时, 创建新的变量
while ((len = fis.read(b)) != -1){
fos.write(b,0,len);
}
fos.close();
fis.close();
}
当使用字节流读取文本文件时,可能会有一个小问题。 就是遇到中文字符时,可能不会显示完整的字符,那是因为 一个中文字符可能占用多个字节存储。 所以Java提供一些字符流类,以字符为单位读写数据,专门用于处理文本文 件。
java.io.Reader 抽象类是表示用于读取字符流的所有类的超类,可以读取字符信息到内存中。 它定义了字符输入 流的基本共性功能方法
java.io.FileReader 类是读取字符文件的便利类。构造时使用系统默认的字符编码和默认字节缓冲区。
注意事项 当你创建一个流对象时,必须传入一个文件路径。类似于FileInputStream
read 方法 每次可以读取一个字符的数据,提升为int类型,读取到文件末尾,返回 -1
public static void main(String[] args) throws Exception {
//使用文件名称创建流对象
FileReader fr = new FileReader("fmjava.txt");
int b;//定义变量保存数据
while ((b = fr.read()) != -1){
System.out.println((char)b);
}
fr.close();
}
read(char[] cbuf) 每次读取b的长度个字符到数组中,返回读取到的有效字符个数, 读取到末尾时,返回 -1
使用上面这种方法会发现,如果是5个字符的时候 会多读取一个, 是因为chars中内容没有被清空
指定有效个数
java.io.FileWriter 类是写出字符到文件的便利类。构造时使用系统默认的字符编码和默认字节缓冲区。
当你创建一个流对象时,必须传入一个文件路径,类似于FileOutputStream。
作用 每次可以写出一个字符数
示例
FileWriter fw = new FileWriter("fmjava.txt",true);
fw.write(97);
fw.write('b');
fw.write(30000);
//关闭资源时,与FileOutputStream不同
//如果不关闭,数据只是保存到缓冲区,并未保存到文件。
fw.close();
关闭和刷新 刷新 因为内置缓冲区的原因,如果不关闭输出流,无法写出字符到文件中。但是关闭的流对象,是无法继续写出数据 的。 如果我们既想写出数据,又想继续使用流,就需要 flush 方法了 flush 刷新缓冲区,流对象可以继续使用 close 关闭流,释放系统资源。关闭前会刷新缓冲区。
示例
FileWriter fw = new FileWriter("fmjava.txt",true);
fw.write(97);
fw.write('b');
fw.write(30000);
//关闭资源时,与FileOutputStream不同
//如果不关闭,数据只是保存到缓冲区,并未保存到文件。
fw.flush();
fw.write('d');
fw.close();
作用 write(char[] cbuf) 和 write(char[] cbuf, int off, int len) ,每次可以写出字符数 组中的数据 示例
FileWriter fw = new FileWriter("fmjava.txt");
String msg = "疯狂代码";
char[] chars = msg.toCharArray();
//写出字符数组
fw.write(chars);//疯狂代码
//写出从索引2开始,2个字符。
fw.write(chars,2,2);//代码
fw.close();
作用 write(String str) 和 write(String str, int off, int len) ,每次可以写出字符串中的 数据
示例
方式1
FileWriter fw = null;
try {
fw = new FileWriter("fmjava.txt");
} catch (IOException e) {
e.printStackTrace();
}finally {
if (fw != null){
try {
fw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
方式2 格式
try(创建流对象语句,如果多个,使用’;'隔开){ 代码 } catch(IOException e){ e.printStackTrace(); }
示例
//该语句确保了每个资源在语句结束时关闭
try(FileWriter fw = new FileWriter("fmjava.txt");
FileReader fr = new FileReader("fmjava.txt")) {
fw.write("fmjava.com");
int read = fr.read();
}catch (IOException e){
e.printStackTrace();
}
缓冲流,也叫高效流,是对4个基本的 File*** 流的增强 所以也是4个流,按照数据类型分类: 字节缓冲流: BufferedInputStream , BufferedOutputStream 字符缓冲流: BufferedReader , BufferedWriter
缓冲流的基本原理,是在创建流对象时,会创建一个内置的默认大小的缓冲区数组, 通过缓冲区读写,减少系统IO 次数,从而提高读写的效率。
//创建字节缓冲输入流
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("fmjava.txt"));
//创建字节缓冲输出流
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("fmjava.txt"));
直接使用FileInputStream与FileOutStream复制文件
long start = System.currentTimeMillis();
FileInputStream fis = new FileInputStream("D:\\apache-maven-3.5.4.rar");
FileOutputStream fos = new FileOutputStream("newMaven.rar");
int len;
byte[] b = new byte[1024];
while ((len = fis.read(b)) != -1){
fos.write(b);
}
fis.close();
fos.close();
long end = System.currentTimeMillis();
System.out.println("时间:"+(end-start));
使用缓冲流复制文件
long start = System.currentTimeMillis();
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("D:\\apache-maven-3.5.4.rar"));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("newMaven.rar"));
int len;
byte[] b = new byte[1024];
while ((len = bis.read(b)) != -1){
bos.write(b);
}
bis.close();
bos.close();
long end = System.currentTimeMillis();
System.out.println("时间:"+(end-start));
构造方法
BufferedReader br = new BufferedReader(new FileReader("fmjava.txt"));
BufferedWriter bw = new BufferedWriter(new FileWriter("fmjava.txt"));
特有方法
示例
BufferedReader br = new BufferedReader(new FileReader("fmjava.txt"));
String line = null;
while ((line = br.readLine())!= null){
System.out.println(line);
}
br.close();
BufferedWriter br = new BufferedWriter(new FileWriter("out.txt"));
br.write("疯码");
br.newLine();
br.write("教育");
br.newLine();
br.close();
计算机中储存的信息都是用二进制数表示的,而我们在屏幕上看到的数字、英文、标点符号、汉字等字符是二进制 数转换之后的结果。 按照某种规则,将字符存储到计算机中,称为编码 反之,将存储在计算机中的二进制数按照 某种规则解析显示出来,称为解码 按照A规则存储,同样按照A规则解析,那么就能显示正确的文本f符 号。反之,按照A规则存储,再按照B规则解析,就会导致乱码现象
字符集 Charset :也叫编码表。是一个系统支持的所有字符的集合,包括各国家文字、标点符号、图形符 号、数字等。 计算机要准确的存储和识别各种字符集符号,需要进行字符编码,一套字符集必然至少有一套字符编码。 常见字符 集有ASCII字符集、GBK字符集、Unicode字符集等
当指定了编码,它所对应的字符集自然就指定了,所以编码才是我们最终要关心的。
在IDEA中,使用 FileReader 读取项目中的文本文件。由于IDEA的设置,都是默认的 UTF-8 编码,所以没有任何 问题 但是,当读取Windows系统中创建的文本文件时,由于Windows系统的默认是GBK编码,就会出现乱码。
示例
public static void main(String[] args) throws Exception{
FileReader fileReader = new FileReader("d://gbkfile.txt");
int read;
while ((read = fileReader.read())!= -1){
System.out.println((char)read); //读出的内容是乱码
}
fileReader.close();
}
解决乱码 InputStreamReader 作用 转换流 java.io.InputStreamReader ,是Reader的子类,是从字节流到字符流的桥梁 它读取字节,并使用指定 的字符集将其解码为字符。它的字符集可以由名称指定,也可以接受平台的默认字符集 构造方法
InputStreamReader isr = new InputStreamReader(new FileInputStream("d://gbkfile.txt"),"gbk");
int read;
while ((read = isr.read())!= -1){
System.out.println((char)read); //读出的内容是乱码
}
isr.close();
OutputStreamWriter 作用 转换流 java.io.OutputStreamWriter ,是Writer的子类,是从字符流到字节流的桥梁 使用指定的字符集将字符 编码为字节。它的字符集可以由名称指定,也可以接受平台的默认字符集 构造方法 OutputStreamWriter(OutputStream in) 创建一个使用默认字符集的字符流。 OutputStreamWriter(OutputStream in, String charsetName) 创建一个指定字符集的字符流
示例
String fileName1 = "d://out.txt";
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(fileName1));
osw.write("疯码");//保存为6个字节
osw.close();
String fileName2 = "d://out2.txt";
OutputStreamWriter osw2 = new OutputStreamWriter(new FileOutputStream(fileName2), "gbk");
osw2.write("疯码");//4个字节
osw2.close();
用一个字节序列可以表示一个对象,该字节序列包含该 对象的数据 、 对象的 类型 和 对象中存储的属性 等信息 字节序列写出到文件之后,相当于文件中持久保存了一个对象的信息。 字节序列还可以从文件中读取回来,重构对象,对它进行反序列化 对象的数据 、 对象的类型 和 对象中 存储的数据 信息,都可以用来在内存中创建对象。
该类必须实现 java.io.Serializable 接口 Serializable 是一个标记接口,不实现此接口的类将不会使任 何状态序列化或反序列化,会抛出 NotSerializableException 该类的所有属性必须是可序列化的。如果有一个属性不需要可序列化的,则该属性必须注明是瞬态的,使用 transient 关键字修饰
作用:将Java对象的原始数据类型写出到文件,实现对象的持久存储 构造方法
public ObjectOutputStream(OutputStream out)
创建一个指定OutputStream的ObjectOutputStream。 构造举例,
写出对象方方法 public final void writeObject (Object obj)
示例 创建Person类
public class Person implements java.io.Serializable{
public String name;
public String age;
public transient String address;
public void show(){
System.out.println("myName is "+name);
}
}
写到文件当中
public static void main(String[] args) throws Exception{
Person person = new Person();
person.name = "fmjava";
person.age = "1";
person.address = "南京";
FileOutputStream fos = new FileOutputStream("person.txt");
ObjectOutputStream oos = new ObjectOutputStream(fos);
oos.writeObject(person);
oos.close();
fos.close();
}
作用:ObjectInputStream反序列化流,将之前使用ObjectOutputStream序列化的原始数据恢复为对象
构造方法
public ObjectInputStream(InputStream in)
创建一个指定InputStream的ObjectInputStream
读取对象方法 readObject() 示例
FileInputStream fileIn = new FileInputStream("person.txt");
ObjectInputStream in = new ObjectInputStream(fileIn);
Person p = (Person)in.readObject();
System.out.println(p.name);
System.out.println(p.age);
System.out.println(p.address);
p.show();
fileIn.close();
in.close();
注意事项 对于JVM可以反序列化对象,它必须是能够找到class文件的类。 如果找不到该类的class文件,则抛出一个 ClassNotFoundException 异常
概述
我们在控制台打印输出,是调用 print 方法和 println 方法完成的 这两个方法都来自于 java.io.PrintStream 类 该类能够方便地打印各种数据类型的值,是一种便捷的输出方式。
使用指定的文件名创建一个新的打印流
public PrintStream(String fileName)
System.out 就是 PrintStream 类型的,只不过它的流向是系统规定的,打印在控制台上
示例
System.out.println("疯码");
PrintStream os = new PrintStream("fmjava.txt");
//设置系的打印流向,输出到指定的文件
System.setOut(os);
System.out.println("疯码");