一、File类
java.io.File
类是文件和目录路径名的抽象表示,主要用于文件和目录的创建、查找和删除等操作。
File类的构造方法
public File(String pathname)
:通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例。public File(String parent, String child)
:从父路径名字符串和子路径名字符串创建新的 File实例。public File(File parent, String child)
:从父抽象路径名和子路径名字符串创建新的 File实例。
import java.io.File;
/**
* @Author:
* @Date: 2020/9/20 9:06
*/
public class Test {
public static void main(String[] args) {
// 创建File对象表示H:\aaa\hb.jpg文件路径
File f1 = new File("H:\\aaa\\hb.jpg");
File f2 = new File("H:\\aaa","hb.jpg");
File parent = new File("H:\\aaa");
File f3 = new File(parent, "hb.jpg");
System.out.println(f1);
System.out.println(f2);
System.out.println(f3);
System.out.println("=========================================");
// 创建File对象表示H:\aaa\2020文件夹路径
File f4 = new File("H:\\aaa\\2020");
File f5 = new File("H:\\aaa","2020");
File f6 = new File(parent,"2020");
System.out.println(f4);
System.out.println(f5);
System.out.println(f6);
System.out.println("=========================================");
// 路径不存在的
File f7 = new File("H:\\aaa\\b.txt");// b.txt文件是不存在的
File f8 = new File("H:\\aaa\\2018");// 2018文件夹是不存在的
System.out.println(f7);
System.out.println(f8);
}
}
- 一个File对象代表硬盘中的一个文件或者目录。
- 无论该路径下是否存在文件或者目录,都不影响File对象的创建。
File类常用方法
绝对路径和相对路径
- 绝对路径:从盘符开始的路径,这是一个完整的路径。
- 相对路径:相对于项目工作目录的路径,这是一个便捷的路径,开发中经常使用。
获取功能的方法
-
public String getAbsolutePath()
:返回此File的绝对路径名字符串。 -
public String getPath()
:将此File转换为路径名字符串。 获取构造路径(构造方法中传入的路径) -
public String getName()
:返回由此File表示的文件或目录的名称。 -
public long length()
:返回由此File表示的文件的字节大小。 不能获取目录的字节大小,返回值未指定。
public class Test {
public static void main(String[] args) {
/*
程序中:
绝对路径:G:\szit104\day12\aaa\hb.jpg
相对路径:day12\aaa\hb.jpg
*/
// 绝对路径
File f11 = new File("G:\\szit104\\day12\\aaa\\hb.jpg");
// 相对路径
File f22 = new File("day12\\aaa\\hb.jpg");
System.out.println(f1);
System.out.println(f2);
// 创建File对象,表示day12\aaa\hb.jpg文件的路径
File f1 = new File("day12\\aaa\\hb.jpg");
System.out.println("f1的绝对路径:"+f1.getAbsolutePath());// G:\szit104\day12\aaa\hb.jpg G:\szit104为项目工作目录
System.out.println("f1的构造路径:"+f1.getPath());// day12\aaa\hb.jpg
System.out.println("f1的文件名:"+f1.getName());// hb.jpg
System.out.println("f1的字节大小:"+f1.length());// 24,666 字节
// 创建File对象,表示day12\aaa\bbb文件夹的路径
File f2 = new File("day12\\aaa\\bbb");
System.out.println("f2的绝对路径:"+f2.getAbsolutePath());// G:\szit104\day12\aaa\bbb
System.out.println("f2的构造路径:"+f2.getPath());// day12\aaa\bbb
System.out.println("f2的文件名:"+f2.getName());// bbb
System.out.println("f2的字节大小:"+f2.length());// 0
}
}
判断功能的方法
public boolean exists()
:此File表示的文件或目录是否实际存在。public boolean isDirectory()
:此File表示的是否为目录。public boolean isFile()
:此File表示的是否为文件。
创建删除功能的方法
public boolean createNewFile()
:当且仅当具有该名称的文件尚不存在时,创建一个新的空文件。public boolean delete()
:删除由此File表示的文件或目录。public boolean mkdir()
:创建由此File表示的目录。public boolean mkdirs()
:创建由此File表示的目录,包括任何必需但不存在的父目录。
File类遍历目录方法
-
public String[] list()
:返回一个String数组,表示该File目录中的所有子文件或子目录的名称。 -
public File[] listFiles()
:返回一个File数组,表示该File目录中的所有的子文件或子目录的路径。
import java.io.File;
/**
* @Author:
* @Date:
*/
public class Test {
public static void main(String[] args) {
/*
File类遍历目录方法:
- public String[] list() :返回一个String数组,表示该File目录中的所有子文件或子目录的名称。
- public File[] listFiles() :返回一个File数组,表示该File目录中的所有的子文件或子目录的路径。
*/
// 创建File对象,表示day12\aaa文件夹
File f = new File("day12\\aaa");
// 获取f路径下的所有子文件和子文件夹的名称
String[] arr1 = f.list();
// 循环遍历
for (String s : arr1) {
System.out.println(s);
}
System.out.println("==============================");
// 获取f路径下的所有子文件和子文件夹的路径
File[] arr2 = f.listFiles();
// 循环遍历
for (File file : arr2) {
System.out.println(file);
}
System.out.println("==============================");
// 注意:如果文件夹没有访问权限,那么返回的就是null,遍历就会报空指针异常
File f1 = new File("H:\\System Volume Information");
String[] list = f1.list();
File[] files = f1.listFiles();
System.out.println(list+","+files);// null,null
// 报异常,为了代码的健壮性,所以循环之前加一个非空判断
if (list != null) {
for (String s : list) {
}
}
}
}
二、递归
指在当前方法内调用自己的这种现象。
递归的注意事项:
- 递归要有出口(结束方法),否则会报栈内存溢出错误StackOverflowError
- 递归的出口不能太晚了
什么时候用递归:同类事物相包含。
public class Test {
static int count = 0;
public static void main(String[] args) {
/*
程序中的递归: 指在当前方法内调用自己的这种现象
注意事项:
1.递归一定要有出口,否则会报栈内存溢出错误StackOverflowError
2.递归出口太晚了(递归深度要适当),还是会报栈内存溢出错误StackOverflowError
解决办法:合理递归
*/
method();
}
public static void method(){
count++;
if (count == 70000){
return;
}
System.out.println("method 方法执行了...");
method();
}
}
三、IO
3.1 IO的概述
- I : Input 输入 从其他存储设备读数据到内存中就是输入
- O : Output 输出 从内存中写数据到其他存储设备
3.2 IO的分类
根据数据的流向分为:输入流和输出流。
- 输入流 :把数据从
其他设备
上读取到内存
中的流。- 字节输入流:以字节为基本单位,读数据
- 字符输入流:以字符为基本单位,读数据
- 输出流 :把数据从
内存
中写出到其他设备
上的流。- 字节输出流:以字节为基本单位,写出数据
- 字符输出流:以字符为基本单位,写出数据
根据数据的类型分为:字节流和字符流。
- 字节流 :以字节为单位,读写数据的流。
- 字节输入流:以字节为基本单位,读数据
- 字节输出流:以字节为基本单位,写出数据
- 字符流 :以字符为单位,读写数据的流。
- 字符输入流:以字符为基本单位,读数据
- 字符输出流:以字符为基本单位,写出数据
IO的顶层父类
字节输入流:顶层父类是InputStream抽象类,常见的子类FileInputStream
字节输出流:顶层父类是OutputStream抽象类,常见的子类FileOutputStream
字符输入流:顶层父类是Reader抽象类,常见的子类FileReader
字符输出流:顶层父类是Writer抽象类,常见的子类FileWriter
注意事项
- utf8编码一个中文占3个字节,gbk编码一个中文占2个字节
- 如果存储和解析的编码不一致就会乱码
- idea默认编码是utf8
四、字节流
1、字节输出流【OutputStream】
OutputStream类的概述
java.io.OutputStream
抽象类是表示字节输出流的所有类的超类,将指定的字节信息写出到目的地。它定义了字节输出流的基本共性功能方法。
OutputStream类的常用方法
public void close()
:关闭此输出流并释放与此流相关联的任何系统资源。public void write(byte[] b)
:将 b.length字节从指定的字节数组写入此输出流。public void write(byte[] b, int off, int len)
:从指定的字节数组写入 len字节,从偏移量 off开始输出到此输出流。public abstract void write(int b)
:将指定的字节输出流。
小贴士:
close方法,当完成流的操作时,必须调用此方法,释放系统资源。
FileOutputStream类
FileOutputStream类的概述
java.io.FileOutputStream
类是OutputStream类的子类,用来表示是文件输出流,用于将数据写出到文件。
FileOutputStream类的构造方法
public FileOutputStream(File file)
:创建文件输出流以写入由指定的 File对象表示的文件。public FileOutputStream(String name)
: 创建文件输出流以指定的名称写入文件。
当你创建一个流对象时,必须传入一个文件路径。该路径下,如果没有这个文件,会创建该文件。如果有这个文件,会清空这个文件的数据。
写出字节:write(int b)
方法,每次可以写出一个字节数据,
小贴士:
1. 虽然参数为int类型四个字节,但是只会保留一个字节的信息写出。
2. 流操作完毕后,必须释放系统资源,调用close方法,千万记得。
写出字节数组:write(byte[] b)
,每次可以写出数组中的数据,代码使用演示:
public class Test3 {
public static void main(String[] args) throws Exception{
/*
FileOutputStream类的写出数据:
- public void write(byte[] b):将 b.length字节从指定的字节数组写入此输出流。
- public void close() :关闭此输出流并释放与此流相关联的任何系统资源。
*/
// 创建字节输出流,关联目的地文件路径
FileOutputStream fos = new FileOutputStream("day12\\bbb\\b.txt");
// 创建字节数组,并存储字节数据
byte[] bys = {97,98,99,100};
// 写出该字节数组中的字节数据
fos.write(bys);
// 关闭流,释放资源
fos.close();
}
}
写出指定长度字节数组:write(byte[] b, int off, int len)
,每次写出从off索引开始,len个字节,
数据追加续写
每次程序运行,创建输出流对象,都会清空目标文件中的数据。如何保留目标文件中数据,还能继续添加新数据呢?
public FileOutputStream(File file, boolean append)
: 创建文件输出流以写入由指定的 File对象表示的文件。public FileOutputStream(String name, boolean append)
: 创建文件输出流以指定的名称写入文件。
这两个构造方法,参数中都需要传入一个boolean类型的值,true
表示追加数据,false
表示清空原有数据。这样创建的输出流对象,就可以指定是否追加续写了,代码使用演示:
public class Test5 {
public static void main(String[] args) throws Exception{
/*
数据追加续写:
- public FileOutputStream(File file, boolean append): 创建文件输出流以写入由指定的 File对象表示的文件。
- public FileOutputStream(String name, boolean append): 创建文件输出流以指定的名称写入文件。
参数append: 如果是true,就表示追加续写(不清空),如果是false,就清空原文件中的数据
注意:
1.当你创建一个字节输出流对象时,必须传入一个文件路径。
2.该路径下,如果没有这个文件,会创建该文件(空的)。
3.如果有这个文件,并且第二个参数为true,就不清空,如果第二个参数为false,就清空
*/
// 创建字节输出流对象,关联目的地文件路径(day12\bbb\a.txt)
FileOutputStream fos = new FileOutputStream("day12\\bbb\\a.txt",true);
// 写出数据
fos.write(97);
// 关闭流,释放资源
fos.close();
}
}
写出换行
Windows系统里,换行符号是\r\n
public class FOSWrite {
public static void main(String[] args) throws IOException {
// 需求: 把这首诗写入day15\\aaa\\d.txt文件中
// String类 byte[] getBytes();把一个字符串转换为一个字节数组
// 创建字节输出流对象,关联目的地文件路径
FileOutputStream fos = new FileOutputStream("day15\\aaa\\d.txt");
// 写出数据
fos.write("吟诗一首".getBytes());
fos.write("\r\n".getBytes());
fos.write("看这风景美如画".getBytes());
fos.write("\r\n".getBytes());
fos.write("吟诗一首赠天下".getBytes());
fos.write("\r\n".getBytes());
fos.write("奈何本人没文化".getBytes());
fos.write("\r\n".getBytes());
fos.write("只能卧槽浪好大".getBytes());
// 关闭流,释放资源
fos.close();
}
}
- 回车符
\r
和换行符\n
:- 回车符:回到一行的开头(return)。
- 换行符:下一行(newline)。
- 系统中的换行:
-
Windows系统里,每行结尾是
回车+换行
,即\r\n
; -
Unix系统里,每行结尾只有
换行
,即\n
; -
Mac系统里,每行结尾是
回车
,即\r
。从 Mac OS X开始与Linux统一。
-
2、字节输入流【InputStream】
InputStream类的概述
java.io.InputStream
抽象类是表示字节输入流的所有类的超类,可以读取字节信息到内存中。它定义了字节输入流的基本共性功能方法。
InputStream类的常用方法
public void close()
:关闭此输入流并释放与此流相关联的任何系统资源。public abstract int read()
: 从输入流读取数据的下一个字节。public int read(byte[] b)
: 从输入流中读取一些字节数,并将它们存储到字节数组 b中 。返回读入的字节数,-1到结尾了public int read(byte b[], int off, int len)
返回读入的字节数,-1到结尾了
小贴士:
close方法,当完成流的操作时,必须调用此方法,释放系统资源。
FileInputStream类
FileInputStream类的概述
java.io.FileInputStream
类是InputStream类的子类 , 用来表示文件输入流,从文件中读取字节。
FileInputStream类的构造方法
FileInputStream(File file)
: 通过打开与实际文件的连接来创建一个 FileInputStream ,该文件由文件系统中的文件对象 file命名。FileInputStream(String name)
: 通过打开与实际文件的连接来创建一个 FileInputStream ,该文件由文件系统中的路径名 name命名。
当你创建一个输入流对象时,必须传入一个文件路径。该路径下,如果没有该文件,会抛出FileNotFoundException
FileInputStream类的读取数据
- 读取字节:
read
方法,每次可以读取一个字节的数据,提升为int类型,读取到文件末尾,返回-1
,
小贴士:
1. 虽然读取了一个字节,但是会自动提升为int类型。
2. 流操作完毕后,必须释放系统资源,调用close方法,千万记得。
使用字节数组读取:read(byte[] b)
,每次读取b的长度个字节到数组中,返回读取到的有效字节个数,读取到末尾时,返回-1
小贴士:
使用数组读取,每次读取多个字节,减少了系统间的IO操作次数,从而提高了读写的效率,建议开发中使用。
五、字符流
当使用字节流读取文本文件时,可能会有一个小问题。就是遇到中文字符时,可能不会显示完整的字符,那是因为一个中文字符可能占用多个字节存储。所以Java提供一些字符流类,以字符为单位读写数据,专门用于处理文本文件。
1、字符输入流【Reader】
字符输入流Reader类的概述
java.io.Reader
抽象类是表示用于读取字符流的所有类的超类,可以读取字符信息到内存中。它定义了字符输入流的基本共性功能方法。
字符输入流Reader类的常用方法
-
public void close()
:关闭此流并释放与此流相关联的任何系统资源。 -
public int read()
: 从输入流读取一个字符。
字符读取,作为0到65535( 0x00-0xffff )范围内的整数,如果已经达到流的末尾,则为-1。 -
public int read(char[] cbuf)
: 从输入流中读取一些字符,并将它们存储到字符数组 cbuf中 。
读取的字符数,如果已经达到流的结尾,则为-1
FileReader类
FileReader类的概述
java.io.FileReader
类是读取字符文件的便利类。构造时使用系统默认的字符编码(utf8)和默认字节缓冲区。
FileReader类的构造方法
FileReader(File file)
: 创建一个新的 FileReader ,给定要读取的File对象。FileReader(String fileName)
: 创建一个新的 FileReader ,给定要读取的文件的名称。
当你创建一个流对象时,必须传入一个文件路径。类似于FileInputStream 。
public class Test1 {
public static void main(String[] args) throws Exception{
/*
概述:java.io.FileReader类继承Reader类,表示字符输入流,用来读取字符数据
构造方法:
- FileReader(File file): 创建一个新的 FileReader ,给定要读取的File对象。
- FileReader(String fileName): 创建一个新的 FileReader ,给定要读取的文件的名称。
注意:
1.当你创建一个输入流对象时,必须传入一个文件路径。
2.该路径下,如果没有该文件,会抛出FileNotFoundException
*/
// 文件存在:
// 创建字符输入流对象,关联数据源文件路径
FileReader fr1 = new FileReader("day12\\ddd\\a.txt");
FileReader fr2 = new FileReader(new File("day12\\ddd\\a.txt"));
// 文件不存在:
FileReader fr3 = new FileReader("day12\\ddd\\b.txt");// 报文件找不到异常
}
}
读取字符:read
方法,每次可以读取一个字符的数据,提升为int类型,读取到文件末尾,返回-1
使用字符数组读取:read(char[] cbuf)
,每次读取多个字符到数组中,返回读取到的有效字符个数,读取到末尾时,返回-1
2、字符输出流【Writer】
字符输出流Writer类的概述
java.io.Writer
抽象类是表示用于字符输出流的所有类的超类,将指定的字符信息写出到目的地。它定义了字节输出流的基本共性功能方法。
字符输出流Writer类的常用方法
public abstract void close()
:关闭此输出流并释放与此流相关联的任何系统资源。public abstract void flush()
:刷新此输出流并强制任何缓冲的输出字符被写出。public void write(int c)
:写出一个字符。public void write(char[] cbuf)
:将 b.length字符从指定的字符数组写出此输出流。public abstract void write(char[] b, int off, int len)
:从指定的字符数组写出 len字符,从偏移量 off开始输出到此输出流。public void write(String str)
:写出一个字符串。public void write(String str,int off,int len)
:写出一个字符串的一部分。
FileWriter类
FileWriter类的概述
java.io.FileWriter
类是写出字符到文件的便利类。构造时使用系统默认的字符编码和默认字节缓冲区。
FileWriter类的构造方法
FileWriter(File file)
: 创建一个新的 FileWriter,给定要读取的File对象。FileWriter(String fileName)
: 创建一个新的 FileWriter,给定要读取的文件的名称。FileWriter(File file,boolean append)
: 创建一个新的 FileWriter,给定要读取的File对象。FileWriter(String fileName,boolean append)
: 创建一个新的 FileWriter,给定要读取的文件的名称。
当你创建一个流对象时,必须传入一个文件路径,类似于FileOutputStream。
public class Test1 {
public static void main(String[] args) throws Exception{
/*
概述:java.io.FileWriter是Writer的子类,表示字符输出流,可以用来写出字符数据
构造方法:
- FileWriter(File file): 创建一个新的 FileWriter,给定要读取的File对象。
- FileWriter(String fileName): 创建一个新的 FileWriter,给定要读取的文件的名称。
- FileWriter(File file,boolean append): 创建一个新的 FileWriter,给定要读取的File对象。
- FileWriter(String fileName,boolean append): 创建一个新的 FileWriter,给定要读取的文件的名称。
注意:
1.当你创建一个字符输出流对象时,必须传入一个文件路径。
2.前面2个构造方法,传入的路径,如果没有这个文件,会创建该文件(空的),如果有这个文件,就会清空。
3.后面2个构造方法,传入的路径, 如果没有这个文件,会创建该文件(空的),如果有这个文件,并且第二个参数为true,就不清空,如果第二个参数为false,就清空
*/
// 文件存在
FileWriter fw1 = new FileWriter("day12\\ddd\\b.txt",true);
// 文件不存在
FileWriter fw2 = new FileWriter("day12\\ddd\\c.txt");
}
}
FileWriter类写出数据
写出字符:write(int b)
方法,每次可以写出一个字符数据
public class Test2 {
public static void main(String[] args) throws Exception{
/*
- public void write(int c) :写出一个字符。
*/
// 创建字符输出流对象,关联目的地文件路径
FileWriter fw = new FileWriter("day12\\ddd\\d.txt");
// 写出单个字符
fw.write('a');
fw.write('b');
// 关闭流,释放资源
fw.close();
}
}
小贴士:
- 虽然参数为int类型四个字节,但是只会保留一个字符的信息写出。
- 未调用close方法,数据只是保存到了缓冲区,并未写出到文件中。
写出字符数组 :write(char[] cbuf)
和write(char[] cbuf, int off, int len)
,每次可以写出字符数组中的数据,用法类似FileOutputStream
写出字符串:write(String str)
和 write(String str, int off, int len)
,每次可以写出字符串中的数据
续写和换行:操作类似于FileOutputStream。
public class FWWrite {
public static void main(String[] args) throws IOException {
// 使用文件名称创建流对象,可以续写数据
FileWriter fw = new FileWriter("fw.txt",true);
// 写出字符串
fw.write("ab");
// 写出换行
fw.write("\r\n");
// 写出字符串
fw.write("cd");
// 关闭资源
fw.close();
}
}
小贴士:字符流,只能操作文本文件,不能操作图片,视频等非文本文件。
当我们单纯读或者写文本文件时 使用字符流 其他情况使用字节流
关闭和刷新
因为内置缓冲区的原因,如果不关闭输出流,无法写出字符到文件中。但是关闭的流对象,是无法继续写出数据的。如果我们既想写出数据,又想继续使用流,就需要flush
方法了。
flush
:刷新缓冲区,流对象可以继续使用。close
:关闭流,释放系统资源。关闭前会刷新缓冲区。
六、数据输入Scanner
数据输入是指获取用户键盘录入的数据,
我们可以通过 Scanner 类来获取用户的输入
public static void main(String[] args) {
//创建对象
Scanner sc = new Scanner(System.in);
//接收数据
int x = sc.nextInt();
//输出数据
System.out.println("x:" + x);
}
Scanner类的构造方法
Scanner(InputStream source) //从指定输入流扫描的值。
Scanner(InputStream source, String charsetName) //从指定输入流扫描的值
Scanner(File source) //从指定文件扫描的值。
Scanner(File source, String charsetName) //从指定文件扫描的值。
Scanner类的常用方法
nextXxx():即获取下一个输入项。其中Xxx表示所要输入的数据的类型,比如Int、Long、Double…等基本数据类型。
hasNextXxx():是否还有下一个输入项。
next()与nextLine()方法获取输入的字符串,
在读取之前一般需要使用hasNext()与hasNextLine()进行判断是否还有输入的数据。
public void close() // 使用完毕后要记得关闭流
nextInt():
it only reads the int value, nextInt() places the cursor(光标) in the same line after reading the input.(nextInt()只读取数值,剩下"\n"还没有读取,并将cursor放在本行中)
next(): read the input only till the space. It can’t read two words separated by space. Also, next() places the cursor in the same line after reading the input.(next()只读空格之前的数据,并且cursor指向本行)
next() 方法遇见第一个有效字符(非空格,非换行符)时,开始扫描,当遇见第一个分隔符或结束符(空格或换行符)时,结束扫描,获取扫描到的内容,即获得第一个扫描到的不含空格、换行符的单个字符串。
next()
注意:
- 一定要读取到有效字符后才可以结束输入。
- 对输入的有效字符之前所遇到的空白,会自动将其去除。
- 只有输入的有效字符后才将其后面输入的空白作为结束符。
- next()不能得到带有空格的字符串。
nextLine()
注意:
1. 以Enter作为结束符,即获取到的是输入回车之前的所有字符。
2. 可以获取空白。