JAVA基础复习与总结<七> File类_基本的IO概念_输入输出

File类

1、操作目录 

mkdir() 创建目录，必须确保父目录存在，如果不存在，创建失败

mkdirs()

list() 文件：目录字符串形式 ，只返回目录和文件的名称

listFiles()  ：返回目录和名称的路径

Static listRoots() 根路径

2、绝对路径和相对路径

绝对路径：指文件在硬盘上真正存在的路径。比如：D:\Java\HelloWorld.java

相对路径：指某个文件的路径和别的文件的路径关系。比如在d盘里面有两个文件，路径分别是：D:\Java\HelloWorld.java和D:\Java\images\monkey.png。它们都在d盘的Java文件夹里面。那么monkey.png这个文件的路径相对于HelloWorld.java来说就是\images\monkey.png。

注意：../ 代表向上一级目录。Java相对于图片的相对路径是:../HellloWorld.java.

在windows系统中绝对路径以盘符开头，例如：D:\

在非windows系统中绝对路径以根目录开头：  /

在不写盘符或者根目录来直接构建file类的情况下，绝对路径就是在当前的工作空间+String name

3、IO流中解决不同系统的路径问题

IO操作中关于路径有两个常量，而这两个常量在不同的操作系统中可能不同。

1）路径分割符 ： ；

2）名称分割符：  \\（Windows）             /（Mac OS）

路径分割符： File.pathSeparator

名称分割符： File.separator

推荐的路径方式：

path="E:"+File.separator+"xp"+File.separator+"test"+File.separator+"2.jpg";

public static void main(String[] args) {

System.out.println(File.pathSeparator);

System.out.println(File.separator);

//路径表示形式

String path ="E:\\xp\\test\\2.jpg";

path="E:"+File.separator+"xp"+File.separator+"test"+File.separator+"2.jpg";

//推荐方式

path="E:/xp/test/2.jpg";

}

}

4、File类的应用

1）遍历目录下的文件

/**

*    mkdir() 创建目录，必须确保父目录存在，如果不存在，创建失败

*    mkdirs() 创建目录，如果父目录链不存在，一同创建

*    list() 文件：目录名字符串形式

*    listFiles()：过滤器，测试指定文件是否在某目录中

*    Static listRoots() 根路径

*/

import java.io.File;

import java.io.FilenameFilter;

public class TestFile {

    public static void main(String[] args ){

         String path ="/Users/qianjiapeng/Desktop";

         File src = new File(path);

         if(src.isDirectory()){   //存在并且为目录

             System.out.println("=======子目录；文件名=======");

             String[ ] subNames = src.list();   //.list()方法存储的是文件名

             for(String temp:subNames){

                 System.out.println(temp);   //将该目录下的文件的名称进行了输出

             }

             System.out.println("========子目录；文件File对象========");

             File[] subFiles = src.listFiles();   //listFiles()方法返回的是文件，

                                                 // 因此在遍历文件夹以及子文件夹中所有文件时必须使用listFiles()方法，可以用作递归

             for(File temp:subFiles){

                 System.out.println(temp);

             }

             System.out.println("========子文件.java对象========");

             //命令设计模式

                subFiles = src.listFiles(new FilenameFilter() {

                    @Override

                    /*

                    dir代表的就是

                     */

                    public boolean accept ( File dir, String name ) {  //重写了此方法，dir是父路基，name是子文件名

                       // System.out.println(dir.getAbsolutePath());

                        return new File(dir,name).isFile()&&name.endsWith(".txt");  //在父路径下面找到是文件并且符合命名要求的文件

                      }

                });

             for(File temp:subFiles){

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

             }

2）递归实现遍历目录下的文件与子文件

/**

* 输出子孙级目录；文件的名称(绝对路径)

* 1、listFiles()

* 2、递归

*/

public class TestFIle2 {

public static void main(String[] args){

String path = "/Users/qianjiapeng/Desktop";

File parent = new File(path );

//printName(parent);

//输出所有路径下的所有文件夹

File[] roots = File.listRoots();

System.out.println(Arrays.toString(roots));  //这是一个输出根路径

for (File temp: roots){

printName(temp);

}

}

/**

     * 输出路径

     */

    public static void printName(File src){   //一个递归方法

if(null== src || !src.exists()){

return;

}

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

if(src.isDirectory()){   //如果是文件夹

for(File sub:src.listFiles()){

printName(sub);

}

}

}

}

IO流

一、概念： 

流：流动、流向，从一端移动到另一端。从源头流向目的地。

常见的数据源：程序与文件操作，或者数组，或者网络连接、数据库。以程序为中心。

二、IO流主要用来处理设备间的数据传输 

分类：

1、按照流向分类：输入流、输出流。

2、按照操作类型分类：

字节流：二进制，可以处理一切文件。包括纯文本、doc、音频、视频等等。

字符流：只能处理纯文本。

3、按照功能来分：

节点流：包裹源头的。

处理流：增强功能，提高性能。

三、字符流与字节流（重点）与文件（都是以程序为中心的） 

1、字节流：

输入流：InputStream

方法：read(byte[ ] b) 、read(byte[ ] b, int off ,int len ) 、 close();

FileInputStram();

输出流：OutputStream

方法：write(byte[ ] b) 、write(byte[ ] b, int off, int len )、close()、flush( );

FileOutputStream();

2、字符流：

输入流：Reader

方法：read(char[ ] cbuf) 、read(char[ ] cbuf,int off, int len)、close( );

输出流：Writer

方法：write(char[ ] cbuf )、write(char[ ] cbuf ,int off, int len)、flush()、close( );

1）向文本文件中写出内容

public class FileOutputTest {

public static void main(String[] args){

FileOutputStream fos = null;

try {

//如果该文件不存在，则会自动创建一个。如果有则直接写入

//如果不传true则原本文件的文件内容被覆盖，传入true则在原来的内容后面继续写

//在开发中文件分割符最好不要直接写/。

fos = new FileOutputStream("/Users"+File.separator+"qianjiapeng/IdeaProjects/Java300/src/TestIO/learn2.txt",true);

String meg = "Hello World!";

fos.write(meg.getBytes());

fos.write("\n".getBytes());

2）FileInputStream读取文件

/**

* FileInputStream读取文件

*/

public class Int_Out {

public static void main (String[] args){

FileInputStream fis = null;

try {

//绝对路径

fis = new FileInputStream("/Users/qianjiapeng/IdeaProjects/Java300/src/TestIO/learn.txt");

// System.out.println(fis.read());   //这里打印的是ASCII码。 .read方法，在读取了一个之后将会将游标自动指向下一个

//System.out.println(fis.read());

//System.out.println(fis.read());

//System.out.println(fis.read());

//读取完毕之后会返回-1 ，可以考虑用循环来读取

//使用循环来读取

//每次在硬盘上读一个字节，效率不高

// int temp;

//while ((temp = fis.read())!= -1){

//   char c = (char)temp;

//  System.out.print(c);

//            }

//相对路径，系统会从项目的根目录开始读取

//fis = new FileInputStream("learn.txt");

//定义byte数组告诉系统一次读取几个字节，减少内存和硬盘键的通信，可以提高效率

byte[] arr = new  byte[23];

int temp;

//有参的read方法返回的int值是读取了几个字节

while ((temp=fis.read(arr))!=-1){

System.out.println(new String(arr,0,temp));

}

}catch (FileNotFoundException e){

e.printStackTrace();

}catch (IOException e){

e.printStackTrace();

}finally {

try {

fis.close();

}catch (IOException e){

e.printStackTrace();

}

}

//要捕获一个文件不存在的异常和输入输出异常

}

}

四、操作 

1、举例：搬家             读取文件

1）关联房子               建立与文件联系

2）选择搬家               选择对应流

3）搬家                      文件的读取或写出

a) 卡车大小             数组大小

b) 运输                    读取、写出

4）打发over                释放资源

2、操作

1）建立联系

2）选择流

3）操作

4）释放资源

InputStream、OutputStream、Writer、Reader都是抽象类。

/**

* 1、建立联系 File对象目的地

* 2、选择流   文件输出流 OutputStream FileOutputStream

* 3、操作 :  write() +flush()

* 4、释放资源：关闭

*/

public class Output_Read {

public static void main(String[] args){

// * 1、建立联系 File对象 目的地

File dest = new File("/Users/qianjiapeng/Desktop/2.txt");

// * 2、选择流   文件输出流 OutputStream FileOutputStream

OutputStream os =null;

//以追加的形式写出文件

try {

os = new FileOutputStream(dest,true); //后面是true表示是追加，否则就是覆盖

//3、操作

String str = "good\r\n";

//字符串转字节数组

byte[] data = str.getBytes();

try {

os.write(data,0,data.length);

os.flush(); //强制刷新出去

} catch (IOException e) {

e.printStackTrace();

System.out.println("文件写出失败");

}

} catch (FileNotFoundException e) {

e.printStackTrace();

System.out.println("文件未找到");

}finally {

if(os!=null){

try {

os.close();

} catch (IOException e) {

e.printStackTrace();

System.out.println("关闭输出流失败");

}

}

}

}

}

public class Read_Output {

public static void main ( String[] args ) {

//1、建立联系、File对象

File src = new File("/Users/qianjiapeng/Desktop/2.txt");

InputStream is = null; //因为待会要对这个操作进行关闭，因此在外面定义从而提升作用域

try {

try {

is = new FileInputStream(src);

//3、操作，不读读取 ,相当于缓冲数组

byte[] car = new byte[100];

int len = 0; //接收实际读取的大小

//循环读取

while (-1 != (len = is.read(car))) {

//read()操作读取完后会返回-1，判断是否为-1就可以结束读取了

//输出字节数组转成字符串

String info = new String(car,0,len);

System.out.println(info);

}

} catch (FileNotFoundException e) {

e.printStackTrace();

System.out.println("文件不存在");

} catch (IOException e) {

e.printStackTrace();

System.out.println("读取文件失败");

}

}finally {

//4、释放字节

if(is!=null){  //如果文件本身就不存在，那么也就没有关闭的必要了

try {

is.close();

} catch (IOException e) {

e.printStackTrace();

System.out.println("关闭文件输入流存在");

}

}

}

}

}

}

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

if(src.isDirectory()){   //如果是文件夹

for(File sub:src.listFiles()){

printName(sub);

}

}

}

}