aFile_FileDemo01
package com.se.aFile;
/**
* 绝对路径与相对路径的说明:
* 1.当前工作空间是 /home/user/michael/
*
* 需求1: 访问 /home/user/michael/file1.txt
* 相对路径: file1.txt
* 绝对路径: /home/user/michael/file1.txt
*
* 需求2: 访问 /home/user/michael/doc/file1.txt
* 相对路径: doc/file1.txt
* 绝对路径: /home/user/michael/doc/file1.txt
*
* 需求3: 访问 /home/user/lucy/file1.txt
* 相对路径: ../lucy/file1.txt
* 绝对路径: /home/user/lucy/file1.txt
*
* 需求4: 访问 /home/user/lucy/doc/file1.txt
* 相对路径: ../lucy/doc/file1.txt
* 绝对路径: /home/user/lucy/doc/file1.txt
*/
public class FileDemo01 {
}
aFile_FileDemo02
package com.se.aFile;
import java.io.File;
/**
* File的常用构造器
* 1. 如果我们想在程序中来描述或者操作磁盘上的一个文件或者文件夹，可以使用File类型
* 2. File类型位于java.io包下
* 3. File可以新建，删除，移动，修改，重命名文件或者文件夹，也可以对文件或者文件夹的属性
* 进行访问。但是不能对文件的内容进行访问(读和写)。
* 4. 常用构造器
* File(String pathname)
* File(String parent,String child)
* File(File parent,String child)
*
* 构造器只负责用来接收程序员传入的路径，并不好校验这个路径是否真实存在。
*/
public class FileDemo02 {
public static void main(String[] args) {
//使用File类型来描述一个文件夹 D盘的下dir1文件夹
// File file = new File("D:\\dir1");
File file = new File("D:" + File.separator + "dir1");
boolean result = file.exists();
if (result) {
System.out.println("D盘下dir1文件夹存在");
} else {
System.out.println("D盘下dir1文件夹不存在");
}
//调用构造器File(String parent,String child)
File file1 = new File("D:/code", "a.txt");
System.out.println(file1.exists()); //false
//调用构造器File(File parent,String child)
File parent = new File("D:/code");
File file2 = new File(parent, "a.txt");
System.out.println(file2.exists());
}
}
aFile_FileDemo03
package com.se.aFile;
import java.io.File;
/**
* 文件属性的相关方法
*/
public class FileDemo03 {
public static void main(String[] args) {
//使用一个File构造器来描述一个文件夹
File file = new File("H:/c/ms.txt");
System.out.println("文件名称：" + file.getName());
System.out.println("文件绝对路径：" + file.getAbsolutePath());
System.out.println("文件父路径：" + file.getParent());
System.out.println("文件路径：" + file.getPath());
System.out.println("是否是一个文件：" + file.isFile());
System.out.println("是否是一个文件夹：" + file.isDirectory());
System.out.println("该文件是否是隐藏文件：" + file.isHidden());
System.out.println("该文件是否可读：" + file.canRead());
System.out.println("该文件是否可写：" + file.canWrite());//可写，一定是可读
System.out.println("该文件是否可执行：" + file.canExecute());//可执行，一定可读
System.out.println("最后一次修改时间：" + file.lastModified());
System.out.println("文件大小：" + file.length());
}
}
aFile_FileDemo04
package com.se.aFile;
import java.io.File;
import java.io.FilenameFilter;
import java.util.Arrays;
/**
* 文件查询，检索的相关方法
* String[] list(): 返回指定文件夹里的子文件或者子目录的名字
* File[] listFiles(): 返回指定文件夹里的子文件或者子目录的File对象
*/
public class FileDemo04 {
public static void main(String[] args) {
//使用一个File构造器来描述一个文件夹
File file = new File("H:/c");
String[] list = file.list();
for (String s : list) {
System.out.println(s);
}
System.out.println("--------------------------------------");
File[] files = file.listFiles();
for (File file1 : files) {
System.out.println(file1.getName() + " " + file1.getAbsolutePath());
}
System.out.println("--------------------------------------");
//使用lambda表达式
FilenameFilter filter = (File dir, String name) -> !name.endsWith(".java");
//重写accept方法:编写过滤逻辑，
//name指的就是文件夹里的每一个文件或文件夹dir就是要操作的那个文件列表(文件夹)
String[] list1 = file.list(filter);
for (String s : list1) {
System.out.println(s);
}
File[] files1 = file.listFiles(filter);
System.out.println(Arrays.toString(files1));
}
}
aFile_FileDemo05
package com.se.aFile;
import java.io.File;
/**
* File的新建，删除
*/
public class FileDemo05 {
public static void main(String[] args) {
//使用File来描述磁盘上的一个文件夹
File dir1 = new File("D:/dir1");
if (!dir1.exists()) {
//创建文件夹
dir1.mkdir();
}
//此时，dir1一定存在 在dir1里创建一个file1.txt的文件
File file1 = new File(dir1, "file1.txt");
if (!file1.exists()) {
try {
file1.createNewFile();
} catch (Exception e) {
e.printStackTrace();
}
//此时，file1一定存在
}
}
}
aFile_FileDemo06
package com.se.aFile;
import java.io.File;
/**
* 文件夹的多层级创建。
* 1. mkdir()方法只能创建一级文件夹，
* 2. mkdirs()方法可以创建多级文件夹。
*/
public class FileDemo06 {
public static void main(String[] args) {
File file = new File("H:/c/");
if (!file.exists()) {
file.mkdirs();
}
//重命名
File file1 = new File("H:/dir11/dir22/dir33");
if (file1.exists()) {
file1.renameTo(new File("H:/dir11/dir22/dir33"));
}
//通过renameTo(File file)方法移动文件
File file2 = new File("H:/dir11/dir22/dir33/a.txt");
File file3 = new File("H:/dir11/dir22/a.txt");
if (file2.exists()) {
file2.renameTo(file3);
}
}
}
aFile_FileDemo07
package com.se.aFile;
import java.io.File;
/**
* File的删除功能
* 1. delete方法只能删除空文件夹
* 2. delete如果想要删除非空文件夹，需要把里面删除干净才能删除
*/
public class FileDemo07 {
public static void main(String[] args) {
File file = new File("H:/dir11/dir22/dir33");
if (file.exists()) {
boolean f = file.delete();
System.out.println(f);
}
//测试
File f = new File("H:/dir11");
delete(f);
}
// 递归方法删除指定的文件夹
public static void delete(File file) {
if (!file.exists()) {
throw new RuntimeException("要删除的文件或者文件夹不存在");
}
if (file.isDirectory()) {
//获取文件夹里的内容 文件或文件夹
File[] files = file.listFiles();
//遍历每一个文件夹或者文件
for (File f : files) {
delete(f);
}
}
//if执行完，如果是文件夹，内容请看，并删除空文件夹
//如果不是文件夹，文件之间删除
file.delete();
}
}
bFile_FileInputStream02
package com.se.bFileStream;
import java.io.FileInputStream;
import java.io.IOException;
/**
* FileInputStream:
* 1. 是InputStream抽象类的子类型
* 2. 是一个低级流，用于连接文件和程序
* 3. 常用构造器
* FileInputStream(String pathname)
* FileInputStream(File file)
*/
public class FileInputStream02 {
public static void main(String[] args) {
FileInputStream fis = null;
try {
fis = new FileInputStream("D:/file1.txt");
//读取一个字节
int ch = fis.read();
System.out.println((char)ch);
for (int i = 0; i < 10; i++){
//交互次数多
ch = fis.read();
System.out.println((char)ch);
}
//提前创建一个10个长度的byte数组
byte[] bs = new byte[10];
//将数据读入数组中
int length = -1;
while((length=fis.read(bs)) != -1){//大大减少了和磁盘的交互次数
String str = new String(bs, 0, length);
System.out.println(new String(str));
}
} catch (IOException e) {
throw new RuntimeException(e);
} finally {
try {
fis.close();
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}
}
bFile_FilePutOutStream01
package com.se.bFileStream;
import java.io.FileOutputStream;
/**
* 文件输出流：
* 1. 是OutPutStream的子类型
* 2. 是低级流(节点流)，用于连接文件和程序
* 3. 常用的构造器
* FileOutputStream(File file)：将原有的内容覆盖
* FileOutputStream(String pathname)： 将原有的内容覆盖
* FileOutputStream(File file, boolean append)： 有追加效果
* FileOutputStream(String pathname, boolean append)： 有追加效果
* 4. 输出流不会帮助我们创建不存在的文件夹，但是文件不存在会帮我们创建出来
*
*/
public class FileOutPutStream01 {
public static void main(String[] args) {
//向D:的file1.txt里写东西
FileOutputStream fos = null;
try {
fos = new FileOutputStream("D:/file1.txt");
//追加模式的构造器
// fos = new FileOutputStream("D:/file1.txt", true);
//写一个A
fos.write(65);
//将B~Z写入文件
for (int i = 66; i <= 90; i++) {
//注意，没写一次都会与磁盘交互一次，次数越多，性能越差
fos.write(i);
}
//将"hello world"写入文件中
byte[] bytes = "hello world".getBytes("utf-8");
// fos.write(bytes);
fos.write(bytes, 0, 7);
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
fos.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
cBuffered_BufferedInPutStream01
package com.se.cBuffered;
import java.io.BufferedInputStream;
import java.io.FileInputStream;
/**
* 字节缓冲输出流：
* 1. 是一个高级流，内部维护着一个缓冲区，默认缓冲区大小为8KB
* 2. 在读取文件中的数据时，一次性尽可能读取到缓冲区大小的字节
* 3. read方法从缓冲区中读取数据，当缓冲区中的数据被读取完时，再从磁盘中读取数据，存入缓冲区
* 4. 常用构造器：
* BufferedInputStream(InputStream is)
* BufferedInputStream(InputStream is, int size)
*/
public class BufferedInPutStream01 {
public static void main(String[] args) {
BufferedInputStream bis = null;
try {
bis = new BufferedInputStream(
new FileInputStream("D:/file1.txt"), 10);
//读取一个字节
int ch = bis.read();
System.out.println((char) ch);
//读取多个字节
byte[] bs = new byte[10];
int len = -1;
//读到文件末尾，返回-1
while ((len = bis.read(bs)) != -1) {
String str = new String(bs, 0, len);
System.out.println(str);
}
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
bis.close();
} catch (Exception ex) {
throw new RuntimeException(ex);
}
}
}
}
cBuffered_BufferedOutPutStream01
package com.se.cBuffered;
import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/**
* 字节缓冲输出流： BufferedOutputStream
* 1. 内部维护了一个字节数组作为缓冲区(缓存)： 默认值是8KB
* 2. 我们写入数据的时候，先写到缓冲区，当缓冲区满了再一次性写入磁盘
* 从而减少了与磁盘的交互次数，提高了写出效率。
* 3. 最后一次写入到缓存之后，有可能没有装满，可以调用flush方法，将其强制写入磁盘
* 4. 构造器：
* BufferedOutputStream(OutputStream os)
* BufferedOutputStream(OutputStream os, int size)： size用于自定义缓冲区的大小
*/
public class BufferedOutPutStream01 {
public static void main(String[] args) {
BufferedOutputStream bos = null;
FileOutputStream fos = null;
try {
fos = new FileOutputStream("D:/file2.txt", true);
bos = new BufferedOutputStream(fos);
//将A写入缓冲区
bos.write('A');
//将"hello world"写入缓冲区
byte[] bytes = "hello world".getBytes("utf-8");
// bos.write(bytes);
bos.write(bytes,0,bytes.length);
bos.flush(); //即使没有关闭流，也会强制冲刷缓冲区
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
//多个流的关闭顺序，应先关闭高级流，在关闭低级流
//不过可以直接关闭高级流
bos.close(); //高级
fos.close(); //低级
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}
}
dData_DataInPutStreamDemo01
package com.se.dData;
import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.IOException;
public class DataInPutStreamDemo01 {
public static void main(String[] args) {
try (DataInputStream dis = new DataInputStream(
new FileInputStream("D:/file3.txt"))) {
int nums = dis.readInt();
double v = dis.readDouble();
boolean b = dis.readBoolean();
String s = dis.readUTF();
System.out.println(nums);
System.out.println(v);
System.out.println(b);
System.out.println(s);
} catch (IOException e) {
e.printStackTrace();
}
}
}
dData_DataOutPutStreamDemo01
package com.se.dData;
import java.io.DataOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/**
* 数据输入输出流，是字节过滤流的子类型，其拓展了一些功能，
* 可以直接书写基本数据类型和字符串类型
*/
public class DataOutPutStreamDemo01 {
public static void main(String[] args) {
//将流的创建写到try模块的小括号中，自动关闭
try (DataOutputStream dos =
new DataOutputStream(
new FileOutputStream("D:/file.txt"))) {
dos.writeInt(10);//四个字节
dos.writeDouble(3.14);//八个字节
dos.writeBoolean(true);//一个字节
dos.writeUTF("你是最棒的");//字符串 十五个字节 每写一次UTF的字符串会使用两个字符记录长度
} catch (IOException e) {
e.printStackTrace();
}
}
}