IO流2（File和字节流）

一、File类

1.构造方法

File(String fileName)    将一个字符串路径封装

File(String parent,String child)   传入一个父级路径和子级路径创建file对象

File(File parent,String child) 传入一个File类型的父级路径和子级路径

示例代码：

File f = new File("D:\\a\\b.txt");

File f2 = new File("D:\\a","b.txt");

File parent = new File("D:\\a");

File f3 = new File(parent,"b.txt");

File f4 = new File(new File("D:\\a"),"b.txt");

2.成员方法

A：创建功能和删除功能

boolean createnewFile()：创建文件

   指定路径不存在该文件时时创建文件,返回true,否则返回false

boolean mkdir()：创建单级文件夹

  当指定文件夹不存在时创建文件夹并返回true，否则返回false

boolean mkdirs()：创建多级文件夹

  当指定的多级文件夹某一级文件夹不存在时,创建多级文件夹并返回

  true,否则返回false

boolean delete()：删除文件或文件夹(文件夹必须为空)

当指定的文件或文件夹存在时删除文件或者文件夹 并返回true

示例代码：

File f = new File("d:\\a\\b.txt");//绝对路径

File f2 = new File("a.txt");//相对路径

System.out.println(f2.createNewFile());

File f3 = new File("b");

System.out.println(f3.mkdir());

File f4 = new File("c\\d\\e");

//System.out.println(f4.mkdir());

System.out.println(f4.mkdirs());

System.out.println(f2.delete());

System.out.println(f3.delete());

B：判断功能

boolean exists() 判断文件或文件夹路径是否存在

  boolean isAbsolute() 判断是否是绝对路径

  boolean isDirectory() 判断是否是文件夹

boolean isFile() 判断是否是文件

boolean isHidden() 判断是否是隐藏文件

示例代码：

File f = new File("a.txt");

File f2 = new File("b");

System.out.println(f.isDirectory());

System.out.println(f2.isDirectory());

System.out.println(f.isFile());

System.out.println(f2.isFile());

System.out.println(f.isHidden());

private static void method2() {

System.out.println(f2.isAbsolute());

System.out.println(f.exists());

C：获取功能

File getAbsoluteFile()：以File对象的形式获取绝对路径

  String getAbsolutePath() ：以字符串形式获取绝对路径

  String getParent()：以字符串形式获取父级路径

File getParentFile() ：以File对象的形式获取父级路径

String getName()：获取文件或文件夹的名字

String getPath()：获取路径

long lastModified()：获取最后的修改时间

long length()：获取大小(只能获取文件)

boolean renameTo(File dest)：修改名字(同级目录改名，不同级目录剪

  切)

示例代码：

File f = new File("b.txt");

File f2 = new File("demo/h.txt");

//boolean renameTo(File dest) : 将当前File对象所指向的路径 修改

为 指定File所指向的路径

//注意：修改的文件路径不能存在，如果存在则修改失败

System.out.println(f.renameTo(f2));

File f3 = new File("a.txt");

File f4 = new File("b\\b.txt");

System.out.println(f3.renameTo(f4));

//String getName() : 获取文件和文件夹的名称

System.out.println(f.getName());

System.out.println(f2.getName());

System.out.println(f3.getName());

//String getPath() : 返回创建File对象时给的路径

System.out.println(f.getPath());

System.out.println(f2.getPath());

System.out.println(f3.getPath());

//long lastModified() : 以毫秒值的形式返回最后修改时间

System.out.println(f.lastModified());

//long length() : 返回文件的字节数

System.out.println(f.length());

System.out.println(f3.length());

//File getAbsoluteFile()  ：以File对象的形式返回当前File对象所有

指向的绝对路径

System.out.println(f2.getAbsoluteFile());

//String getAbsolutePath() : 返回File对象所指向的绝对路径

System.out.println(f2.getAbsolutePath());

D：File类其他的获取功能

    String[] list()：获取目录下所有的文件和文件夹名称，以字符串数组返回

File[] listFiles()：获取目录下所有的文件和文件夹对象，返回File对象数组

static File[] listRoots()：获取本机盘符 ，静态方法

示例代码：

//static File[] listRoots() :  返回的是所有盘符

File[] files = File.listRoots();

for (File file : files) {

System.out.println(file);

}

//File[] listFiles()

File[] files = f3.listFiles();

for (File file : files) {

System.out.println(file.getName());

}

//String[] list() : 返回当前路径下所有的文件和文件夹名称

//注意：只有指向文件夹的File对象才可以调用该方法

String[] files = f3.list();

for (int i = 0; i < files.length; i++) {

System.out.println(files[i]);

}

3.打印指定目录下所有的.java文件名(包含子目录)

public class RecurrenceTest {

public static void main(String[] args) {

File f = new File("d:\\a");

method(f);

}

public static void method(File file) {

File[] files = file.listFiles();

if(files != null) {

for (File f : files) {

//判断是否是文件对象

if(f.isFile() && f.getName().endsWith(".java")) {

System.out.println(f.getName());

}else if(f.isDirectory()){

//是一个目录对象

method(f);

}

}

}

}

}

4.删除文件夹

public class RecurrenceTest2 {

public static void main(String[] args) {

File f = new File("d:\\a");

method(f);

}

//删除指定文件夹下所有文件和子文件夹

public static void method(File file) {

//删除自己所有的子文件和子文件夹

//获取所有的子文件和子文件夹

File[] files = file.listFiles();

if(files != null) {

for (File f : files) {

if(f.isFile()) {

//直接删掉此文件

System.out.println(f.getName());

f.delete();

}else if(f.isDirectory()) {

//继续查看是否还有文件和子文件夹

method(f);

}

}

//删除本文件夹

System.out.println(file.getName());

file.delete();

}

}

}

二、IO流

1.IO流体系结构

字符流：

字符输入流顶层抽象父类： Reader

字符输入流： FileReader

字符输入缓冲流： BufferedReader

字符输出流顶层抽象父类： Writer

字符输出流： FileWriter

字符输出缓冲流： BufferedWriter

字节流：

字节输入流顶层抽象父类： InputStream

字节输入流： FileInputStream

字节输入缓冲流： BufferedInputStream

字节输出流顶层抽象父类： OutputStream

字节输出流： FileOutputStream

字节输出缓冲流： BufferedOutputStream

注意：字符流一般用于操作纯文本文件，而字节流一般用于操作富文本文件(图

片，音频，视频等)。字符流不可用于操作富文本。

2.字符流复制文本文件

普通字符流一次读写一个字符

普通字符流一次读写一个字符数组

高效字符流一次读写一个字符

高效字符流一次读写一个字符数组

高效字符流特殊功能  【推荐】

public class Test02 {

public static void main(String[] args) throws IOException{

long start = System.currentTimeMillis();

copy5();

long end = System.currentTimeMillis();

System.out.println(end - start);

}

//高效字符流特殊功能

private static void copy5() throws IOException{

BufferedReader br = new BufferedReader(new FileReader("a.txt"));

BufferedWriter bw = new BufferedWriter(new FileWriter("b.txt"));

String line;

while((line = br.readLine()) != null) {

bw.write(line);

bw.newLine();

}

br.close();

bw.close();

}

//高效字符流一次读写一个字符数组             

private static void copy4() throws IOException{

BufferedReader br = new BufferedReader(new FileReader("a.txt"));

BufferedWriter bw = new BufferedWriter(new FileWriter("b.txt"));

char[] arr = new char[1024];

int len;

while((len = br.read(arr)) != -1) {

bw.write(arr, 0, len);

}

br.close();

bw.close();

}

//高效字符流一次读写一个字符

private static void copy3() throws IOException{

BufferedReader br = new BufferedReader(new FileReader("a.txt"));

BufferedWriter bw = new BufferedWriter(new FileWriter("b.txt"));

int ch;

while((ch = br.read()) != -1) {

bw.write(ch);

}

br.close();

bw.close();

}

//普通字符流一次读写一个字符数组

private static void copy2() throws IOException{

FileReader fr = new FileReader("a.txt");

FileWriter fw = new FileWriter("b.txt");

char[] arr = new char[1024];

int len;

while((len = fr.read(arr)) != -1) {

fw.write(arr, 0, len);

}

fr.close();

fw.close();

}

//普通字符流一次读写一个字符

private static void copy1() throws IOException{

FileReader fr = new FileReader("a.txt");

FileWriter fw = new FileWriter("b.txt");

int ch;

while((ch = fr.read()) != -1) {

fw.write(ch);

}

fr.close();

fw.close();

}

}

3.使用字节流复制图片

private static void method2() throws IOException {

//创建字节输入流对象

FileInputStream fis = new FileInputStream("XXX.jpg");

//创建字节输出流对象

FileOutputStream fos = new FileOutputStream("d:\\XXX.jpg");

//一次读写一个字节数组

int len;//用于存储读到的字节个数

byte[] bys = new byte[1024];

while((len = fis.read(bys)) != -1) {

fos.write(bys,0,len);

}

//释放资源

fos.close();

fis.close();

}

4.使用字节流复制文本文件

public class FileCopyDemo {

public static void main(String[] args) throws IOException  {

//创建字节输入流对象

FileInputStream fis = new FileInputStream("IODemo.java");

//创建字节输出流对象

FileOutputStream fos = new

FileOutputStream("d:\\a\\IODemo.java");

//一次读写一个字节数组

int len;//存储读到的字节个数

byte[] bys = new byte[1024];

while((len = fis.read(bys)) != -1) {

fos.write(bys,0,len);

}

//释放资源

fos.close();

fis.close();

}

}

5.复制文件夹

（用字节流复制，文件夹中可能会有富文本文件）

import java.io.File;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.IOException;

import java.util.Scanner;

/*

* 1.通过键盘录入一个源文件夹路径(要判断是否是正确的文件夹路径)

2.通过键盘录入一个目标文件夹路径(要判断是否是正确的文件夹路径)

3.将源文件夹中的内容全部复制到目标文件夹中

       */

public class Test2 {

public static void main(String[] args) throws IOException {

//文件夹路径类似于 d:\\a\\IODemo.java

System.out.println("请输入一个源文件夹路径：");

File src = method1();

System.out.println("请输入一个目标文件夹路径：");

File dest = method1();

//复制文件夹

method2(src, dest);

}

   /*复制文件夹

   *源文件夹对象：src

   *目标文件夹对象：dest

   */

private static void method2(File src, File dest) throws IOException {

//在目标文件夹中创建新文件夹，名称为src的文件夹名

File parent = new File(dest,src.getName()); 

parent.mkdir();

File[] files = src.listFiles();

if(files != null) {

for (File file : files) {  //遍历源文件夹

//如果是文件,复制文件

if(file.isFile()) {

/*复制文件

*源文件   file

*目标文件 new File(parent,file.getName())

*/

//字节流 读对象

FileInputStream fis = new FileInputStream(file);

//字节流 写对象

FileOutputStream fos = new FileOutputStream(new

File(parent,file.getName()));

//一次读写一个字节数组

int len;

byte[] bs = new byte[1024];

while((len = fis.read(bs)) != -1) {

fos.write(bs, 0, len);

}

//关闭流

fis.close();

fos.close();

}

//如果是文件夹,再次调用本方法

if(file.isDirectory()) {

/*

* 新的源文件夹  ：file

* 新的目标文件夹: parent

*/

method2(file,parent);

}

}//for

}//if

}

private static File method1() {

while(true) {

Scanner sc = new Scanner(System.in);

//System.out.println("请输入一个文件夹路径：");

String s = sc.next();

File f = new File(s);

if(!f.exists()) {

System.out.println("您输入的文件夹不存在，请重新输入：");

} else if(f.isFile()) {

System.out.println("您输入的是文件路径，请重新输入：");

} else if(f.isDirectory()) {

return f;

}

}

}

}

另：存储单元进制转换

1B = 8bit

1KB = 1024B

1MB = 1024KB

1GB = 1024MB

1TB = 1024GB

1PB = 1024TB

1EB = 1024PB

1ZB = 1024EB

1YB = 1024ZB

1BB = 1024YB