文章目录
1.file
1.File类的概述和构造方法
File:它是文件和目录路径名的抽象表示
- 文件和目录是可以通过File封装成对象的
- 对于File而言,其封装的并不是一个真正存在的文件,仅仅是一个路径名而已。它可以是存在的,也可以是不存在的。将来是要通过具体的操作把这个路径的内容转换为具体存在的。
方法名 | 说明 |
---|---|
File(String pathname) | 通过将给定的路径名字符串转换为抽象路径名来创建新的 File 实例 |
File(String parent, String child) | 从父路径名字符串和子路径名字符串创建新的 File 实例1 |
File(File parent, String child) | 从父抽象路径名和子路径名字符串创建新的 File 实例 |
package com.study_01;
import java.io.File;
public class FileDemo01 {
public static void main(String[] args) {
// File(String pathname):通过将给定的路径名字符串转换为抽象路径名来创建新的File实例。
File f1 = new File("D:\\C-Java\\S-study\\biliHeiMa\\myFile\\src\\fileTest\\java.txt");
System.out.println(f1);
// File(String parent,String child):从父路径名字符串和子路径名字符串创建新的File实例。
File f2 = new File("D:\\C-Java\\S-study\\biliHeiMa\\myFile\\src\\fileTest","java.txt");
System.out.println(f2);
// File(File parent,String child):从父抽象路径名和子路径名字符串创建新的File实例。
File f3 = new File("D:\\C-Java\\S-study\\biliHeiMa\\myFile\\src\\fileTest");
File f4 = new File(f3,"java.txt");
System.out.println(f4);
}
}
===输出===
D:\C-Java\S-study\biliHeiMa\myFile\src\fileTest\java.txt
D:\C-Java\S-study\biliHeiMa\myFile\src\fileTest\java.txt
D:\C-Java\S-study\biliHeiMa\myFile\src\fileTest\java.txt
2.File类创建功能
package com.study_01;
import java.io.File;
import java.io.IOException;
public class FIleDemo02 {
public static void main(String[] args) throws IOException {
// 创建文件 ---必修要有fileTest目录,因为creatFile只能创建文件
File f1 = new File("D:\\C-Java\\S-study\\biliHeiMa\\myFile\\src\\fileTest\\java.txt");
System.out.println(f1.createNewFile());
System.out.println("-----");
// 创建目录
File f2 = new File("D:\\C-Java\\S-study\\biliHeiMa\\myFile\\src\\fileTest\\javaSE");
System.out.println(f2.mkdir());
System.out.println("-----");
// 创建多级目录
File f3 = new File("D:\\C-Java\\S-study\\biliHeiMa\\myFile\\src\\fileTest\\javaWeb\\Html");
// System.out.println(f3.mkdir());
System.out.println(f3.mkdirs());
File f4 = new File("D:\\C-Java\\S-study\\biliHeiMa\\myFile\\src\\fileTest\\javaSE.txt");
// System.out.println(f4.mkdir());
System.out.println(f4.createNewFile());
}
}
===输出===
true
-----
true
-----
true
true
package com.study_01;
import java.io.File;
import java.io.IOException;
public class FileDemo03 {
public static void main(String[] args) throws IOException {
// File f1 = new File("D:\\C-Java\\S-study\\biliHeiMa\\myFile\\src\\fileTest\\java.txt");
// 需求一:在当前模块目录下创建java.txt文件
File f1 = new File("java.txt");
System.out.println(f1.createNewFile());
// 需求2:删除当前模块目录下创建的java.txt文件
System.out.println(f1.delete());
System.out.println("---------");
// 需求3:在当前模块下创建itcast目录
File f2 = new File("itcast");
// System.out.println(f2.mkdir());
// 需求4:删除当前模块下创建itcast目录
System.out.println(f2.delete());
System.out.println("---------");
// 需求5:在当前模块下创建itcast目录,在该目录下创建文件java.txt
File f3 = new File("itcast");
System.out.println(f3.mkdir());
File f4 = new File("itcast\\java.txt");
System.out.println(f4.createNewFile());
// 需求6:删除当前模块下的目录itcast
System.out.println(f4.delete());
System.out.println(f3.delete());
}
}
3.File类判断和获取功能
package com.study_01;
import java.io.File;
import java.io.IOException;
public class FileDemo04 {
public static void main(String[] args) throws IOException {
// 创建一个File对象
File f = new File("src\\fileTest\\java.txt");
System.out.println(f.isDirectory());
System.out.println(f.isFile());
System.out.println(f.exists());
System.out.println(f.getAbsoluteFile());
System.out.println(f.getPath());
System.out.println(f.getName());
System.out.println("--------");
// 遍历D盘的文件及目录
File f2 = new File("D:\\");
String[] str = f2.list();
for (String s : str) {
System.out.println(s);
}
System.out.println("-------");
// 遍历D盘的文件
File[] fileArray = f2.listFiles();
for (File file : fileArray) {
// System.out.println(file);
// System.out.println(file.getName());
if(file.isFile()) {
System.out.println(file.getName());
}
}
}
}
===输出===
false
true
true
D:\C-Java\S-study\biliHeiMa\myFile\src\fileTest\java.txt
src\fileTest\java.txt
java.txt
--------
遍历内容
--------
遍历内容
4.File类删除功能
绝对路径和相对路径的区别
- 绝对路径:完整的路径名,不需要任何其他信息就可以定位它所表示的文件。例如:E:\Vitcast\java.txt
- 相对路径:必须使用取自其他路径名的信息进行解释。例如:myFile\java.txt
5.递归
6.递归阶乘
7.遍历目录
package com.study_01;
import java.io.File;
import java.io.FileInputStream;
public class DiGUiDemo {
public static void main(String[] args) {
// 根据指定目录创建一个File对象
// File f1 = new File("D:\\C-Java\\S-study\\biliHeiMa\\myFile\\src");
File f1 = new File("D:\\C-Java\\S-study\\biliHeiMa");
getAllFile(f1);
}
// 定义一个方法
public static void getAllFile(File srcFile) {
// 获取给定路径的目录文件对象数组
File[] fileArray = srcFile.listFiles();
/
if (fileArray != null) {
for (File file : fileArray) {
// 如果是目录就进行递归
if (file.isDirectory()) {
getAllFile(file);
} else {
System.out.println(file);
}
}
}
}
}
2.字节流
8.IO流概述和分类
IO流概述:
- IO :输入/输出(Input/Output)
- 流:是一种抽象概念,是对数据传输的总称。也就是说数据在设备间的传输称为流,流的本质是数据传输
IO流分类:
-
按照数据的流向
- 输入流:读数据
- 输出流:写数据
-
按照数据类型来分
- 字节流
- 字节输入流;字节输出流
- 字符流
- 字符输入流;字符输出流
- 字节流
一般来说,我们说IO流是按照数据类型来分的
那么这两种流都在什么情况下使用呢?
- 如果数据通过Window自带的记事本软件打开,我们还可以读懂里面的内容,就使用字符流,否则使用字节流。如果你不知道该使用哪种类型的流,就使用字节流
9.字节流写数据
字节流抽象基类
- InputStream:这个抽象类是表示字节输入流的所有类的超类
- OutputStream:个抽象类是表示字节输出流的所有类的超类
- 子类名特点:子类名称都是以其父类名作为子类名的后缀
FileOutputStream:文件输出流用于将数据写入File
- FileOutputStream(String name):创建文件输出流以指定的名称写入文件
使用字节输出流写数据的步骤:
- 创建字节输出流对象(调用系统功能创建了文件,创建字节输出流对象,让字节输出流对象指向文件)
- 调用字节输出流对象的写数据方法
- 释放资源(关闭此文件输出流并释放与此流相关联的任何系统资源
package com.study_01;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class FileOutputStreamDemo01 {
public static void main(String[] args) throws IOException {
// 创建字节输出流对象
// FileOutputStream(Strin gname):创建文件输出流以指定的名称写入文件
FileOutputStream fos = new FileOutputStream("fos.txt");
/*
做了三件事
A:调用了系统功能创建了文件
B:创建了字节输出流对象
C:让字节输出流对象指向创建好的文件
*/
fos.write(97);// a
// fos.write(57);// 9
// fos.write(55);// 7
// 最后都要释放资源
// void close():关闭此文件输出流与释放与此流相关的任何系统资源
fos.close();
}
}
package com.study_01;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
/*
public FileOutputStream(String name,boolean append)
创建文件输出流以指定的名称写入文件。 如果第二个参数为true ,则字节将写入文件的末尾而不是开头
可以理解为续写
*/
public class FileOutputStreamDemo03 {
public static void main(String[] args) throws IOException {
// 床架字节输出对象
FileOutputStream fos = new FileOutputStream("fos.txt",true);
// 写数据
for (int i = 0; i < 10; i++) {
fos.write("hello".getBytes());
fos.write("\n".getBytes());
}
// 释放资源
fos.close();
}
}
10.字节流写入的三种方式
package com.study_01;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
public class FileOutputStreamDemo02 {
public static void main(String[] args) throws IOException {
// FileOutputStream(String name):创建文件输出流以指定的名称写入文件
FileOutputStream fos = new FileOutputStream("fos.txt");
// new File(name)
// FileOutputStream fos = new FileOutputStream(new File("fos.txt"));
// FileOutputStream(File file):创建文件输出流以写入有指定的File对象表示的文件
// File file = new File("fox.txt");
// FileOutputStream fos2 = new FileOutputStream(file);
// FileOutputStream fos2 = new FileOutputStream(new File("fos.txt"));
// void write(int b)
// fos.write(97);
// fos.write(98);
// fos.write(99);
// fos.write(100);
// fos.write(101);
// void writ(byte[] b)
// byte[] bys = {97,98,99,100,101};
// bytep[] getBytes (): 返回字符串对应的自己数组1
byte[] bys = "abcde".getBytes();
// fos.write(bys);
// void write(byte[] b, int off, int len) 从指定的字节数组写入 len字节,从偏移量 off开始输出到此输出流。
fos.write(bys,0,3);
fos.close();
}
}
11.字节流写数据两个小问题
字节流写数据如何实现换行呢?
-
写完数据后,加换行符
-
windows:\r\n
-
linux:\n
-
mac:\r
字节流写数据如何实现追加写入呢?
- public FileOutputStream(String name,boolean append)
- 创建文件输出流以指定的名称写入文件。如果第二个参数为true,则字节将写入文件的末尾而不是开头
12.字节流写数据加异常处理
package com.study_01;
import java.io.FileOutputStream;
import java.io.IOException;
public class FileOutputStreamDemo04 {
public static void main(String[] args) {
// try {
// FileOutputStream fos = new FileOutputStream("fos.txt");
// fos.write("hello".getBytes());
// fos.close();
// } catch (IOException e) {
// e.printStackTrace();
// }
FileOutputStream fos = null;
try {
fos = new FileOutputStream("fos.txt");
System.out.println(fos);
fos.write("hello".getBytes());
} catch (IOException e) {
e.printStackTrace();
} finally {
if (fos != null) {
try {
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
13.字节流读数据
需求:把文件fos.txt中的内容读取出来在控制台输出
FilelnputStream:从文件系统中的文件获取输入字节
- FilelnputStream(String name):通过打开与实际文件的连接来创建一个FilelnputStream,该文件由文件系统中的路径名name命名
使用字节输入流读数据的步骤:
①创建字节输入流对象
②调用字节输入流对象的读数据方法
③释放资源。
package com.study_02;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
public class FileIntputStreamDemo01 {
public static void main(String[] args) throws IOException {
// 创建字节输入流对象
// FileInputStream(String name)
FileInputStream fis = new FileInputStream("fos.txt");
// 调用字节输入流对象的读数据方法
// int read() 从该输入流读取一个字节的数据
/*
// 第一次读取数据
int by = fis.read();
System.out.println(by);
System.out.println((char) by);
// 第二次
by = fis.read();
System.out.println(by);
System.out.println((char) by);
// 再多读取两次
by = fis.read();
System.out.println(by);
by = fis.read();
System.out.println(by);
*/
// int by = fis.read();
// while (by != -1) {
// System.out.print((char) by);
// by = fis.read();
// }
// 优化上面程序
int by;
while ((by=fis.read())!=-1){
System.out.print((char) by);
}
// 释放资源
fis.close();
}
}
14.复制文本文件
// 根据数据源创建字节输入流对象
FileInputStream fis = new FileInputStream("散文.txt");
// 根据目的地创建字节输出流对象
FileOutputStream fos = new FileOutputStream("散文2.txt");
int by;
while ((by=fis.read())!=-1) {
fos.write(by);
}
fos.close();
fis.close();
15.字节流读数据(一次读一个字节数组数据)
package com.study_02;
import java.io.FileInputStream;
import java.io.IOException;
public class FileIntputStreamDemo02 {
public static void main(String[] args) throws IOException {
// 创建字节输入流对象
FileInputStream fis = new FileInputStream("fos.txt");
// 调用字节输入流对象的读数据方法
/*
byte[] bys = new byte[5];
// 第一次读取数据
int len = fis.read(bys);
System.out.println(len);
System.out.println(new String(bys));
// 第二次读取数据
len = fis.read(bys);
System.out.println(len);
System.out.println(new String(bys));
// 第三次读取数据
len = fis.read(bys);
System.out.println(len);
// System.out.println(new String(bys));
System.out.println(new String(bys,0,len));
*/
/*
hello\n
world\n
第一次:hello
第二次:\r\nwor
第三次:ld\r\nr
*/
byte[] bys = new byte[1024]; // 1024及整数倍数
int len;
while ((len = fis.read(bys))!=-1){
System.out.print(new String(bys,0,len));
}
fis.close();
}
}
16.字节流复制图片
package com.study_02;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class FileIntputStreamDemo03 {
public static void main(String[] args) throws IOException {
FileInputStream fis = new FileInputStream("t.jpg");
FileOutputStream fos = new FileOutputStream("ttt.jpg");
byte[] bys = new byte[1024];
int len;
while ((len=fis.read(bys))!=-1){
fos.write(bys,0,len);
}
fos.close();
fis.close();
}
}
1.字节缓冲流
为了提高效率,举个例子,一开始骑自行车送快递,一次只能送一个,后面配了一辆五菱宏光,一次可以送十几件
- BufferOutputStream:该类实现缓冲输出流。通过设置这样的输出流,应用程序可以向底层输出流写入字节,而不必为写入的每个字节导致底层系统的调用
- BufferedlnputStream:创建BufferedlnputStream将创建一个内部冲区数组。当从流中读取或跳过字节时,内部缓冲区将根据需要从所包含的输入流中重新填充,一次很多字节
构造方法:
- 字节缓冲输出流:BufferedOutputStream(OutputStream out)
- 字节缓冲输入流:BufferedlnputStream(InputStream in)
为什么构造方法需要的是字节流,而不是具体的文件或者路径呢?
- 字节缓冲流仅仅提供缓冲区,而真正的读写数据还得依靠基本的字节流对象进行操作
package com.study_03;
import java.io.*;
public class BufferStreamDemo {
public static void main(String[] args) throws IOException {
/*
// 字节缓冲输出流:BufferedOutputStream(OutputStream out)
// FileOutputStream fos = new FileOutputStream("bos.txt");
// BufferedOutputStream bos = new BufferedOutputStream(fos);
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("bos.txt"));
// 写数据
bos.write("hello\r\n".getBytes());
bos.write("hello\r\n".getBytes());
// 释放资源
bos.close();
*/
// 字节缓冲输入流:BufferedInputStream(InputStream in)
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("bos.txt"));
// 一次读取一个字节数据
// int by;
// while ((by = bis.read())!=-1) {
// System.out.print((char) by);
// }
// 一次读取一个字节数组的数据
byte[] bys = new byte[1024];
int len;
while ((len = bis.read(bys))!=-1) {
System.out.print(new String(bys,0,len));
}
bis.close();
}
}
2.字节流复制视频
package com.study_03;
import java.io.*;
/*
四种方式实现复制视频,并记录每种方式复制视频的时间
1:基本字节流一次读写一个字节
2:基本字节流一次读写一个字节数组
3:字节缓冲流一次读写一个字节
4:字节缓冲流一次读写一个字节数组
*/
public class CopyAviDemo {
public static void main(String[] args) throws IOException {
// 记录开始时间
long startTime = System.currentTimeMillis();
// 复制视频
// method1(); // 共耗时:46207毫秒
// method2(); // 共耗时:142毫秒
// method3(); // 共耗时:155毫秒
method4(); // 共耗时:36毫秒
// 记录结束时间
long endTime = System.currentTimeMillis();
System.out.println("共耗时:" + (endTime - startTime) + "毫秒");
}
// 1:基本字节流一次读写一个字节
private static void method1() throws IOException {
FileInputStream fis = new FileInputStream("Airport.mp4");
FileOutputStream fos = new FileOutputStream("视屏复制.mp4");
int by;
while ((by = fis.read()) != -1) {
fos.write(by);
}
fos.close();
fis.close();
}
// 2:基本字节流一次读写一个字节数组
private static void method2() throws IOException {
FileInputStream fis = new FileInputStream("Airport.mp4");
FileOutputStream fos = new FileOutputStream("视屏复制.mp4");
byte[] bys = new byte[1024];
int len;
while ((len = fis.read(bys)) != -1) {
fos.write(bys, 0, len);
}
fos.close();
fis.close();
}
// 3:字节缓冲流一次读写一个字节
private static void method3() throws IOException {
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("Airport.mp4"));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("视屏复制.mp4"));
int by;
while ((by= bis.read())!=-1){
bos.write(by);
}
bos.close();
bis.close();
}
// 4:字节缓冲流一次读写一个字节数组
private static void method4() throws IOException {
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("Airport.mp4"));
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("视屏复制.mp4"));
byte[] bys = new byte[1024];
int len;
while ((len=bis.read(bys))!=-1) {
bos.write(bys,0,len);
}
bos.close();
bis.close();
}
}