IO流：输入输出流
I：intput--->输入
O：output--->输出
File类的使用
File 对象的创建
/*
1、如何创建File类的实例
File(String filePath)
File(String parentPath , String childPath)
File(File parentFile , String childFile)
2、
相对路径:相较于某个路径下，指明的路径
绝对路径:包含盘符在内的路径文件或文件目录的路径
3、路径分隔符
windows：\\
unix：/
*/
@Test
public void test(){
//构造器1：
File file1 = new File("Hello1.txt");//IDEA中 使用单元测试方法测试，相对于当前的 module（若使用main方法，则相对与当前的项目），eclipse中，无论使用什么，相对路径都是在当前目录中
File file2 = new File("F:\\workspace\\IOTest\\Hello2.txt");// 单独一个 ”\“ 有转义的意思，要表示一个 ”\“ 则使用 ”\\“表示。
System.out.println(file1);
System.out.println(file2);
//构造器2：
File file3 = new File("F:\\workspace\\IOTest","IOTest");
System.out.println(file3);
//构造器3：
File file4 = new File(file3,"Hello3.txt");
System.out.println(file4);
}
File 相关方法的使用
/*
public String getAbsolutePath()：获取绝对路径
public String getPath() ：获取路径
public String getName() ：获取名称
public String getParent()：获取上层文件目录路径。若无，返回null
public long length() ：获取文件长度（即：字节数）。不能获取目录的长度。
public long lastModified() ：获取最后一次的修改时间，毫秒值
如下的两个方法适用于文件目录：
public String[] list() ：获取指定目录下的所有文件或者文件目录的名称数组
public File[] listFiles() ：获取指定目录下的所有文件或者文件目录的File数组
*/
@Test
public void test2(){
File file1 = new File("hello1.txt"); //相对路径
File file2 = new File("F:\\workspace\\IOTest\\hello2.txt"); //绝对路径
//hello1.txt 文件存在，相对路径
System.out.println(file1.getAbsolutePath());//F:\workspace\IOTest\hello1.txt
System.out.println(file1.getPath());//hello1.txt
System.out.println(file1.getName());//hello1.txt
System.out.println(file1.getParent());//null
System.out.println(file1.length());//0
System.out.println(new Date(file1.lastModified()));//0
System.out.println("**********************************************");
//hello1.txt 文件不存在，绝对路径
System.out.println(file2.getAbsolutePath());//F:\workspace\IOTest\hello2.txt
System.out.println(file2.getPath());//F:\workspace\IOTest\hello2.txt
System.out.println(file2.getName());//hello2.txt
System.out.println(file2.getParent());//F:\workspace\IOTest
System.out.println(file2.length());//0
System.out.println(file2.lastModified());//0
}
@Test
public void test3(){
//获取指定目录下的所有文件或者文件目录的名称数组
//1、String[] list()
//文件目录存在
File file1 = new File("F:\\workspace\\IOTest");
String[] list = file1.list();
for (String s:list) {
System.out.println(s);//有后缀的为文件，没有后缀的为目录
}
//文件目录不存在
// File file2 = new File("F:\\workspace\\IOTest1");//报错
System.out.println("**************************************************");
//2、File[] listFiles()
File[] files = file1.listFiles();
for (File f:files) {
System.out.println(f);//为绝对路径+文件名
}
}
/*
File类的重命名功能
public boolean renameTo(File dest):把文件重命名为指定的文件路径
比如：file1.renameTo(files) 为例
要想返回 true , 需要保证地是file1在硬盘中是存在的，且file2不能存在。
*/
@Test
public void test4(){
File file1 = new File("hello1.txt");
File file2 = new File("F:\\workspace\\IOTest\\src\\FileTest\\hello3.txt");
boolean renameTo = file1.renameTo(file2);
System.out.println(renameTo);
//运行之后，相对路径下的 hello1.txt 移动到 F:\workspace\IOTest\src\FileTest 目录下，且更名为 hello3.txt
}
/*
public boolean isDirectory()：判断是否是文件目录
public boolean isFile() ：判断是否是文件
public boolean exists() ：判断是否存在
public boolean canRead() ：判断是否可读
public boolean canWrite() ：判断是否可写
public boolean isHidden() ：判断是否隐藏
*/
@Test
public void test5(){
//文件在硬盘上存在时：
File file1 = new File("F:\\workspace\\IOTest\\src\\FileTest\\hello3.txt");
System.out.println(file1.isDirectory());//false
System.out.println(file1.isFile());//true
System.out.println(file1.exists());//true
System.out.println(file1.canRead());//true
System.out.println(file1.canWrite());//true
System.out.println(file1.isHidden());//false
//文件在硬盘上不存在时：
File file2 = new File("hello.txt");
System.out.println(file2.isDirectory());//false
System.out.println(file2.isFile());//false
System.out.println(file2.exists());//false
System.out.println(file2.canRead());//false
System.out.println(file2.canWrite());//false
System.out.println(file2.isHidden());//false
}
/*
File类的创建功能: 创建硬盘中对应的文件或文件目录
public boolean createNewFile() ：创建文件。若文件存在，则不创建，返回false
public boolean mkdir() ：创建文件目录。如果此文件目录存在，就不创建了。
如果此文件目录的上层目录不存在，也不创建。
public boolean mkdirs() ：创建文件目录。如果上层文件目录不存在，一并创建
注意事项：如果你创建文件或者文件目录没有写盘符路径，那么，默认在项目路径下。
File类的删除功能：删除磁盘中的文件或文件目录
public boolean delete()：删除文件或者文件夹
删除注意事项： Java中的删除不走回收站。 要删除一个文件目录，
【注】请注意该文件目录内不能包含文件或者文件目录
*/
@Test
public void test6() throws IOException {
//文件的创建
File file1 = new File("hi.txt");
if (!file1.exists()){//判断文件是否存在
file1.createNewFile();//若文件不存在，创建文件
System.out.println("创建成功");
}else {
file1.delete();//若文件不存在，删除文件
System.out.println("删除成功");
}
}
@Test
public void test7(){
//文件目录的创建
File file1 = new File("F:\\workspace\\IOTest\\src\\FileTest\\test1");
boolean mkdir1 = file1.mkdir();
if (mkdir1){
System.out.println("创建成功1");
}else {
System.out.println("文件夹存在1");
}
File file2 = new File("F:\\workspace\\IOTest\\src\\FileTest\\test2");
boolean mkdir2 = file2.mkdir();
if (mkdir2){
System.out.println("创建成功2");
}else {
System.out.println("文件夹存在2");
}
//若只需要生成一个目录，则 mkdir 与 mkdirs 没有区别
File file3 = new File("F:\\workspace\\IOTest\\src\\FileTest\\test3\\test3");
boolean mkdir3 = file3.mkdir();
if (mkdir3){
System.out.println("创建成功3");
}else {
System.out.println("创建失败3");
}
File file4 = new File("F:\\workspace\\IOTest\\src\\FileTest\\test4\\test4");
boolean mkdir4 = file4.mkdirs();
if (mkdir4){
System.out.println("创建成功4");
}else {
System.out.println("创建失败4");
}
//若创建多层目录，则 mkdir 是无法创建的，而 mkdirs 可以创建成功
}
File 类中涉及到关于文件或文件目录的创建、删除、重命名、修改时间、文件大小等方法，并未涉及到写入读取文件内容的操作，如果需要读取或写入文件内容，必须使用IO流来完成。
后续 File 类的对象常会作为参数传递到流的构造器中，指明读取或写入的"终点"。
File类的相关练习
/*
1、利用File构造器，new 一个文件目录file
1)在其中创建多个文件和目录
2)编写方法，实现删除file中指定文件的操作
*/
@Test
public void test() throws IOException {
File file = new File("F:\\workspace\\IOTest\\src\\FileTest\\hello3.txt");
//创建一个与 file 同目录下的另外一个文件，文件名为：hi3.txt
File destFile = new File(file.getParent(),"hi3.txt");
boolean newFile = destFile.createNewFile();
if (newFile){
System.out.println("创建成功");
}
//其后类似
}
import java.io.File;
import java.io.FileFilter;
import java.io.FilenameFilter;
import org.junit.Test;
/**
* 课后练习2：判断指定目录下是否有后缀名为.jpg的文件，如果有，就输出该文件名称
* @author shkstart 邮箱：shkstart@126.com
* @version 创建时间：2019年2月23日 上午1:55:59
*
*/
public class FindJPGFileTest {
@Test
public void test1(){
File srcFile = new File("d:\\code");
String[] fileNames = srcFile.list();
for(String fileName : fileNames){
if(fileName.endsWith(".jpg")){
System.out.println(fileName);
}
}
}
@Test
public void test2(){
File srcFile = new File("d:\\code");
File[] listFiles = srcFile.listFiles();
for(File file : listFiles){
if(file.getName().endsWith(".jpg")){
System.out.println(file.getAbsolutePath());
}
}
}
/*
* File类提供了两个文件过滤器方法
* public String[] list(FilenameFilter filter)
* public File[] listFiles(FileFilter filter)
*/
@Test
public void test3(){
File srcFile = new File("d:\\code");
File[] subFiles = srcFile.listFiles(new FilenameFilter() {
@Override
public boolean accept(File dir, String name) {
return name.endsWith(".jpg");
}
});
for(File file : subFiles){
System.out.println(file.getAbsolutePath());
}
}
}
import java.io.File;
/**
* 3. 遍历指定目录所有文件名称，包括子文件目录中的文件。
拓展1：并计算指定目录占用空间的大小
拓展2：删除指定文件目录及其下的所有文件
* @author shkstart 邮箱：shkstart@126.com
* @version 创建时间：2019年2月23日 上午1:55:31
*
*/
public class ListFilesTest {
public static void main(String[] args) {
// 递归:文件目录
/** 打印出指定目录所有文件名称，包括子文件目录中的文件 */
// 1.创建目录对象
File dir = new File("E:\\teach\\01_javaSE\\_尚硅谷Java编程语言\\3_软件");
// 2.打印目录的子文件
printSubFile(dir);
}
public static void printSubFile(File dir) {
// 打印目录的子文件
File[] subfiles = dir.listFiles();
for (File f : subfiles) {
if (f.isDirectory()) {// 文件目录
printSubFile(f);
} else {// 文件
System.out.println(f.getAbsolutePath());
}
}
}
// 方式二：循环实现
// 列出file目录的下级内容，仅列出一级的话
// 使用File类的String[] list()比较简单
public void listSubFiles(File file) {
if (file.isDirectory()) {
String[] all = file.list();
for (String s : all) {
System.out.println(s);
}
} else {
System.out.println(file + "是文件！");
}
}
// 列出file目录的下级，如果它的下级还是目录，接着列出下级的下级，依次类推
// 建议使用File类的File[] listFiles()
public void listAllSubFiles(File file) {
if (file.isFile()) {
System.out.println(file);
} else {
File[] all = file.listFiles();
// 如果all[i]是文件，直接打印
// 如果all[i]是目录，接着再获取它的下一级
for (File f : all) {
listAllSubFiles(f);// 递归调用：自己调用自己就叫递归
}
}
}
// 拓展1：求指定目录所在空间的大小
// 求任意一个目录的总大小
public long getDirectorySize(File file) {
// file是文件，那么直接返回file.length()
// file是目录，把它的下一级的所有大小加起来就是它的总大小
long size = 0;
if (file.isFile()) {
size += file.length();
} else {
File[] all = file.listFiles();// 获取file的下一级
// 累加all[i]的大小
for (File f : all) {
size += getDirectorySize(f);// f的大小;
}
}
return size;
}
// 拓展2：删除指定的目录
public void deleteDirectory(File file) {
// 如果file是文件，直接delete
// 如果file是目录，先把它的下一级干掉，然后删除自己
if (file.isDirectory()) {
File[] all = file.listFiles();
// 循环删除的是file的下一级
for (File f : all) {// f代表file的每一个下级
deleteDirectory(f);
}
}
// 删除自己
file.delete();
}
}
IO流原理及流的分类
IO原理
流的分类
节点流(或文件流)
一、流的分类
1、按照操作数据的单位：字节流、字符流
2、按照数据的流向：输入流、输出流
3、按照流的角色：节点流、处理流
二、流的体系结构
抽象基类 节点流 缓冲流（处理流的一种）
InputStream FileInputStream(read(byte[] buffer)) BufferedInputStream(read(byte[] buffer))
OutputStream FileOutputStream(write(byte[] buffer,0,len)) BufferedOutputStream(write(byte[] buffer,0,len)) / flus()
Reader FileReader(read(char[] cbuf)) BufferedReader(read(char[] cbuf)/readLine())
Writer FileWriter(write(char[] cbuf,0,len)) BufferedWriter(write(char[] cbuf,0,len)) / flus()
测试 FileReader 和 FileWriter 的使用（字符流）
// public static void main(String[] args) {
// File file = new File("hello.txt");//相对路径相较于当前工程
// System.out.println(file.getAbsoluteFile());//F:\workspace\hello.txt
// }
/*
将 F:\workspace\IOTest\hello.txt 的 hello.txt 文件读入程序中，并输出到控制台
步骤如下：
1、实例化 File 类对象，指明要操作的文件
2、提供具体的流
3、数据的读入
4、流的关闭操作
注意点：
1、read()的理解：返回读入一个字符，如果达到文件末尾，返回-1
2、异常的处理：为了保证流资源一定可以执行关闭操作，需要使用 try-catch-finally 处理
try{
对 File 的声明和操作内容
}catch(IOException e){
e.printStackTrace();
}finally{
try {
流的关闭操作
} catch (IOException e) {
e.printStackTrace();
}
}
3、读入的文件一定要存在，否则会报FileNotFoundException
*/
@Test
public void test() {
FileReader fr = null;
try {
//1、实例化 File 类对象，指明要操作的文件
File file = new File("hello.txt");//相对路径相较于当前Module
// System.out.println(file.getAbsoluteFile());//F:\workspace\IOTest\hello.txt
//2、提供具体的流
fr = new FileReader(file);
//3、数据的读入
//read() : 返回读入的一个字符，如果达到文件末尾，返回-1
//方式一：
// int data = fr.read();//int类型，即用int类型表示字符
// while (data != -1){
// System.out.print((char)data);//实现读取硬盘中文件内容的操作：输出 helloworld
// data = fr.read();
// }
//方式二：语法上针对于方式一的修改
int data;
while ((data=fr.read()) != -1){
System.out.print((char) data);
}
} catch (IOException e) {
e.printStackTrace();
}finally {
//4、流的关闭操作
try {
if (fr != null)
fr.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
//对 read() 操作升级：使用 read() 的重载方法
@Test
public void testFileRead1() {
FileReader fr = null;
try {
//1、File 类的实例化
File file = new File("hello.txt");
//2、FileReader 流的实例化
fr = new FileReader(file);
//读入的操作
//read(): 读入的是一个字符，效率较差。
//read(char[] cbuf): 返回每次读入cbuf数组中的字符个数，如果到末尾则返回-1
char[] cbuf = new char[5];
int len;
while ((len=fr.read(cbuf))!=-1){
//方式一：
//错误的写法
// for (int i = 0; i < cbuf.length; i++) {
// System.out.print(cbuf[i]);//helloworld123ld 由于最后只剩123，而数组中后面的值没变，就输出123ld
// }
//正确的写法
// for (int i = 0; i < len; i++) {
// System.out.print(cbuf[i]);//helloworld123
// }
//方式二
//错误的写法
// String str = new String(cbuf);
// System.out.print(str);//helloworld123ld 与上面相同
//正确的写法
String str = new String(cbuf,0,len); //每次去字符数组 cbuf 的 0 到 len个
System.out.print(str);//helloworld123
}
} catch (IOException e) {
e.printStackTrace();
} finally {
//资源的关闭
try {
fr.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
/*
从内存中写出数据到硬盘文件里
说明：
1、输出操作，对应的File文件可以不存在，并不会报异常
2、File对应的硬盘中的文件如果不存在，在输出的过程中，会自动创建此文件
File对应的硬盘中的文件如果存在：
如果流使用的构造器是：FileWriter(file,false) / FileWriter(file) : 对原有文件的覆盖
如果流使用的构造器是：FileWriter(file,true) : 不会对原有文件覆盖，而是在原有文件基础上追加内容。
*/
@Test
public void testFileWriter() throws IOException {
//1、提供 File 类的对象，指明写出到的文件
File file = new File("hello1.txt");
//2、提供 FileWriter 的对象，用于数据的写出
FileWriter fw = new FileWriter(file);
//3、写出的操作
fw.write("I have a dream!\n");
fw.write("you need to have a dream!");
//4、流资源的关闭操作
fw.close();
//【注】try-catch-finally 操作与 FileReader相似，这里不进行操作
}
文件的复制
//使用 FileReader 和 FileWriter 实现文本文件的复制
@Test
public void testFileReaderWriter() {
FileReader fr = null;
FileWriter fw = null;
try {
//1、创建File类的对象，指明读入和写出的文件
File srcFile = new File("hello.txt");
File destFile = new File("hello2.txt");
//2、创建输入流和输出流的对象
fr = new FileReader(srcFile);
fw = new FileWriter(destFile);
//3、数据的读入和写出操作
char[] cbuf = new char[5];
int len;//记录每次读入到 cbuf 数组的字符个数
while ((len=fr.read(cbuf))!=-1){
//每次写出len个字符
fw.write(cbuf,0,len);
}
} catch (IOException e) {
e.printStackTrace();
}finally {
//4、关闭流资源
//方式一
// try {
// fw.close();
// } catch (IOException e) {
// e.printStackTrace();
// }finally {
// try {
// fr.close();
// } catch (IOException e) {
// e.printStackTrace();
// }
// }
//方式二
try {
fw.close();
} catch (IOException e) {
e.printStackTrace();
}
try {
fr.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
【注】：不能使用字符流来处理图片、视频等字节数据。
测试 FileInputStream 和 FileOutputStream 的使用（字节流）
/**
测试FileInputStream 和 FileOutputStream 的使用
*/
public class FileInputOutputStream {
@Test
public void testFileInputStream() {
FileInputStream fis = null;
try {
//1、造文件
File file = new File("hello.txt");
//造流
fis = new FileInputStream(file);
//3、读数据
byte[] buffer = new byte[5];
int len;//记录
while((len = fis.read(buffer)) != -1){
String str = new String(buffer,0,len);
System.out.print(str);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
//4、关闭资源
try {
if (fis != null)
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
//使用字节流处理文本文件是可能出现乱码的
}
/*
实现对图片的复制操作
*/
@Test
public void testFileInputOutputStream(){
FileInputStream fis = null;
FileOutputStream fos = null;
try {
//1、造文件
File srcFile = new File("p1.jpg");
File destFile = new File("p2.jpg");
//2、造流
fis = new FileInputStream(srcFile);
fos = new FileOutputStream(destFile);
//3、读写过程（复制过程）
byte[] buffer = new byte[5];
int len ;
while((len = fis.read(buffer))!= -1){
fos.write(buffer,0,len);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
//4、关闭流
try {
if (fis!=null)
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
try {
if (fos!=null)
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
实现一个复制文件到另一个路径下的方法
//指定路径下的文件的复制 的方法
public void copyFile(String srcPath,String descPath){
FileInputStream fis = null;
FileOutputStream fos = null;
try {
//1、造文件
File srcFile = new File(srcPath);
File destFile = new File(descPath);
//2、造流
fis = new FileInputStream(srcFile);
fos = new FileOutputStream(destFile);
//3、读写过程（复制过程）
byte[] buffer = new byte[1024];
int len ;
while((len = fis.read(buffer))!= -1){
fos.write(buffer,0,len);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
//4、关闭流
try {
if (fis!=null)
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
try {
if (fos!=null)
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
@Test
public void testCopyFile(){
String srcPath = "G:\\视频文件\\1.mp4";//视频文件地址
String destPath="G:\\视频文件\\2.mp4";//视频文件复制到的目标地址
// String srcPath = "hello.txt";
// String destPath = "hello3.txt";
//若单纯想复制一个文件到另外一个路径下，通过字节流是可以操作的，但是不能在控制台输出，控制台输出的会出现乱码
//但字符流不能复制图片、视频等字节流文件
long start = System.currentTimeMillis();
copyFile(srcPath,destPath);
long end = System.currentTimeMillis();
System.out.println("复制操作花费的时间为："+((end-start))+"ms");
}
结论和注意点
1、对于文本文件 (.txt , .java , .cpp… )，使用字符流处理
2、对于非文本文件(.jpg , .mp3 , .avi , .doc…)，使用字节流来处理
3、若单纯想复制一个文件到另外一个路径下，通过字节流是可以操作的，但是不能在控制台输出，控制台输出的会出现乱码
4、字符流不能复制图片、视频等字节流文件
处理流之一：缓冲流
缓冲流：
处理字节：BufferedInputStream、BufferedOutputStream
处理字符：BufferedRead、BufferedWriter
/**
1、处理流之一：缓冲流的使用
BufferedInputStream
BufferedOutputStream
BufferedRead
BufferedWriter
2、作用：提高流的读取、写入速度
提高读写速度的原因：内部提供了一个缓冲区
3、处理流，就是 “套接” 在已有的流的基础上
测试BufferedInputStream 和 BufferedOutputStream的使用（字节流）
*/
public class BufferedTest {
/*
实现非文本文件的复制
*/
@Test
public void testBufferStream() {
FileInputStream fis = null;
FileOutputStream fos = null;
BufferedInputStream bis = null;
BufferedOutputStream bos = null;
try {
//1、造文件
File srcFile = new File("p1.jpg");
File destFile = new File("p3.jpg");
//2、造流：先造节点流，再造处理流
//2.1、造两个节点流
fis = new FileInputStream(srcFile);
fos = new FileOutputStream(destFile);
//2.2、造缓冲流
bis = new BufferedInputStream(fis);
bos = new BufferedOutputStream(fos);
//3、复制细节：读取、写入
byte[] buffer = new byte[10];
int len;
while ((len = bis.read(buffer)) != -1){
bos.write(buffer,0,len);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
//4、资源关闭：
// 要求先关闭外层的流，再关闭内层的流，与造流相反
try {
if(bis != null)
bis.close();
} catch (IOException e) {
e.printStackTrace();
}
try {
if (bos != null)
bos.close();
} catch (IOException e) {
e.printStackTrace();
}
//说明：关闭外层流的同时，内层流也会在自动进行关闭。关闭外层流的同时，关于内层流的关闭可以省略
// fis.close();
// fos.close();
}
}
//实现文件复制的方法
public void copyFileWithBuffered(String srcPath,String destPath){
FileInputStream fis = null;
FileOutputStream fos = null;
BufferedInputStream bis = null;
BufferedOutputStream bos = null;
try {
//1、造文件
File srcFile = new File(srcPath);
File destFile = new File(destPath);
//2、造流：先造节点流，再造处理流
//2.1、造两个节点流
fis = new FileInputStream(srcFile);
fos = new FileOutputStream(destFile);
//2.2、造缓冲流
bis = new BufferedInputStream(fis);
bos = new BufferedOutputStream(fos);
//3、复制细节：读取、写入
byte[] buffer = new byte[1024];
int len;
while ((len = bis.read(buffer)) != -1){
bos.write(buffer,0,len);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
//4、资源关闭：
// 要求先关闭外层的流，再关闭内层的流，与造流相反
try {
if(bis != null)
bis.close();
} catch (IOException e) {
e.printStackTrace();
}
try {
if (bos != null)
bos.close();
} catch (IOException e) {
e.printStackTrace();
}
//说明：关闭外层流的同时，内层流也会在自动进行关闭。关闭外层流的同时，关于内层流的关闭可以省略
// fis.close();
// fos.close();
}
}
@Test
public void testCopyFileWithBuffered(){
String srcPath = "G:\\视频文件\\test1.mp4";//视频文件地址
String destPath="G:\\视频文件\\test3.mp4";//视频文件复制到的目标地址
long start = System.currentTimeMillis();
copyFileWithBuffered(srcPath,destPath);
long end = System.currentTimeMillis();
System.out.println("复制操作花费的时间为："+((end-start))+"ms");//若文件够大，会清楚发现速度明显提高
}
/*
bos.flush()//清空缓存区，可以显示调用，但会自动调用flush()方法，所以没有必要加上
*/
测试BufferedRead 和 BufferedWriter的使用（字符流）
/*
使用 BufferedReader 和 BufferedWriter 实现文本文件的复制
*/
@Test
public void testBufferedReaderBufferedWriter() {
BufferedReader br = null;
BufferedWriter bw = null;
try {
//造文件、造流
br = new BufferedReader(new FileReader(new File("dbcp.txt")));
bw = new BufferedWriter(new FileWriter(new File("dbcp1.txt")));
//具体读写操作
char[] cbuf = new char[1024];
int len;
while((len=br.read(cbuf)) != -1){
bw.write(cbuf,0,len);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
//关闭流
try {
if (br!=null)
br.close();
} catch (IOException e) {
e.printStackTrace();
}
try {
if (bw!=null)
bw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
题2
//图片的加密
@Test
public void test1() {
FileInputStream fis = null;
FileOutputStream fos = null;
try {
// FileInputStream fis = new FileInputStream(new File("p1.jpg"));
fis = new FileInputStream("p1.jpg");
fos = new FileOutputStream("p1Secret.jpg");
byte[] buffer = new byte[20];
int len;
while((len = fis.read(buffer)) != -1){
//对字节数据进行修改
//错误的写法
// for (byte b: buffer) {
// b = (byte)(b^5);
// }
//正确的写法
for (int i = 0; i < len; i++) {
buffer[i] = (byte)(buffer[i] ^5);
}
fos.write(buffer,0,len);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if (fis!=null)
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
try {
if (fos!=null)
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
//图片的解密
@Test
public void test2() {
FileInputStream fis = null;
FileOutputStream fos = null;
try {
// FileInputStream fis = new FileInputStream(new File("p1.jpg"));
fis = new FileInputStream("p1Secret.jpg");
fos = new FileOutputStream("p14.jpg");
byte[] buffer = new byte[20];
int len;
while((len = fis.read(buffer)) != -1){
//对字节数据进行修改
//错误的写法
// for (byte b: buffer) {
// b = (byte)(b^5);
// }
//正确的写法
for (int i = 0; i < len; i++) {
buffer[i] = (byte)(buffer[i] ^5);
}
fos.write(buffer,0,len);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if (fis!=null)
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
try {
if (fos!=null)
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
题3
import org.junit.Test;
import java.io.*;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
/**
* 练习3:获取文本上字符出现的次数,把数据写入文件
*
* 思路：
* 1.遍历文本每一个字符
* 2.字符出现的次数存在Map中
*
* Map<Character,Integer> map = new HashMap<Character,Integer>();
* map.put('a',18);
* map.put('你',2);
*
* 3.把map中的数据写入文件
*
* @author shkstart
* @create 2019 下午 3:47
*/
public class WordCount {
/*
说明：如果使用单元测试，文件相对路径为当前module
如果使用main()测试，文件相对路径为当前工程
*/
@Test
public void testWordCount() {
FileReader fr = null;
BufferedWriter bw = null;
try {
//1.创建Map集合
Map<Character, Integer> map = new HashMap<Character, Integer>();
//2.遍历每一个字符,每一个字符出现的次数放到map中
fr = new FileReader("dbcp.txt");
int c = 0;
while ((c = fr.read()) != -1) {
//int 还原 char
char ch = (char) c;
// 判断char是否在map中第一次出现
if (map.get(ch) == null) {
map.put(ch, 1);
} else {
map.put(ch, map.get(ch) + 1);
}
}
//3.把map中数据存在文件count.txt
//3.1 创建Writer
bw = new BufferedWriter(new FileWriter("wordcount.txt"));
//3.2 遍历map,再写入数据
Set<Map.Entry<Character, Integer>> entrySet = map.entrySet();
for (Map.Entry<Character, Integer> entry : entrySet) {
switch (entry.getKey()) {
case ' ':
bw.write("空格=" + entry.getValue());
break;
case '\t'://\t表示tab 键字符
bw.write("tab键=" + entry.getValue());
break;
case '\r'://
bw.write("回车=" + entry.getValue());
break;
case '\n'://
bw.write("换行=" + entry.getValue());
break;
default:
bw.write(entry.getKey() + "=" + entry.getValue());
break;
}
bw.newLine();
}
} catch (IOException e) {
e.printStackTrace();
} finally {
//4.关流
if (fr != null) {
try {
fr.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (bw != null) {
try {
bw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
//文件编码的方式（如：GBK），决定了解析时使用的字符集（也只能是GBK）
处理流之二：转换流
转换流
/**
处理流之二：转换流的使用
1、转换流：属于字符流
InputStreamReader : 将一个字节的输入流转换为字符的输入流
OutputStreamWriter : 将一个字符的输出流转换成字节的输出流
2、作用：提供字节流与字符流之间的转换
3、解码：字节、字节数组 ---> 字符数组、字符串
编码：字符数组、字符串 ---> 字节、字节数组
4、字符集
*/
public class InputStreamReaderTest {
//InputStreamReader 的使用，实现字节的输入流到字符流的转换
@Test
public void test1() {
InputStreamReader isr = null;
try {
FileInputStream fis = new FileInputStream("dbcp.txt");//操作字节流
// InputStreamReader isr = new InputStreamReader(fis,);//使用系统默认的字符集
isr = new InputStreamReader(fis,"UTF-8");
//参数一指明字节流，参数二指明字符集，取决于文件保存时使用的字符集
char[] cbuf = new char[20];
int len;
while((len=isr.read(cbuf))!=-1){
String str = new String(cbuf,0,len);
System.out.print(cbuf);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if (isr!=null)
isr.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
/*
综合使用 InputStreamReader 和 OutputStreamWriter
*/
@Test
public void test2() {
InputStreamReader isr = null;//解码使用 UTF-8
OutputStreamWriter osw = null;//编码使用 GBK
try {
//造文件、造流
File file1 = new File("dbcp.txt");
File file2 = new File("dbcpCopy.txt");
FileInputStream fis = new FileInputStream(file1);
FileOutputStream fos = new FileOutputStream(file2);
isr = new InputStreamReader(fis,"UTF-8");
osw = new OutputStreamWriter(fos,"GBK");
//读写过程
char[] cbuf = new char[20];
int len;
while ((len = isr.read(cbuf)) != -1){
osw.write(cbuf,0,len);
}//关闭资源
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
isr.close();
} catch (IOException e) {
e.printStackTrace();
}
try {
osw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
字符编码
处理流之三：标准输入、输出流(了解)
/*
1、标准的输入输出流
1.1
System.in : 标准的输入流，默认从键盘输入，类型时 InputStream
System.out : 标准的输出流，默认从控制台输出，类型是 PrintStream，是 OutputStream 的子类
1.2
System 类的 setIn(InputStream is) / setOut(OutputStream os) 方式重新指定输入和输出的流。
1.3
例题：从键盘输入字符串，要求将读取到的整行字符串转成大写输出。
然后继续进行输入操作，直至当输入“e”或者“exit”时，退出程序。
方式一：使用 Scanner 实现，调用 next() 方法返回一个字符串
方式二：使用 System.in 实现，System.in ----> 转换流 ----> BufferedReader 的 readLine()
*/
public static void main(String[] args) {
BufferedReader br = null;
try {
InputStreamReader isr = new InputStreamReader(System.in);
br = new BufferedReader(isr);
while(true){
System.out.println("请输入字符串：");
String data = br.readLine();
if ("e".equalsIgnoreCase(data) || "exit".equalsIgnoreCase(data)){//最好是将 data 写在后边，避免空指针问题
System.out.println("程序结束");
break;
}
String upperCase = data.toUpperCase();
System.out.println(upperCase);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if (br == null) {
br.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
// MyInput.java: Contain the methods for reading int, double, float, boolean, short, byte and
// string values from the keyboard
import java.io.*;
public class MyInput {
// Read a string from the keyboard
public static String readString() {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
// Declare and initialize the string
String string = "";
// Get the string from the keyboard
try {
string = br.readLine();
} catch (IOException ex) {
System.out.println(ex);
}
// Return the string obtained from the keyboard
return string;
}
// Read an int value from the keyboard
public static int readInt() {
return Integer.parseInt(readString());
}
// Read a double value from the keyboard
public static double readDouble() {
return Double.parseDouble(readString());
}
// Read a byte value from the keyboard
public static double readByte() {
return Byte.parseByte(readString());
}
// Read a short value from the keyboard
public static double readShort() {
return Short.parseShort(readString());
}
// Read a long value from the keyboard
public static double readLong() {
return Long.parseLong(readString());
}
// Read a float value from the keyboard
public static double readFloat() {
return Float.parseFloat(readString());
}
}
处理流之四：打印流(了解)
/*
2、打印流：PrintStream 和 PrintWriter
2.1
提供了一系列重载的 print() 和 println()
PrintStream(FileOutputStream fos) //由默认的控制台输出改成输出到 fos 所指定的文件当中
2.2
练习
*/
@Test
public void test(){
PrintStream ps = null;
try {
FileOutputStream fos = new FileOutputStream(new File("F:\\workspace\\IOTest\\src\\IOTest1\\test.txt"));
// 创建打印输出流,设置为自动刷新模式(写入换行符或字节 '\n' 时都会刷新输出缓冲区)
ps = new PrintStream(fos, true);
if (ps != null) {// 把标准输出流(控制台输出)改成文件,即将数据输出到文件中
System.setOut(ps);
}
for (int i = 0; i <= 255; i++) { // 输出ASCII字符
System.out.print((char) i);
if (i % 50 == 0) { // 每50个数据一行
System.out.println(); // 换行
}
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} finally {
if (ps != null) {
ps.close();
}
}
}
处理流之五：数据流(了解)
/*
3、数据流
3.1、DataInputStream 和 DataOutputStream
3.2、作用：用于读取或写出基本数据类型的变量或字符串
练习：将内存中的字符串、基本数据类型的变量写出到文件中。
*/
@Test
public void test3() {
DataOutputStream dos = null;
try {// 创建连接到指定文件的数据输出流对象
dos = new DataOutputStream(new FileOutputStream("data.txt"));
dos.writeUTF("Jack");// 写UTF字符串
dos.flush();//刷新操作，将内存中的数据写入文件
dos.writeInt(12);
dos.flush();
dos.writeBoolean(true);
dos.flush();
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if (dos != null) {
dos.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
/*
将文件中存储的基本数据类型和字符串读取到内存中，保存到变量中。
注意点：读取不同类型的数据的顺序要与当初写入文件时，保存的数据的顺序一致！
*/
@Test
public void test4() {
DataInputStream dis = null;
try {
dis = new DataInputStream(new FileInputStream("data.txt"));
//读的顺序与写入的顺序相同,否则报异常 java.io.EOFException
String name = dis.readUTF();
int age = dis.readInt();
boolean isMale = dis.readBoolean();
System.out.println("name = "+name+",age = "+age+",isMale = "+isMale);
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if (dis != null) {
dis.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
处理流之六：对象流
对象流的序列化
使用对象流序列化对象
1、体验序列化机制
/*
序列化过程：将内存中的 java 对象保存到磁盘中，或通过网络传输出去
使用 ObjectOutputStream 实现
*/
@Test
public void testObjectOutputStream(){
ObjectOutputStream oos = null;
try {
//造流、造对象
oos = new ObjectOutputStream(new FileOutputStream("object.dat"));
//具体写出操作
oos.writeObject(new String("坚持党的领导，没有中国共产党，就没有新中国！！！"));
oos.flush();
} catch (IOException e) {
e.printStackTrace();
} finally {
if (oos != null) {
//关闭流
try {
oos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
/*
反序列化：将磁盘文件中的对象还原成内存中的java对象
使用 ObjectInputStream 实现
*/
@Test
public void testObjectInputStream(){
ObjectInputStream ois = null;
try {
ois = new ObjectInputStream(new FileInputStream("object.dat"));
Object obj = ois.readObject();
String str = (String)obj;
System.out.println(str);
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
} finally {
if (ois != null) {
try {
ois.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
2、自定义类实现序列化与反序列化
//自定义类Person进行自定义类的序列化
import java.io.Serializable;
/**
Person 需要满足如下要求方可序列化
1、需要实现接口：Serializable
2、需要当前类提供一个全局常量：serialVersionUID
3、除了当前类需要实现 Serializable 接口之外，还必须保证其内部所有属性也必须是可序列化的。(默认情况下，基本数据类型是可序列化的)
补充：ObjectOutputStream 和 ObjectInputStream 不能序列化 static 和 transient 修饰的成员变量
*/
public class Person implements Serializable {//Serializable 没有具体可实现的方法，是个标识接口
public static final long serialVersionUID = 42456845892L;//序列版本号
//当没有自己定义版本号时，系统会自动分配一个版本号，但是，当我们没有自定义版本号，且进行序列化，再对原先对象进行修改
//再进行反序列化会报异常，没办法还原。
private String name;
private int age;
private Accout acc;
public Person(String name, int age, Accout acc) {
this.name = name;
this.age = age;
this.acc = acc;
}
public Accout getAcc() {
return acc;
}
public void setAcc(Accout acc) {
this.acc = acc;
}
public Person() {
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
class Accout{
private double balance;
public Accout() {
}
public Accout(double balance) {
this.balance = balance;
}
public double getBalance() {
return balance;
}
public void setBalance(double balance) {
this.balance = balance;
}
@Override
public String toString() {
return "Accout{" +
"balance=" + balance +
'}';
}
}
//序列化的测试
/**
对象流的使用
1、ObjectInputStream 和 ObjectOutputStream
2、用于存储和读取基本数据类型数据或对象的处理流。它的强大之处就是可以把Java中的对象写入到数据源中，也能把对象从数据源中还原回来。
3、要想一个java对象是可序列化的，需要满足相应的要求
需要满足如下要求方可序列化
1、需要实现接口：Serializable
2、需要当前类提供一个全局常量：serialVersionUID
3、3、除了当前类需要实现 Serializable 接口之外，还必须保证其内部所有属性也必须是可序列化的。(默认情况下，基本数据类型是可序列化的)
4、序列化机制
对象序列化机制允许把内存中的Java对象转换成平台无关的二进制流，从而允许把这种二进制流持久地保存在磁盘上，或通过网络将这种二进制流传输到另一个网络节点。
//当其它程序获取了这种二进制流，就可以恢复成原来的Java对象
补充：ObjectOutputStream 和 ObjectInputStream 不能序列化 static 和 transient 修饰的成员变量
*/
public class ObjectInputOutputStreamTest {
/*
序列化过程：将内存中的 java 对象保存到磁盘中，或通过网络传输出去
使用 ObjectOutputStream 实现
*/
@Test
public void testObjectOutputStream(){
ObjectOutputStream oos = null;
try {
//造流、造对象
oos = new ObjectOutputStream(new FileOutputStream("object.dat"));
//具体写出操作
oos.writeObject(new String("坚持党的领导，没有中国共产党，就没有新中国！！！"));
oos.writeObject(new Person("Jack",23));//若对象不是可序列化文件，则报异常 java.io.NotSerializableException
// oos.writeObject(new Person("Jerry",56,new Accout(5000)));//此时Accout没有序列化，报异常 java.io.NotSerializableException: ObjectInputOutputStream.Accout
oos.flush();
} catch (IOException e) {
e.printStackTrace();
} finally {
if (oos == null) {
//关闭流
try {
oos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
/*
反序列化：将磁盘文件中的对象还原成内存中的java对象
使用 ObjectInputStream 实现
*/
@Test
public void testObjectInputStream(){
ObjectInputStream ois = null;
try {
ois = new ObjectInputStream(new FileInputStream("object.dat"));
Object obj = ois.readObject();
String str = (String)obj;//度的顺序与写的顺序一致
Person p = (Person) ois.readObject();
System.out.println(str);//坚持党的领导，没有中国共产党，就没有新中国！！！
System.out.println(p);//Person{name='Jack', age=23}
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
} finally {
if (ois != null) {
try {
ois.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
随机存取文件流
RandomAccessFile 类
import com.sun.deploy.security.WinDeployNTLMAuthCallback;
import org.junit.Test;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.RandomAccessFile;
/**
RandomAccessFile 的使用
1、RandomAccessFile 直接继承于 java.lang.Object 类，实现了DataInput 和 DataOutput接口
2、RandomAccessFile 既可以作为一个输入流，又可以作为一个输出流
3、如果 RandomAccessFile 作为一个输出流出现，写出到的文件不存在，则在执行过程中自动创建
如果写出到的文件存在，则会对原有文件的内容进行覆盖（默认从头覆盖）
4、可以通过相关操作，实现 RandomAccessFile "插入"数据的效果
RandomAccessFile(File fileName,mode);
mode 有一下参数
r: 以只读方式打开
rw：打开以便读取和写入
rwd:打开以便读取和写入；同步文件内容的更新
rws:打开以便读取和写入；同步文件内容和元数据的更新
JDK 1.6 上面写的每次 write 数据时，“rw”模式，数据不会立刻写道磁盘中；而“rwd”，数据会被立刻写入硬盘，
如果写数据过程中发生异常，“rwd”模式中已被write的数据被保存到硬盘，而“rw”则全部丢失
*/
public class RandomAccessFileTest {
//使用 RandomAccessFile 的输入输出功能，实现文件的复制
@Test
public void test1(){
RandomAccessFile raf1 = null;
RandomAccessFile raf2 = null;
try {
raf1 = new RandomAccessFile(new File("p1.jpg"),"r");
raf2 = new RandomAccessFile(new File("p5.jpg"),"rw");
byte[] buffer = new byte[1024];
int len;
while ((len = raf1.read(buffer)) != -1){
raf2.write(buffer,0,len);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if (raf1 != null) {
raf1.close();
}
} catch (IOException e) {
e.printStackTrace();
}
try {
if (raf2 != null) {
raf2.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
//RandomAccessFile对文件内容进行覆盖
@Test
public void test2(){
RandomAccessFile raf1 = null;
try {
raf1 = new RandomAccessFile(new File("hello.txt"),"rw");
//如果本文件不存在，则是会新建一个文件，并输入内容，
// 若文件已存在，则会在开头位置对内容进行覆盖
raf1.seek(4);//将指针调到角标为3的位置
raf1.write("abc".getBytes());
} catch (IOException e) {
e.printStackTrace();
} finally {
if (raf1 != null) {
try {
raf1.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
/*
使用 RandomAccessFile 实现数据插入的效果
*/
@Test
public void test(){
RandomAccessFile raf1 = null;
try {
raf1 = new RandomAccessFile(new File("hello.txt"),"rw");
raf1.seek(3);//将指针调到角标为3的位置
//保存指针3后面的所有数据到 StringBuilder 中
StringBuilder builder = new StringBuilder((int) new File("hello.txt").length());
byte[] buffer = new byte[20];
int len;
while((len = raf1.read(buffer))!=-1){
builder.append(new String(buffer,0,len));
}
//调回指针，写入”xyz“
raf1.seek(3);
raf1.write("xyz".getBytes());
//将 StringBuilder 中的数据写入到文件中
raf1.write(builder.toString().getBytes());
} catch (IOException e) {
e.printStackTrace();
} finally {
if (raf1 != null) {
try {
raf1.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
使用 ByteArrayOutputStream 进行插入操作
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import org.junit.Test;
public class ByteArrayOutputStreamTest {
@Test
public void test1() throws Exception {
FileInputStream fis = new FileInputStream("abc.txt");
String info = readStringFromInputStream(fis);
System.out.println(info);
}
private String readStringFromInputStream(FileInputStream fis) throws IOException {
// 方式一：可能出现乱码
// String content = "";
// byte[] buffer = new byte[1024];
// int len;
// while((len = fis.read(buffer)) != -1){
// content += new String(buffer);
// }
// return content;
// 方式二：BufferedReader
BufferedReader reader = new BufferedReader(new InputStreamReader(fis));
char[] buf = new char[10];
int len;
String str = "";
while ((len = reader.read(buf)) != -1) {
str += new String(buf, 0, len);
}
return str;
// 方式三：避免出现乱码
// ByteArrayOutputStream baos = new ByteArrayOutputStream();
// byte[] buffer = new byte[10];
// int len;
// while ((len = fis.read(buffer)) != -1) {
// baos.write(buffer, 0, len);
// }
//
// return baos.toString();
}
}
流的基本小结
NIO.2中Path、Paths、Files类的使用
Java NIO 概述
Path、Paths和Files核心API
Files方法测试
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.nio.channels.SeekableByteChannel;
import java.nio.file.DirectoryStream;
import java.nio.file.Files;
import java.nio.file.LinkOption;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardCopyOption;
import java.nio.file.StandardOpenOption;
import java.util.Iterator;
import org.junit.Test;
/**
* Files工具类的使用：操作文件或目录的工具类
* @author shkstart
* @create 2019 下午 2:44
*/
public class FilesTest {
@Test
public void test1() throws IOException{
Path path1 = Paths.get("d:\\nio", "hello.txt");
Path path2 = Paths.get("atguigu.txt");
// Path copy(Path src, Path dest, CopyOption … how) : 文件的复制
//要想复制成功，要求path1对应的物理上的文件存在。path1对应的文件没有要求。
// Files.copy(path1, path2, StandardCopyOption.REPLACE_EXISTING);
// Path createDirectory(Path path, FileAttribute<?> … attr) : 创建一个目录
//要想执行成功，要求path对应的物理上的文件目录不存在。一旦存在，抛出异常。
Path path3 = Paths.get("d:\\nio\\nio1");
// Files.createDirectory(path3);
// Path createFile(Path path, FileAttribute<?> … arr) : 创建一个文件
//要想执行成功，要求path对应的物理上的文件不存在。一旦存在，抛出异常。
Path path4 = Paths.get("d:\\nio\\hi.txt");
// Files.createFile(path4);
// void delete(Path path) : 删除一个文件/目录，如果不存在，执行报错
// Files.delete(path4);
// void deleteIfExists(Path path) : Path对应的文件/目录如果存在，执行删除.如果不存在，正常执行结束
Files.deleteIfExists(path3);
// Path move(Path src, Path dest, CopyOption…how) : 将 src 移动到 dest 位置
//要想执行成功，src对应的物理上的文件需要存在，dest对应的文件没有要求。
// Files.move(path1, path2, StandardCopyOption.ATOMIC_MOVE);
// long size(Path path) : 返回 path 指定文件的大小
long size = Files.size(path2);
System.out.println(size);
}
@Test
public void test2() throws IOException{
Path path1 = Paths.get("d:\\nio", "hello.txt");
Path path2 = Paths.get("atguigu.txt");
// boolean exists(Path path, LinkOption … opts) : 判断文件是否存在
System.out.println(Files.exists(path2, LinkOption.NOFOLLOW_LINKS));
// boolean isDirectory(Path path, LinkOption … opts) : 判断是否是目录
//不要求此path对应的物理文件存在。
System.out.println(Files.isDirectory(path1, LinkOption.NOFOLLOW_LINKS));
// boolean isRegularFile(Path path, LinkOption … opts) : 判断是否是文件
// boolean isHidden(Path path) : 判断是否是隐藏文件
//要求此path对应的物理上的文件需要存在。才可判断是否隐藏。否则，抛异常。
// System.out.println(Files.isHidden(path1));
// boolean isReadable(Path path) : 判断文件是否可读
System.out.println(Files.isReadable(path1));
// boolean isWritable(Path path) : 判断文件是否可写
System.out.println(Files.isWritable(path1));
// boolean notExists(Path path, LinkOption … opts) : 判断文件是否不存在
System.out.println(Files.notExists(path1, LinkOption.NOFOLLOW_LINKS));
}
/**
* StandardOpenOption.READ:表示对应的Channel是可读的。
* StandardOpenOption.WRITE：表示对应的Channel是可写的。
* StandardOpenOption.CREATE：如果要写出的文件不存在，则创建。如果存在，忽略
* StandardOpenOption.CREATE_NEW：如果要写出的文件不存在，则创建。如果存在，抛异常
*
* @author shkstart 邮箱：shkstart@126.com
* @throws IOException
*/
@Test
public void test3() throws IOException{
Path path1 = Paths.get("d:\\nio", "hello.txt");
// InputStream newInputStream(Path path, OpenOption…how):获取 InputStream 对象
InputStream inputStream = Files.newInputStream(path1, StandardOpenOption.READ);
// OutputStream newOutputStream(Path path, OpenOption…how) : 获取 OutputStream 对象
OutputStream outputStream = Files.newOutputStream(path1, StandardOpenOption.WRITE,StandardOpenOption.CREATE);
// SeekableByteChannel newByteChannel(Path path, OpenOption…how) : 获取与指定文件的连接，how 指定打开方式。
SeekableByteChannel channel = Files.newByteChannel(path1, StandardOpenOption.READ,StandardOpenOption.WRITE,StandardOpenOption.CREATE);
// DirectoryStream<Path> newDirectoryStream(Path path) : 打开 path 指定的目录
Path path2 = Paths.get("e:\\teach");
DirectoryStream<Path> directoryStream = Files.newDirectoryStream(path2);
Iterator<Path> iterator = directoryStream.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}
}
}
Path方法测试
import java.io.File;
import java.nio.file.Path;
import java.nio.file.Paths;
import org.junit.Test;
/**
* 1. jdk 7.0 时，引入了 Path、Paths、Files三个类。
* 2.此三个类声明在：java.nio.file包下。
* 3.Path可以看做是java.io.File类的升级版本。也可以表示文件或文件目录，与平台无关
* <p>
* 4.如何实例化Path:使用Paths.
* static Path get(String first, String … more) : 用于将多个字符串串连成路径
* static Path get(URI uri): 返回指定uri对应的Path路径
*
* @author shkstart
* @create 2019 下午 2:44
*/
public class PathTest {
//如何使用Paths实例化Path
@Test
public void test1() {
Path path1 = Paths.get("d:\\nio\\hello.txt");//new File(String filepath)
Path path2 = Paths.get("d:\\", "nio\\hello.txt");//new File(String parent,String filename);
System.out.println(path1);
System.out.println(path2);
Path path3 = Paths.get("d:\\", "nio");
System.out.println(path3);
}
//Path中的常用方法
@Test
public void test2() {
Path path1 = Paths.get("d:\\", "nio\\nio1\\nio2\\hello.txt");
Path path2 = Paths.get("hello.txt");
// String toString() ： 返回调用 Path 对象的字符串表示形式
System.out.println(path1);
// boolean startsWith(String path) : 判断是否以 path 路径开始
System.out.println(path1.startsWith("d:\\nio"));
// boolean endsWith(String path) : 判断是否以 path 路径结束
System.out.println(path1.endsWith("hello.txt"));
// boolean isAbsolute() : 判断是否是绝对路径
System.out.println(path1.isAbsolute() + "~");
System.out.println(path2.isAbsolute() + "~");
// Path getParent() ：返回Path对象包含整个路径，不包含 Path 对象指定的文件路径
System.out.println(path1.getParent());
System.out.println(path2.getParent());
// Path getRoot() ：返回调用 Path 对象的根路径
System.out.println(path1.getRoot());
System.out.println(path2.getRoot());
// Path getFileName() : 返回与调用 Path 对象关联的文件名
System.out.println(path1.getFileName() + "~");
System.out.println(path2.getFileName() + "~");
// int getNameCount() : 返回Path 根目录后面元素的数量
// Path getName(int idx) : 返回指定索引位置 idx 的路径名称
for (int i = 0; i < path1.getNameCount(); i++) {
System.out.println(path1.getName(i) + "*****");
}
// Path toAbsolutePath() : 作为绝对路径返回调用 Path 对象
System.out.println(path1.toAbsolutePath());
System.out.println(path2.toAbsolutePath());
// Path resolve(Path p) :合并两个路径，返回合并后的路径对应的Path对象
Path path3 = Paths.get("d:\\", "nio");
Path path4 = Paths.get("nioo\\hi.txt");
path3 = path3.resolve(path4);
System.out.println(path3);
// File toFile(): 将Path转化为File类的对象
File file = path1.toFile();//Path--->File的转换
Path newPath = file.toPath();//File--->Path的转换
}
}
扫一扫
132
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
