一. File类
1.1 概述File类是http://java.io包很重要的一个类;
File类的对象可以表示文件,也可以是目录。
File对象只可以对文件或目录的属性进行操作,不可以操作文件的具体数据,即不能对文件进行读/写操作。
1.2 构造方法
(1) parent, child)
从父抽象路径名和子路径名字符串创建新的 File实例。
(2)pathname)
通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例。
(3) parent, child)
从父路径名字符串和子路径名字符串创建新的 File实例。
(4) uri)
通过将给定的 file: URI转换为抽象路径名来创建新的 File实例。
代码案例:
//创建文件的方法
public class CreateFile {
public static void main(String[] args) {
// 创建文件对象。
File file = new File("D:/FileDemo/FileDemo.txt");
// 创建文件
if (!file.exists()) {
try {
if (file.createNewFile()) {
System.out.println("文件创建成功");
} else {
System.out.println("文件创建失败");
}
} catch (IOException e) {
e.printStackTrace();
}
} else {
System.out.println("文件已存在");
}
}
}
//创建目录的方法
import java.io.File;
public class CreateDirectory {
public static void main(String[] args) {
File file = new File("D:\\FileDemo");
if (!file.exists()) {
if (file.mkdirs()) {
System.out.println("创建成功");
} else {
System.out.println("创建目录失败");
}
} else {
System.out.println("目录已存在,创建失败");
}
}
}
1.3 常用方法
遍历方法:
//遍历方法
import java.io.File;
public class FileList{
public static void main(String[] args) {
// 创建目录对象。
File file = new File("E:\\");
// 使用list方法
String[] fileNameList = file.list();
// 遍历目录数组
for (String s : fileNameList) {
System.out.println(s);
}
System.out.println("------------------------------------");
// 使用listFiles方法
File[] fileList = file.listFiles();
for (File f : fileList) {
System.out.println(f.getAbsolutePath());
}
}
}
1.4 FileFilter文件过滤器
1.4.1 两个作用:
(1)过滤不符合规格的文件名文件名过滤器接口:interface FilenameFilter
需重写accept方法自定义过滤规则boolean accept(File dir, String name)
-- dir:表示文件的当前目录。
-- name:表示当前目录的子目录或者文件的名字。File类中提供了使用文件名过滤器遍历目录的方法String[] list(FilenameFilter filter)
-- 把满足指定过滤条件的文件和目录,返回到String数组中。
File[] listFiles(FilenameFilter filter)
-- 把满足指定过滤条件的文件和目录,返回到File数组中。
(2)常用于检测文件是否存在文件过滤器接口:interface FileFilter
需重写accept方法自定义过滤规则,如下:boolean accept(File pathName)
-- pathName:表示当前目录的子目录或者文件的名字。File类中提供了使用文件过滤器遍历目录的方法:File[] listFiles(FilenameFilter filter)
-- 把满足指定过滤条件的文件和目录,返回到File数组中。
代码演示:
public class FileFilterDemo {
public static void main(String[] args) {
//创建目录对象
File dir = new File("D:\\FileDemo");
//使用"匿名内部类"的方式创建过滤器
FileFilter filter = new FileFilter() {
@Override
public boolean accept(File file) {
return file.getName().toLowerCase().endsWith(".txt");
}
};
File[] files = dir.listFiles(filter);
for (File file : files) {
System.out.println(file);
}
}
}
二. 输入流与输出流
类:InputStream、OutputStream、Reader、Writer
2.1 流按着数据的传输方向分为:输入流:往内存中读叫输入流。
输出流:从内存中往外写叫输出流。
(1)所有输入流都是InputStream类或者Reader类的子类。类名以InputStream结尾的类都是InputStream的子类。
类名以Reader结尾的类都是Reader类的子类。
(3)所有输出流都是OutputStream类或者Writer类的子类。类名以OutputStream结尾的类都是OutputStream的子类。
类名以Writer结尾的类都是Writer类的子类。
2.2 从数据流编码格式上划分为:字节流:处理单元为1个字节
字符流:处理单元为2个字节
(1)InputStream和OutputStream的子类都是字节流可以读写二进制文件,主要处理音频、图片、歌曲、字节流,处理单元为1个字节。
(2)Reader和Writer的子类都是字符流主要处理字符或字符串,字符流处理单元为2个字节。
字节流将读取到的字节数据,去指定的编码表中获取对应文字。
由于上述两种分类都是针对InputStream、OutputStream、Reader、Writer四个类,所以代码案例写在一起
代码案例:
//字节输入流(FileInputStream)
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
public class FileInputStreamDemo {
public static void main(String[] args) {
//建立文件对象 File file=new File("C:\\Users\\25849\\Desktop\\1.txt");
try
{
//建立链接 FileInputStream fileInputStream=new FileInputStream(file);
int n=0;
StringBuffer sBuffer=new StringBuffer();
while (n!=-1) //当n不等于-1,则代表未到末尾 {
n=fileInputStream.read();//读取文件的一个字节(8个二进制位),并将其由二进制转成十进制的整数返回
char by=(char) n; //转成字符
sBuffer.append(by);
}
System.out.println(sBuffer.toString());
}
catch (FileNotFoundException e)
{
System.out.println("文件不存在或者文件不可读或者文件是目录");
}
catch (IOException e)
{
System.out.println("读取过程存在异常");
}
}
}
结果:由于文件存的是字符类型,以字节形式读取,会把原本的字符分解为两个字节,所以乱码了
????¤§???????¤§asfsa???
sdg sgdf???dfhfh
?¤§?????????????????¨é??
?????¨é???????¨é??sf?
//字节输出流(FileOutputStream)
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class FileOutputStreamDemo {
public static void main(String[] args) {
// 建立文件对象File file = new File("C:\\Users\\25849\\Desktop\\1.txt");
try {
String content = "我生来坚强\n只要不死\n我就笑得猖狂";
FileOutputStream out = new FileOutputStream(file, true);
out.write(content.getBytes());
System.out.println("写入成功");
}
catch (FileNotFoundException e) {
System.out.println("文件不存在或者文件不可读或者文件是目录");
} catch (IOException e) {
System.out.println("读取过程存在异常");
}
}
}
结果:
写入成功
在没有实力之前,你要学会比狼能忍
在有了实力之后,你要学会比狼更狠我生来坚强我生来坚强
只要不死
我就笑得猖狂
//字符输入流(FileReader)
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
public class FileReaderDemo2 {
public static void main(String[] args) {
// 建立文件对象File file = new File("C:\\Users\\25849\\Desktop\\1.txt");
try {
// 建立链接FileReader fileReader = new FileReader(file);
int n = 0;
char[] chars = new char[10];
String s ;
while ((n = fileReader.read(chars)) != -1) // 当n不等于-1,则代表未到末尾{
String string = new String(chars,0,n);
System.out.println(string);
}
} catch (FileNotFoundException e) {
System.out.println("文件不存在或者文件不可读或者文件是目录");
} catch (IOException e) {
System.out.println("读取过程存在异常");
}
}
}
//字符输出流(FileWriter)
import java.io.FileWriter;
import java.io.IOException;
public class FileWriterDemo2 {
public static void main(String[] args) {
FileWriter filewriter = null;
try {
filewriter = new FileWriter("C:\\Users\\25849\\Desktop\\1.txt",true);
String content = "abcdefghigklmn";
filewriter.write( content );
} catch (IOException e1) {
e1.printStackTrace();
}finally{
try {
//清空缓存区filewriter.flush();
//关闭“文件字符输出流”filewriter.close();
System.out.println("写入成功!");
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
2.3 从封装类型不同分为:节点流:如果流封装的是某种特定的数据源,如文件、字符串、字符串数组等,则称为节点流。
处理流:如果流封装的是其它流对象,称为处理流。处理流提供了缓冲功能,提高读写效率。
(1)节点流中常用类字节输入流 FileInputStream
字节输出流 FileOutputStream
字符输入流 FileReader
字符输出流 FileWriter
(2)处理流中常用类缓冲字节输出流 BufferedOutputStream
缓冲字节输入流 BufferedInputStream
缓冲字符输入流 BufferedReader
缓冲字符输出流 BufferedWriter
上面的节点流就是之前描述的,在这里着重描述处理流
2.3.1 处理流:
1.缓冲区原理:
-缓冲区的概念。
-缓冲区的作用:要对操作的数据进行临时的缓存,提高了读写效率。
-缓冲区如何提高读写效率。
2.处理流的特点:字符缓冲输入流提供了读取一行的方法readLine() 。
字符缓冲输出流提供了写入一个空行的方法newLine()。
字符缓冲输出流,把写入的数据先写入到内存,再使用flush()方法将内存数据刷到硬盘上。
注意:在使用字符缓冲输出流时,一定先flush(),然后再close(),避免数据的丢失。
代码案例:
//缓冲字节输入处理流(BufferedInputStream)
import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;
public class BufferedInputStreamDemo2 {
public static void main(String[] args) {
FileInputStream fileInputStream = null;
BufferedInputStream bufferedInputStream = null;
try {
fileInputStream = new FileInputStream("C:\\Users\\25849\\Desktop\\1.txt");
bufferedInputStream = new BufferedInputStream(fileInputStream);
byte[] bytes = new byte[16];
int length = 0;
while ((length = bufferedInputStream.read(bytes)) != -1) {
System.out.println(new String(bytes, 0, length));
}
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
bufferedInputStream.close();
System.out.println("读取完成!");
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
//缓冲字节输出处理流(BufferedOutputStream)
import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class BufferedOutputStreamDemo2 {
public static void main(String[] args) {
FileOutputStream fileOutputStream = null;
BufferedOutputStream bufferedOutputStream = null;
try {
fileOutputStream = new FileOutputStream("C:\\Users\\25849\\Desktop\\1.txt");
bufferedOutputStream = new BufferedOutputStream(fileOutputStream);
String content = "abcdefghigklmn";
byte[] bytes = content.getBytes();
bufferedOutputStream.write(bytes);
System.out.println("写入成功!");
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
// 刷新 “缓冲字节输出处理流”
bufferedOutputStream.flush();
// 关闭 “缓冲字节输出处理流”
bufferedOutputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
//缓冲字符输入处理流(BufferedReader)
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
public class BufferedReaderDemo2 {
public static void main(String[] args) {
FileReader fileReader = null;
BufferedReader bufferedReader = null;
try {
fileReader = new FileReader("C:\\Users\\25849\\Desktop\\1.txt");
bufferedReader = new BufferedReader(fileReader);
String content = null;
int length = 0;
while ((content = bufferedReader.readLine()) != null) {
System.out.println(content);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
//关闭 “字符输入处理流”
bufferedReader.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
//缓冲缓冲字符输出处理流(BufferedWriter )
2.4 节点流和处理流速度的对比
//用字节节点流复制一个视频
package com.company.project.homework.h11;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import javax.xml.crypto.Data;
//复制两个视频文件
//字节流
//用节点流
public class Demo2 {
public static void main(String[] args) throws IOException {
long now = System.currentTimeMillis();
FileInputStream fis = new FileInputStream("D:\\ChromeCoreDownloads\\VN1v5.mp4");
FileOutputStream fos ;
File newfile = new File("D:\\ChromeCoreDownloads\\VN1v5ss.mp4");
if(!newfile.exists()) {
newfile.createNewFile();
}
fos = new FileOutputStream(newfile);
byte[] by = new byte[128];
int num = 0 ;
while ((num = fis.read(by)) != -1) {
fos.write(by,0,num);
}
System.out.println("复制完成");
System.out.println("使用时间:" + (System.currentTimeMillis() - now));
fos.close();
fis.close();
}
}
结果:
复制完成
使用时间:203
//用字节处理流复制同一个视频
package com.company.project.homework.h11;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import javax.xml.crypto.Data;
//复制两个视频文件
//字节流
//用处理流
public class Demo {
public static void main(String[] args) throws IOException {
long now = System.currentTimeMillis();
FileInputStream fis = new FileInputStream("D:\\ChromeCoreDownloads\\VN1v5.mp4");
FileOutputStream fos ;
File newfile = new File("D:\\ChromeCoreDownloads\\VN1v5ss.mp4");
if(!newfile.exists()) {
newfile.createNewFile();
}
fos = new FileOutputStream(newfile);
BufferedInputStream bis = new BufferedInputStream(fis);
BufferedOutputStream bos = new BufferedOutputStream(fos);
byte[] by = new byte[128];
int num = 0 ;
while ((num = bis.read(by)) != -1) {
bos.write(by,0,num);
}
System.out.println("复制完成");
System.out.println("使用时间:" + (System.currentTimeMillis() - now));
bos.close();
bis.close();
fos.close();
fis.close();
}
}
结果:
复制完成
使用时间:15
明显速度提升了很多!!!!