java__IO_02

package cn.itcast.file;

import java.io.File;
import java.io.FilenameFilter;
/*
需求1 ：  指定一个文件夹，然后该文件夹下面所有java文件。

需求2： 指定一个文件夹，然后列出文件夹下面的所有子文件与文件夹，但是格式要如下:

文件：
    文件名1
    文件名2
    文件名3
    ..

文件夹：
    文件夹名1
    文件夹名2
    文件夹名3
    ....

    listFiles(FilenameFilter filter)    返回指定当前目录中符合过滤条件的子文件或子目录。对于文件这样操作会返回null。
list(fileNameFilter filter) 返回指定当前目录中符合过滤条件的子文件或子目录。对于文件这样操作会返回null。

*/

// 自定义一个文件名过滤器
class MyFilter implements FilenameFilter{

    @Override
    public boolean accept(File dir, String name) {
        //System.out.println("文件夹:"+dir+" 文件名："+ name);
        return name.endsWith(".java");
    }

}

public class Demo7 {

    public static void main(String[] args) {
        File dir = new File("F:\\1208\\day06\\代码\\day06");
        listJava2(dir);

    }

    public static void listJava2(File dir){
        File[] files = dir.listFiles(new MyFilter()); //得到文件夹下面的所有子文件与文件夹。
        for(File file : files){
            System.out.println(file.getName());
        }
    }

    //列出所有的java文件
    public static void listJava(File dir){
        File[] files = dir.listFiles(); //获取到了所有的子文件
        for(File file : files){
            String fileName = file.getName();
            /*if(fileName.endsWith(".java")&&file.isFile()){
                System.out.println(fileName);
            }*/

            if(fileName.matches(".+\\.java")&&file.isFile()){
                System.out.println(fileName);
            }

        }
    }

    public static void listFile(File dir){
        File[] files = dir.listFiles();//获取到所有的子文件
        System.out.println("文件：");
        for(File fileItem : files){
            if(fileItem.isFile()){
                System.out.println("\t"+fileItem.getName());
            }
        }       
        System.out.println("文件假：");
        for(File fileItem : files){
            if(fileItem.isDirectory()){
                System.out.println("\t"+fileItem.getName());
            }
        }

    }

}

判断输出或输入的依据

package cn.itcast.input;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

/*
 File类: 用于描述一个文件或者文件夹的。

 通过File对象我们可以读取文件或者文件夹的属性数据，如果我们需要读取文件的内容数据，那么我们需要使用IO流技术。

IO流（Input Output）

IO流解决问题： 解决设备与设备之间的数据传输问题。  内存--->硬盘   硬盘--->内存


IO流技术：


IO流分类：
    如果是按照数据的流向划分：

        输入流


        输出流

    如果按照处理的单位划分：

        字节流: 字节流读取得都是文件中二进制数据，读取到二进制数据不会经过任何的处理。


        字符流： 字符流读取的数据是以字符为单位的 。 字符流也是读取文件中的二进制数据，不过会把这些二进制数据转换成我们能 识别的字符。  
                字符流 = 字节流 + 解码

输入字节流：
--------| InputStream 所有输入字节流的基类  抽象类
------------| FileInputStream  读取文件数据的输入字节流 

使用FileInputStream读取文件数据的步骤：
    1. 找到目标文件
    2. 建立数据的输入通道。
    3. 读取文件中的数据。
    4. 关闭 资源.



 */
public class Demo1 {

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

    //方式4：使用缓冲数组配合循环一起读取。28
    public static void readTest4() throws IOException{
        long startTime = System.currentTimeMillis();
        //找到目标文件
        File file = new File("F:\\美女\\1.jpg");
        //建立数据的输入通道
        FileInputStream fileInputStream = new FileInputStream(file);
        //建立缓冲数组配合循环读取文件的数据。
        int length = 0; //保存每次读取到的字节个数。
        byte[] buf = new byte[1024]; //存储读取到的数据    缓冲数组 的长度一般是1024的倍数，因为与计算机的处理单位。  理论上缓冲数组越大，效率越高

        while((length = fileInputStream.read(buf))!=-1){ // read方法如果读取到了文件的末尾，那么会返回-1表示。
            System.out.print(new String(buf,0,length));
        }

        //关闭资源
        fileInputStream.close();


        long endTime = System.currentTimeMillis();
        System.out.println("读取的时间是："+ (endTime-startTime)); //446
    }


    //方式3：使用缓冲 数组 读取。    缺点： 无法读取完整一个文件的数据。     12G
    public static void readTest3() throws IOException{
        //找到目标文件
        File file = new File("F:\\a.txt");
        //建立数据的输入通道
        FileInputStream fileInputStream = new FileInputStream(file);
        //建立缓冲字节数组，读取文件的数据。
        byte[] buf = new byte[1024];  //相当于超市里面的购物车。
        int length = fileInputStream.read(buf); // 如果使用read读取数据传入字节数组，那么数据是存储到字节数组中的，而这时候read方法的返回值是表示的是本次读取了几个字节数据到字节数组中。
        System.out.println("length:"+ length);

        //使用字节数组构建字符串
        String content = new String(buf,0,length);
        System.out.println("内容："+ content);
        //关闭资源
        fileInputStream.close();
    }





    //方式2 ： 使用循环读取文件的数据
    public static void readTest2() throws IOException{
        long startTime = System.currentTimeMillis();
        //找到目标文件
        File file = new File("F:\\美女\\1.jpg");
        //建立数据的输入通道
        FileInputStream fileInputStream = new FileInputStream(file);
        //读取文件的数据
        int content = 0; //声明该变量用于存储读取到的数据
        while((content = fileInputStream.read())!=-1){
            System.out.print((char)content);
        }
        //关闭资源
        fileInputStream.close();

        long endTime = System.currentTimeMillis();
        System.out.println("读取的时间是："+ (endTime-startTime)); //446
    }



    //读取的方式一缺陷： 无法读取完整一个文件 的数据.
    public static void readTest1() throws IOException{
        //1. 找到目标文件
        File file = new File("F:\\a.txt");
        //建立数据的输入通道。
        FileInputStream fileInputStream = new FileInputStream(file);
        //读取文件中的数据
        int content = fileInputStream.read(); // read() 读取一个字节的数据，把读取的数据返回。
        System.out.println("读到的内容是："+ (char)content);
        //关闭资源    实际上就是释放资源。 
         fileInputStream.close();
    }


}

package cn.itcast.input;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
/*
 问题1： 读取完一个文件的数据的时候，我不关闭资源有什么影响?
 答案： 资源文件一旦 使用完毕应该马上释放，否则其他的程序无法对该资源文件进行其他 的操作。





 */
import java.util.Arrays;


public class Demo2 {

    public static void main(String[] args) throws IOException {
        //找到目标文件 //i不能读取doc文档
        File file = new File("F:\\day18-day21.IO.doc");
        //建立数据的输入通道
        FileInputStream fileInputStream = new FileInputStream(file);
        //建立缓冲字节数组读取文件
        byte[] buf = new byte[8];
        int length = 0 ;

        while((length = fileInputStream.read(buf))!=-1){
            System.out.print(new String(buf));  // aaaa   bbba  bbb' '
//      System.out.println(Arrays.toString(buf));
        }
        //释放文件资源
        fileInputStream.close();


    }

}

package cn.itcast.output;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

/*
需求： 拷贝一张图片。
*/
public class CopyImage {


    public static void main(String[] args) throws IOException {
        //找到目标文件
        File inFile = new File("F:\\美女\\1.jpg");
        File destFile = new File("E:\\1.jpg");
        //建立数据的输入输出通道
        FileInputStream fileInputStream = new  FileInputStream(inFile);
        FileOutputStream fileOutputStream = new FileOutputStream(destFile); //追加数据....

        //每新创建一个FileOutputStream的时候，默认情况下FileOutputStream 的指针是指向了文件的开始的位置。 每写出一次，指向都会出现相应移动。
        //建立缓冲数据，边读边写
        byte[] buf = new byte[1024]; 
        int length = 0 ; 
        while((length = fileInputStream.read(buf))!=-1){ //最后一次只剩下了824个字节
            fileOutputStream.write(buf,0,length); //写出很多次数据，所以就必须要追加。
        }
        //关闭资源 原则： 先开后关，后开先关。
        fileOutputStream.close();
        fileInputStream.close();
    }

}

package cn.itcast.output;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

/*
 输出字节流：

 --------| OutputStream 是所有输出字节流 的父类。  抽象类
 -----------| FileOutStream 向文件输出数据的输出字节流。

FileOutputStream如何使用呢？
    1. 找到目标文件
    2. 建立数据的输出通道。
    3. 把数据转换成字节数组写出。
    4. 关闭资源

FileOutputStream要注意的细节：
    1. 使用FileOutputStream 的时候，如果目标文件不存在，那么会自动创建目标文件对象。 
    2. 使用FileOutputStream写数据的时候，如果目标文件已经存在，那么会先清空目标文件中的数据，然后再写入数据。
    3.使用FileOutputStream写数据的时候, 如果目标文件已经存在，需要在原来数据基础上追加数据的时候应该使用new FileOutputStream(file,true)构造函数，第二参数为true。
    4.使用FileOutputStream的write方法写数据的时候，虽然接收的是一个int类型的数据，但是真正写出的只是一个字节的数据，只是
    把低八位的二进制数据写出，其他二十四位数据全部丢弃。

     00000000-000000000-00000001-11111111   511


     11111111---> -1 



 */


public class Demo1 {

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


    //使用字节数组把数据写出。
    public static void writeTest3() throws IOException{
        //找到目标文件
        File file = new File("F:\\b.txt");
        //建立数据输出通道
        FileOutputStream fileOutputStream = new FileOutputStream(file);
        //把数据写出。
        String data = "abc";
        byte[] buf = data.getBytes();
        fileOutputStream.write(buf, 0, 3); // 0 从字节数组的指定索引值开始写， 2：写出两个字节。

        //关闭资源
        fileOutputStream.close();
    }



    //使用字节数组把数据写出。
    public static void writeTest2() throws IOException{
        //找到目标文件
        File file = new File("F:\\b.txt");
        //建立数据输出通道
        FileOutputStream fileOutputStream = new FileOutputStream(file,true);
        //把数据写出。并换行
        String data = "\r\nhello world";
        fileOutputStream.write(data.getBytes());
        //关闭资源
        fileOutputStream.close();
    }



    //每次只能写一个字节的数据出去。
    public static void writeTest1() throws IOException{
        //找到目标文件
        File file = new File("F:\\b.txt");
        //建立数据的输出通道
        FileOutputStream fileOutputStream = new FileOutputStream(file);
        //把数据写出
        fileOutputStream.write('h');
        fileOutputStream.write('e');
        fileOutputStream.write('l');
        fileOutputStream.write('l');
        fileOutputStream.write('o');
        //关闭资源
        fileOutputStream.close();


    }


}

package cn.itcast.exception;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

import javax.management.RuntimeErrorException;

/*
 IO异常 的处理

 */
public class Demo1 {

    public static void main(String[] args) {
    //  readTest();

        copyImage();
    }

    // 拷贝图片
    public static void copyImage() {
        FileInputStream fileInputStream = null;
        FileOutputStream fileOutputStream = null;

        try {
            // 找到目标文件
            File inFile = new File("F:\\美女\\1.jpg");
            File outFile = new File("E:\\1.jpg");
            // 建立输入输出通道
            fileInputStream = new FileInputStream(inFile);
            fileOutputStream = new FileOutputStream(outFile);
            // 建立缓冲数组，边读边写
            byte[] buf = new byte[1024];
            int length = 0;
            while ((length = fileInputStream.read(buf)) != -1) {
                fileOutputStream.write(buf, 0, length);
            }
        } catch (IOException e) {
            System.out.println("拷贝图片出错...");
            throw new RuntimeException(e);
        } finally {
            // 关闭资源
            try {
                if (fileOutputStream != null) {
                    fileOutputStream.close();
                    System.out.println("关闭输出流对象成功...");
                }
            } catch (IOException e) {
                System.out.println("关闭输出流资源失败...");
                throw new RuntimeException(e);
            } finally {
                if (fileInputStream != null) {
                    try {
                        fileInputStream.close();
                        System.out.println("关闭输入流对象成功...");
                    } catch (IOException e) {
                        System.out.println("关闭输入流对象失败...");
                        throw new RuntimeException(e);
                    }
                }

            }
        }
    }

    public static void readTest() {
        FileInputStream fileInputStream = null;
        try {
            // 找到目标文件
            File file = new File("F:\\aaaaa.txt");
            // 建立数据输入通道
            fileInputStream = new FileInputStream(file);
            // 建立缓冲数组读取数据
            byte[] buf = new byte[1024];
            int length = 0;
            while ((length = fileInputStream.read(buf)) != -1) {
                System.out.print(new String(buf, 0, length));
            }
        } catch (IOException e) {
            /*
             * //处理的代码... 首先你要阻止后面的代码执行,而且要需要通知调用者这里出错了... throw new
             * RuntimeException(e);
             * //把IOException传递给RuntimeException包装一层，然后再抛出，这样子做的目的是
             * 为了让调用者使用变得更加灵活。
             */
            System.out.println("读取文件资源出错....");
            throw new RuntimeException(e);
        } finally {
            try {
                if (fileInputStream != null) {
                    fileInputStream.close();
                    System.out.println("关闭资源成功...");
                }
            } catch (IOException e) {
                System.out.println("关闭资源失败...");
                throw new RuntimeException(e);
            }
        }
    }

}

package cn.itcast.buffered;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

/*
 我们清楚读取文件数据使用缓冲数组读取效率更高，sun也知道使用缓冲数组读取效率更高，那么
 这时候sun给我们提供了一个------缓冲输入字节流对象,让我们可以更高效率读取文件。


输入字节流体系： 
----| InputStream  输入字节流的基类。 抽象
----------| FileInputStream 读取文件数据的输入字节流
----------| BufferedInputStream 缓冲输入字节流    缓冲输入字节流的出现主要是为了提高读取文件数据的效率。    
其实该类内部只不过是维护了一个8kb的字节数组而已。 

注意： 凡是缓冲流都不具备读写文件的能力。

使用BufferedInputStream的步骤    :
    1. 找到目标文件。
    2. 建立数据 的输入通道
    3. 建立缓冲 输入字节流流
    4. 关闭资源


 */


public class Demo1 {

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

    public static void readTest2() throws IOException{
        //找到目标文件
        File file = new File("F:\\a.txt");

        FileInputStream fileInputStream= new FileInputStream(file);
        BufferedInputStream bufferedInputStream= new BufferedInputStream(fileInputStream);
        bufferedInputStream.read();



        FileOutputStream fileOutputStream= new FileOutputStream(file);
        BufferedOutputStream bufferedOutputStream= new BufferedOutputStream(fileOutputStream);
        fileOutputStream.write(null);

        //读取文件数据
        int content = 0 ;
        //疑问二：BufferedInputStream出现 的目的是了提高读取文件的效率，但是BufferedInputStream的read方法每次读取一个字节的数据
        //而FileInputStreram每次也是读取一个字节的数据，那么BufferedInputStream效率高从何而来？
        while((content = fileInputStream.read())!=-1){
            System.out.print((char)content);
        }

        //关闭资源
        bufferedInputStream.close();//调用BufferedInputStream的close方法实际上关闭的是FileinputStream.
    }



    //读取文件的时候我们都是使用缓冲数组读取。效率会更加高
    public static void readTest() throws IOException{
        File file = new File("F:\\a.txt");
        //建立数组通道
        FileInputStream fileInputStream = new FileInputStream(file);
        //建立缓冲数组读取数据
        byte[] buf = new byte[1024*8];
        int length = 0; 
        while((length = fileInputStream.read(buf))!=-1){
            System.out.print(new String(buf,0,length));
        }
        //关闭资源
        fileInputStream.close();
    }


}

package cn.itcast.buffered;

import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

/*
输出字节流
--------| OutputStream  所有输出字节流的基类  抽象类
------------| FileOutputStream 向文件 输出数据 的输出字节流
------------| Bufferedoutputstream  缓冲输出字节流    BufferedOutputStream出现的目的是为了提高写数据的效率。 
                                内部也是维护了一个8kb的字节数组而已。

 使用BufferedOutputStream的步骤：
    1. 找到目标文件
    2. 建立数据的输出通道


BufferedOutputStream 要注意的细节
    1. 使用BufferedOutStream写数据的时候，它的write方法是是先把数据写到它内部维护的字节数组中。
    2. 使用BufferedOutStream写数据的时候，它的write方法是是先把数据写到它内部维护的字节数组中，如果需要把数据真正的写到硬盘上面，需要
    调用flush方法或者是close方法、 或者是内部维护的字节数组已经填满数据的时候。



 */
public class Demo2 {

    public static void main(String[] args) throws IOException {
        //找到目标文件
        File file = new File("F:\\a.txt");
        //建立数据的输出通道
        FileOutputStream  fileOutputStream = new FileOutputStream(file);
        //建立缓冲输出字节流对象
        BufferedOutputStream bufferedOutputStream  = new BufferedOutputStream(fileOutputStream);
        //把数据写出
        bufferedOutputStream.write("hello world".getBytes()); 
        //把缓冲数组中内部的数据写到硬盘上面。
        //bufferedOutputStream.flush();
        bufferedOutputStream.close();
    }

}

package cn.itcast.buffered;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

/*
练习： 使用缓冲输入输出字节流拷贝一个图片。

*/
public class CopyImage {

    public static void main(String[] args) throws IOException {
        //找到目标文件
        File  inFile = new File("F:\\美女\\1.jpg");
        File outFile = new File("E:\\1.jpg");
        //建立数据输入输出通道
        FileInputStream fileInputStream = new FileInputStream(inFile);
        FileOutputStream fileOutputStream = new FileOutputStream(outFile);
        //建立缓冲输入输出流
        BufferedInputStream bufferedInputStream = new BufferedInputStream(fileInputStream);
        BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(fileOutputStream);
        //边读边写
        int content = 0; 
        // int length = bufferedInputStream.read(buf);   如果传入了缓冲数组，内容是存储到缓冲数组中，返回值是存储到缓冲数组中的字节个数。
        while((content = bufferedInputStream.read())!=-1){ // 如果使用read方法没有传入缓冲数组，那么返回值是读取到的内容。
            bufferedOutputStream.write(content);
//          bufferedOutputStream.flush();
        }
        //关闭资源
        bufferedInputStream.close();
        bufferedOutputStream.close();



    }

}