路径的书写
- 绝对路径：一个完整的路径，以盘符开头，例如F:/aaa.txt。
- 相对路径：一个简化的路径，不以盘符开头,例如/aaa.txt//b.txt。
1、路径是不区分大小写
2、路径中的文件名称分隔符windows使用反斜杠“\”或者是“/”。
1.File类
1.1File类的作用
File类 主要是描述目录的和文件对象的属性功能，但是不能对文件进行读写操作
File类主要用于文件和目录的创建、查找和删除等操作。
1.2File类的构造方法
- 最常用的构造方法还是直接用String写入文件的路径
- 文件的路径不存在时，在编译期并不报错，也就是说，在构造方法时的不会检验文件的路径是否正确，只会在运行时有FileNotFindException异常
//创建一个文件对象
File file1=new File("f:/Java/文件/169.txt");
1.3对文件及目录属性的常操作
判断操作
File file1 = new File ("d:/a.txt")
"文件是否存在:"+file1.exists();返回boolean值
"文件是否可读:"+file1.canRead();返回boolean值
"文件是否可写:"+file1.canWrite();返回boolean值
"是否是文件:"+file1.isFile();返回boolean值
"是否是绝对路径:"+file1.isAbsolute();返回boolean值
"是否是隐藏文件:"+file1.isHidden();返回boolean值
"是否是文件夹:"+file1.isDirectory();返回boolean值
获取操作
public String getName();获取文件名/目录名
public long length();获取文件的长度（字节）/目录长度
public String getAbsolutePath();获取文件的绝对路径
public String getParent();获取文件的父目录（上一级目录）
public String getPath();文件/目录构造路径
public long lastModified();最后一次被修改的时间(结果是最后修改的时间到1970年1月1日00：00：00的毫秒数)
lastModified()的使用配合Data对像来使用
File f1=new File("Test.java");
System.out.println(new Date(f1.lastModified()));
//返回的是Wed May 02 21:05:40 CST 2007
目录和文件的创建
public boolean mkdirs();创建指定目录，若上级目录不存在，会一同创建
public boolean mkdir();创建指定目录，若上级目录不存在，目录创建失败
--在File中不能通过调用构造方法来创建文件
public boolean createNewFile();创建指定文件
//检验文件是否创建完成
System.out.println(f2.getAbsolutePath()+"是否存在："+f2.exists());
创建文件时的注意
- 文件的目录必须是正确的，否则会返回IOException异常
- 在所创文件的目录下必须保证文件是唯一的，也就是在同类型的文件下文件不能重名。
目录和文件的删除
--删除目录/文件时一定要确保目录/文件下没有内容，否则删除失败
public boolean delete();删除目录/文件
文件的重命名
//将文件169.txt重新命名为83.txt
File file1=new File("f:/Java/文件/169.txt");
File file2=new File("f:/Java/文件/83.txt");
file1.renameTo(file2);
我们要使这个方法成功必须满足两个条件：
1.file2不存在，也就是file2并没有真的创建
2.file1 存在
满足这两个条件才会成功执行；
如果满足执行条件：先创建一个rname 对应文件,然后将old内容复制到其中，最后将原来的old文件删除；
如果不满足执行条件：上述内容都不会实现；
异常
1.SecurityException - 如果安全管理器存在，并且其 SecurityManager.checkWrite(java.lang.String)方法拒绝对旧的或新的路径名的写入访问
2.NullPointerException - 如果参数 dest是 null
通过重命名可以实现文件的移动
File file3=new File("f:/Java/文件/83.txt");
File file4=new File("f:/Java/83.txt");
System.out.println(file3.renameTo(file4));
返回结果是：true
1.file1必须存在，且file2不存在
2.移动后的目录中不可出现类型和命名都一致的文件
3.移动前后文件的命名必须相同
1.4目录的遍历
- public String[] list() ：返回一个String数组，表示该File目录中的所有子文件或目录。
- public File[] listFiles() ：返回一个File数组，表示该File目录中的所有的子文件或目录。
package chapter14;
import java.io.File;
public class TestFileRoots {
public static void main(String[] args) {
// 获取根目录
File[] roots = File.listRoots();
//遍历输出
for(int i=0;i<roots.length;i++) {
System.out.println(roots[i]);
}
//获取一个指定文件夹下的所有文件名
File folder = new File("f:/Java");
//获取文件夹下的文件列表
File[] files = folder.listFiles();
//遍历输出
for(int i=0;i<files.length;i++) {
System.out.println(files[i]);
}
}
}
结果
f:\Java\JDK8.rar
f:\Java\Practice
f:\Java\二级考试
f:\Java\二级考试.zip
f:\Java\图片
f:\Java\图片.zip
f:\Java\文件
listFiles在获取指定目录下的文件或者文件夹时必须满足下面两个条件
1，指定的目录必须存在
2，指定的必须是目录。否则容易引发返回数组为null，出现NullPointerException异常。
2. IO
2.1 IO类的作用
IO是是针对具体文件的操作类，主要是实现文件的输入和输出。
IO的分类（1）
- 流向的分类：
不管是输入和输出都是相对于你自己的程序来说的。
- 输出流：实现对文件的写的操作，将内容写入你的文件就是输出。
- 输入流：实现对文件的读的操作，将内容从你的文件读取到现在的程序中来就是输入。
*通常形况下输出和输入是成双成对的。
- 文件类型的分类
-字节流：以字节为单位的文件，后缀：.dat等
-字符流：以字符为单位的文件，后缀：.txt等
我们必须明确一点的是，一切文件数据(文本、图片、视频等)在存储时，都是以二进制数字的形式保存，都一个一个的字节，那么传输时一样如此。所以，字节流可以传输任意文件数据。在操作流的时候，我们要时刻明确，无论使用什么样的流对象，底层传输的始终为二进制数据。
只是字符流文件在输入输出时有多一个编码的过程。文件中保存的本质还是字节。字节文件的小率比字字符文件高。
比如向字符和字节文件中输入199这个数字
- 字节流文件：是读取文件内容的类型，再分配空间，将199转换为16进制的c7输出到文件字节流文件中。
- 字符流文件：将199分成’1’,‘9’,'9’的字符，将各个字符转换成二进制，再为各个字符分配空间，分别输出到字符流文件中。
IO的分类（2）
文件类型对应的父类
| — | 输入流 | 输出流 |
|---|---|---|
| 字符流 | InputWriter | OutputWriter |
| 字节流 | InputStream | OutputStream |
2.3 IO的流
除了基本的输入输出流之外：
- 需要转换—— 转换流 InputStreamReader 、OutputStreamWriter
- 需要高效—— 缓冲流Bufferedxxx
- 多个源—— 序列流 SequenceInputStream
- 对象序列化—— ObjectInputStream、ObjectOutputStream
- 保证数据的输出形式—— 打印流PrintStream 、Printwriter
- 操作基本数据，保证字节原样性——DataOutputStream、DataInputStream
文件读写工作的3个步骤（大象与冰箱）：
- 打开文件的输入流和输出流（打开冰箱）
- 读写文件（放入/拿出大象）
- 关闭文件（关闭冰箱）
2.4文本文件
2.4.1(FileWriter)
2.4.1.1 构造方法
try {
//创建一个FileWriter对象
FileWriter out = new FileWriter("f:/Java/文件/d.txt");
FileWriter out = new FileWriter("f:/Java/文件/d.txt",true);//追加方式写入
File file1 = new File("f:/Java/文件/d.txt");
FileWriter out = new FileWriter(file1);
File file1 = new File("f:/Java/文件/d.txt");
FileWriter out = new FileWriter(file1,true);//追加方式写入
}
catch(IOException e) {
e.printStackTrace();
}
- 指定的文件可以不存在，文件不存在可以自动创建，但是文件的目录必须存在，目录不存在时异常IOException
- 该语句会产生IOException异常，写的时候要加异常监控，或在方法头抛出异常
true的追加
- 当没有写true时，每次向文件中写入内容就会覆盖以前的内容
- 当写了true追加方法时，每次就是在文件的存在的后面继续添加内容，并不会覆盖。
2.4.1.2方法
out.write(",Hello,world!")
*void java.io.Writer.write(String str) throws IOException
只能写入字符,字符串，字符数组。
2.4.2（FileReader）
2.4.2.1构造方法
try {
//FileReader file1 = new FileReader("f:/Java/文件/d.txt");
File file1 = new File("f:/Java/文件/d.txt");
FileReader in = new FileReader(file1);
}
catch(IOException e) {
e.printStackTrace();
}
- 指定的文件文件必须存在，文件不存在时异常IOException类下的FileNotFoundException异常。
2.4.2.2方法
int i=in.read();//返回整形
while(-1!=i) {
char c=(char)i;//转换成char型
System.out.print(c);//输出
i=in.read();//继续读取
}
- public int read（） 方法是一个一个字节的读取，当读取到末尾时返回-1，
- 若存入的是字符’a’,则读取的是97，则需要强转为char
- 这个语句会产生非运行期的异常IOException。
2.4.3缓冲流–高效输出（BufferedWriter）
2.4.3.1构造方法
try {
//BufferedWrite只能使用一个write对象做参数
//创建对象
FileWriter fw = new FileWriter("f:/Java/文件/e.txt");
BufferedWriter bw = new BufferedWriter(fw);
}
catch(IOException e) {
e.printStackTrace();
}
- 用BufferedWrite更高效，但其构造方法只能写入Write其子类的对象
- 指定的文件可以不存在，文件不存在可以自动创建，但是文件的目录必须存在，目录不存在时异常IOException
- 想要实现追加，FileWriter fw = new FileWriter(“f:/Java/文件/e.txt”，true);
2.4.3.2方法
bw.write("序号\t");
bw.write("姓名\t");
bw.write("学号");
*void java.io.Writer.write(String str) throws IOException
只能写入字符,字符串，字符数组。
- public int read（） 方法是一个一个字节的读取，当读取到末尾时返回-1，
- 若存入的是字符’a’,则读取的是97，则需要强转为char
- 这个语句会产生非运行期的异常IOException。
2.4.4 缓冲流–高效输入（BufferedReader）
2.4.4.1构造方法
try {
//打开输入输出流
FileReader fr = new FileReader("f:/Java/文件/e.txt");
BufferedReader br = new BufferedReader(fr);
}
//异常处理
catch(FileNotFoundException e) {
System.out.println("文件不存在！"+e.toString());
}
catch(IOException e){
e.printStackTrace();
}
- 用BufferedReader更高效，但其构造方法只能写入Write其子类的对象
- 指定的文件文件必须存在，文件不存在时异常IOException类下的FileNotFoundException异常。
2.4.4.2方法
//获取各行各列的数值
String s = br.readLine();//读取文件的一行
while(s!=null) {//只要能读取到行的内容，就一直执行
String[] info = s.split("\t");//将列与列用\t分割，分别存入数组info中
System.out.println(info[0]+" "+info[1]+" "+info[2]);
s=br.readLine();//读取下一行
}
- public String readLine（） 方法是直接读取一行,返回String
- 这个语句会产生非运行期的异常IOException。
2.4.5输出各种类型数据（ PrinterWriter）
2.4.5.1构造方法
try {
//PrinterWriter只能使用一个write对象做参数
// 用PrintWriter向文本中输出数据，好处是是能够输入各种类型的数据
PrintWriter pw = new PrintWriter("f:/Java/文件/e.txt");
//PrintWriter PW = new PrintWriter("路径",true);追加方式写入
}
//异常处理
catch(IOException e){
e.printStackTrace();
}
- 用PrinterWriter可以向文本文件中输入各种类型的数据，但其构造方法只能写入Write其子类的对象
- 指定的文件可以不存在，文件不存在可以自动创建，但是文件的目录必须存在，目录不存在时异常IOException
- 想要实现追加，FileWriter fw = new FileWriter(“f:/Java/文件/e.txt”，true);
2.4.5.2方法
Student s1 = new Student("001","孤尽",48);
Student s2 = new Student("002","承越",38);
Student s3 = new Student("003","承旭",28);
//编写表头
pw.print("编号\t");
pw.print("姓名\t");
pw.println("年龄");
//调用对象的toString方法，将字符串写入文件中
pw.println(s1);
pw.println(s2);
pw.println(s3);
//写字符串
pw.print("004");
pw.print("右旋");
pw.println(18);
- print() 和println() 简单的区别是println()光标会移到下一行，类似实现换行功能
- 可输出的值：
- 这个语句会产生非运行期的异常IOException。
2.4.6 输入各种类型数据（Scanner）
2.4.6.1构造方法
try {
Scanner input =new Scanner(new File("f:/Java/文件/e.txt"));
}
//异常处理
catch(IOException e){
e.printStackTrace();
}
- java.util.Scanner类用来读取基本数据类型和字符串>
- 指定的文件文件必须存在，文件不存在时异常IOException
2.4.6.2方法
while (input.hasNext()) {
String id = input.next();//
.next()方法能够从指定文件中读取用分隔符分隔的各种类型的数据，
默认情况下是空格
String name = input.next();
int age = input.nextInt();
//打印输出
System.out.println(id+" "+name+" "+age);
}
- public boolean hasNext() 判断文件中是否还有下一行，如果有，则返回true，没有则返回false。
- public String next()/ public int nextInt()方法是读取一行中的对应的列。
- 指定的文件可以不存在，文件不存在可以自动创建，但是文件的目录必须存在，目录不存在时异常IOException
2.5二进制文件
2.5.1（FileOutputStream）
2.5.1.1 构造方法
try {
//创建一个FileWriter对象
FileOutputStream out = new FileOutputStream("f:/Java/文件/d.dat");
FileOutputStreamout = new FileOutputStream("f:/Java/文件/d.dat",true);
//追加方式写入
File file1 = new File("f:/Java/文件/d.dat");
FileOutputStream out = new FileOutputStream(file1);
File file1 = new File("f:/Java/文件/d.dat");
FileOutputStream out = new FileOutputStream(file1,true);//追加方式写入
}
catch(IOException e) {
e.printStackTrace();
}
- 指定的文件可以不存在，文件不存在可以自动创建，但是文件的目录必须存在，目录不存在时异常IOException
true的追加
- 当没有写true时，每次向文件中写入内容就会覆盖以前的内容
- 当写了true追加方法时，每次就是在文件的存在的后面继续添加内容，并不会覆盖。
2.5.1.2方法
out.write(int i)
*void java.io.FileOutputStream.write(int b) throws IOException
只能写入int型数据。
- 将i的最低1个字节输出到文件，其他3个字节舍弃。
*int型数据分配的空间是4个字节
2.5.2（FileInputStream）
2.5.2.1构造方法
try {
//FileInputStream fis = new FileInputStream("f:/Java/文件/d.dat");
File file1 = new File("f:/Java/文件/d.dat");
FileInputStream in = new FileInputStream(file1);
}
catch(IOException e) {
e.printStackTrace();
}
- 指定的文件文件必须存在，文件不存在时异常IOException类下的FileNotFoundException异常。
2.5.2.2方法
int i=in.read();
while(i!=-1){//当读到文件的最后一个字节时，返回-1；
System.out.println(i);
i=in.read();//读取下一个字节
}
- public int read（） 方法是一个一个字节的读取，当读取到末尾时返回-1，
- 这个语句会产生非运行期的异常IOException。
2.5.3复制文件
package chapterStream;
import java.io.*;
public class CopyPNG {
//复制图片文件
public static void main(String[] args){
try {
//创建输入流，读取文件
FileInputStream in=new FileInputStream("f:/Java/文件/a.png");
//创建输出流，复制文件
FileOutputStream out=new FileOutputStream("f:/Java/文件/b.png");
//读取文件的第一个字节
int i=in.read();
//只要能读到字节，就循环
while(i!=-1){
out.write(i);//向输入流中输出字节
i=in.read();//读取下一个字节
}
//关包
in.close();
out.close();
System.out.println("文件复制成功！！！");
}
catch(FileNotFoundException e) {//找不到文件的异常处理
e.printStackTrace();
}
catch(IOException e){//异常处理
e.printStackTrace();
}
}
}
2.5.4 字符流到字节流的桥梁（OutputStreamWriter）
2.5.4.1 构造方法
try {
//OutputStreamWriter只能使用一个OutputStream对象做参数
FileOutputStream fos = new FileOutputStream("f:/Java/文件/utf.dat")
OutputStreamWriter out = new OutputStreamWriter(fos);
BufferedWriter bw=new BufferedWriter(out);
//若不添加字符集，则用默认字符集
FileOutputStream fos = new FileOutputStream("f:/Java/文件/utf.dat")
OutputStreamWriter out = new OutputStreamWriter(fos,"UTF-8");
BufferedWriter bw=new BufferedWriter(out);
//指定字符集
}
catch(IOException e) {
e.printStackTrace();
}
为了达到最高的效率，可以将FileOutputStream类内装在BufferedWriter类中
- OutputStreamWriter是字符流到字节流的桥梁，是字符通过指定的字符集编码成字节，输出到指定文件中
- 指定的文件可以不存在，文件不存在可以自动创建，但是文件的目录必须存在，目录不存在时异常IOException
想要实现追加，FileWriter fw = new FileWriter(“f:/Java/文件/e.txt”，true);
2.5.4.2方法
bw.write("hello，world")
*void java.io.Writer.write(String str) throws IOException
只能写入字符串，字符，字符数组，int型。
2.5.5 字节流到字符号流的桥梁（IntputStreamWriter）
2.5.5.1构造方法
try {
FileInputStream fis = new FileInputStream("f:/Java/文件/utf.dat")
IntputStreamWriter in = new IntputStreamWriter(fis);
BufferedReader br = new BufferedReader(in);
//若不添加字符集，则用默认字符集
FileInputStream fos = new FileInputStream("f:/Java/文件/dat.txt")
IntputStreamWriter in = new IntputStreamWriter(fis,"UTF-8");
BufferedReader br = new BufferedReader(in);
//指定字符集
}
}
catch(IOException e) {
e.printStackTrace();
}
为了达到最高的效率，可以将FileInputStream类内装在BufferedReader类中
- InputStreamWriter是字符流到字节流的桥梁，是字节通过指定的字符集编码成字符，输入到程序中.
- 指定的文件文件必须存在，文件不存在时异常IOException类下的FileNotFoundException异常。
2.5.5.2方法
String s=in.readLine();
- public String readLine（） 方法是一行的读取。
- 这个语句会产生非运行期的异常IOException。
2.5.6（DateOutputStream）
与FileOutputStream方法不同的是，数据会以分配到的字节空间去输出，并不会舍去字节。
2.5.6.1 构造方法
try {
//DateOutputStream只能使用一个OutputStream对象做参数
FileOutputStream fos = new FileOutputStream("f:/Java/文件/num.dat");
DataOutputStream out = new DataOutputStream(fos);
}
catch(IOException e) {
e.printStackTrace();
}
- DataOutputStream是字符串和基础类型编码成字节，输出到指定文件中
- 指定的文件可以不存在，文件不存在可以自动创建，但是文件的目录必须存在，目录不存在时异常IOException
想要实现追加，FileWriter fw = new FileWriter(“f:/Java/文件/e.txt”，true);
2.5.6.2方法
out.writeUTF("Java");//字符串型数据
out.writeDouble(52.2);//浮点型数据
out.writeBoolean(false);//布尔型数据
out.writeInt(66);//整型数据
*能写入字符串，字符，字符数组，基本数据类型，布尔值。
2.5.7 （DateInputStream）
DateInputStream的读取思路
因为DateInputStream的输出方式是按分配到的字节空间输出在文件中
而每个数据类型分配到的字节空间各不相同，所以这就便于DateInputStream
通过字节空间去读取数据。
2.5.7.1构造方法
try {
FileInputStream fis = new FileInputStream("f:/Java/文件/num.dat");
DataInputStream in = new DataInputStream(fis);
}
}
catch(IOException e) {
e.printStackTrace();
}
- 指定的文件文件必须存在，文件不存在时异常IOException类下的FileNotFoundException异常。
2.5.7.2方法
System.out.println(in.readUTF());
System.out.println(in.readDouble());
System.out.println(in.readBoolean());
System.out.println(in.readInt());
......
- 向字节文件中读取数据，读取顺序和写入顺序一致
- public String readUTF()返回字符串
- 这个语句会产生非运行期的异常IOException。
DataInputStream用异常来判断是否读取到文件的最后一行
try {
while(true) {
System.out.print(in.readInt());
}
}
catch (EOFException e) {//如果输入流到达末尾，则异常
System.out.print("文件到达末尾。");
}
输出文件中的内容的前提是文件中只有int型数据,因为readInt()和writeInt()要对应
2.5.8 对象输出流（ObjectOutputStream）
2.5.8.1 构造方法
try {
//ObjectOutputStream只能使用一个OutputStream对象做参数
FileOutputStream fos = new FileOutputStream("f:/Java/文件/num.dat");
ObjectOutputStream oot = new ObjectOutputStream(fos);
}
catch(IOException e) {
e.printStackTrace();
}
- ObjectOutputStream是对象输出到指定文件中
- 指定的文件可以不存在，文件不存在可以自动创建，但是文件的目录必须存在，目录不存在时异常IOException
想要实现追加，FileWriter fw = new FileWriter(“f:/Java/文件/e.txt”，true);
2.5.8.2方法
//实例对象
Student stu = new Student("001","张三",20);
//向文件中写入
oot.writeObject(stu);
*只能写入对象(对象的引用量)。
实例化的类必须要有接口Serializable
- Serializable接口中没有定义抽象方法，也没有定义常量
package chapterStream;
import java.io.Serializable;
public class Student implements Serializable{//类实现implements Serializable接口则可以向文件中写入对象
//设置私有成员变量
private String id;
private String name;
private int age;
//定义有参的构造方法
Student (String id,String name,int age){
this.age=age;
this.id=id;
this.name=name;
}
//重写tostring方法
public String toString() {
return id+"\t"+name+"\t"+age;
}
}
2.5.9 对象输入流（ObjectInputStream）
2.5.9.1构造方法
try {
FileInputStream fis = new FileInputStream("f:/Java/文件/num.dat");
ObjectInputStream oit = new ObjectInputStream(fis);
}
}
catch(IOException e) {
e.printStackTrace();
}
- 指定的文件文件必须存在，文件不存在时异常IOException类下的FileNotFoundException异常。
2.5.9.2方法
stu = (Student)oit.readObject();//从文件中读取文件，并要强转为student类
- 这个语句会产生非运行期的异常IOException。
- 在读取对象时会有异常ClassNotFoundException
**DataInputStream
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
