java IO流

package com.service.impl;
import java.awt.image.BufferedImage;
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.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class JavaIo {
    public static void main(String[] args) throws IOException {
        File file= new File("D:/test/a1.txt");
        System.out.println(file.exists());
        try {
            file.createNewFile();
            System.out.println(file.exists());
            System.out.println(file.getName());//获取文件的名字
            System.out.println(file.getAbsolutePath());//获取文件的绝对路径
            System.out.println(file.getPath());//获取文件的相对路径
            System.out.println(file.getParent());//获取文件的父路径
            System.out.println(file.canRead());//文件是否可读
            System.out.println(file.canWrite());//文件是否可写
            System.out.println(file.length());//文件的长度
            System.out.println(file.lastModified());//文件最后一次修改的时间
            System.out.println(file.isDirectory());//判断文件是否是一个目录
            System.out.println(file.isHidden());//文件是否隐藏
            System.out.println(file.isFile());//判断文件是否存在
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        
        
        //list()获取某个目录下所有的文件或者文件夹：
        
        File file=new File("D:/");//指定文件目录
                String[] str=file.list();//获取指定目录下的所有文件或者文件夹的名称数组
                 for(String s : str){//加强for循环遍历输出
                     System.out.println(s);
                }
                 
                 
                 
         File file=new File("D:/");//指定文件路径
                File[] f=file.listFiles();//获取指定目录下的所有文件或者文件夹的File数组
               for(File fi : f){//加强for循环遍历输出
                   System.out.println(fi);
               }
        
            //获取test目录下的JPG格式文件，不包含及子文件夹
            File file = new File("D:\\test");
            String[] a = file.list();
            for(String s:a) {
                if(s.endsWith(".JPG")) {
                    System.out.println(s);
                }
            }
        
        //获取test目录下一级目录JPG格式的文件，并输出路径及文件名
        File file = new File("D:/test");
        File[] b = file.listFiles();
        for(File f:b) {
            if(f.isDirectory()) {
                String[] s = f.list();
                for(String c:s) {
                    if(c.endsWith(".JPG")) {
                        System.out.println(f+"****"+c);
                    }
                }
            }
        }
        
        //FileInputStream和FileOutputStream进行拷贝文本或者图片或者歌曲
        
            FileInputStream fis = new FileInputStream("D:/test/a1.txt");
            FileOutputStream fos = new FileOutputStream("D:/test/test1/sss.txt", true);
            int a;
            while((a=fis.read())!=-1) {
                fos.write(a);
            }
            fis.close();
            fos.close();
        
        
        /** A:缓冲思想
        　　* 字节流一次读写一个数组的速度明显比一次读写一个字节的速度快很多，
        　　* 这是加入了数组这样的缓冲区效果，java本身在设计的时候，
        　　* 也考虑到了这样的设计思想，所以提供了字节缓冲区流
        * B.BufferedInputStream
        　　* BufferedInputStream内置了一个缓冲区(数组)
        　　* 从BufferedInputStream中读取一个字节时
        　　* BufferedInputStream会一次性从文件中读取8192个, 存在缓冲区中, 返回给程序一个
        　　* 程序再次读取时, 就不用找文件了, 直接从缓冲区中获取
        　　* 直到缓冲区中所有的都被使用过, 才重新从文件中读取8192个
        * C.BufferedOutputStream
        　　* BufferedOutputStream也内置了一个缓冲区(数组)
        　　* 程序向流中写出字节时, 不会直接写到文件, 先写到缓冲区中
        　　* 直到缓冲区写满, BufferedOutputStream才会把缓冲区中的数据一次性写到文件里*/
        
        
        //FileInputStream和FileOutputStream定义小数组进行读写操作
        
        FileInputStream fis = new FileInputStream("D:/test/a1.txt");
        FileOutputStream fos = new FileOutputStream("D:/test/test1/nnn.txt",true);//true 表示可以继续往里写，不写true默认为覆盖nnn.txt文件
        int a;
        byte[] b = new byte[1024*8] ;
        while((a=fis.read(b))!=-1) {
            fos.write(b,0,a);
        }
        fis.close();
        fos.close();
        
        
        
        
        FileInputStream fis = new FileInputStream("D:/test/a1.txt");
        FileOutputStream fos = new FileOutputStream("D:/test/test1/buffered.txt",true);
        
        BufferedInputStream bis = new BufferedInputStream(fis);
        BufferedOutputStream bos = new BufferedOutputStream(fos);
        int a;
        while((a=bis.read())!=-1) {
            bos.write(a);
        }
        
        bis.close();
        bos.close();
        
        
        /*      面试题：小数组的读写和带Buffered的读取哪个更快?

                * 定义小数组如果是8192个字节大小和Buffered比较的话
                * 定义小数组会略胜一筹,因为读和写操作的是同一个数组
                * 而Buffered操作的是两个数组
                IO流(flush和close方法的区别) 
                flush()方法： 用来刷新缓冲区的,刷新后可以再次写出（字节缓冲流内置缓冲区，如果没有读取出来，可以使用flush()刷新来）
                close()方法：用来关闭流释放资源的的,如果是带缓冲区的流对象的close()方法,不但会关闭流,还会再关闭流之前刷新缓冲区,关闭后不能再写出
                8：字符流FileReader和FileWriter
                字符流是什么
                　　* 字符流是可以直接读写字符的IO流
                　　* 字符流读取字符, 就要先读取到字节数据, 然后转为字符. 如果要写出字符, 需要把字符转为字节再写出.　　　　
                IO流(什么情况下使用字符流)
                * 字符流也可以拷贝文本文件, 但不推荐使用. 因为读取时会把字节转为字符, 写出时还要把字符转回字节.
                * 程序需要读取一段文本, 或者需要写出一段文本的时候可以使用字符流
                * 读取的时候是按照字符的大小读取的,不会出现半个中文
                * 写出的时候可以直接将字符串写出,不用转换为字节数组
                 
                IO流(字符流是否可以拷贝非纯文本的文件)
                * 不可以拷贝非纯文本的文件
                * 因为在读的时候会将字节转换为字符,在转换过程中,可能找不到对应的字符,就会用?代替,写出的时候会将字符转换成字节写出去
                * 如果是?,直接写出,这样写出之后的文件就乱了,看不了了*/
        
        
        
        
        //字符流的拷贝,容易出现乱码
                 FileReader fr2 = new FileReader("D:/test/a1.txt");
                 FileWriter fw2 = new FileWriter("D:/test/test1/FileWriter.txt");
                 
                 int ch;
                 while((ch = fr2.read()) != -1) {
                    fw2.write(ch);
                }
         
                 fr2.close();
                 fw2.close();
                 
                 
                 FileReader fr2 = new FileReader("D:/test/a1.txt");
                 FileWriter fw2 = new FileWriter("D:/test/test1/FileWriter.txt");
                 BufferedReader br = new BufferedReader(fr2);
                 BufferedWriter bw = new BufferedWriter(fw2);
                 
                 int ch;
                 while((ch = br.read()) != -1) {
                     bw.write(ch);
                }
         
                 br.close();
                 bw.close();        
        
    }

}