java入门了解10

1.IO:
　　1.File
　　　　(一)注意：
　　　　　　a.可以表示文件或者文件夹（也可称为目录）
　　　　　　b.创建的File对象实际上不存在的文件只是代表了一个抽象路径
　　　　　　c.Windows中分隔符'\'('//'也可以);Unix/Linux'\';更专业的写法：File.pathSeparatorChar
　　　　（二）绝对路径相对路径
　　　　　　a.Unix，绝对路径前缀‘/’就可以了,Windows前缀由“c:\\..”；
　　　　　　　　Unix没有相对路径，Windows相对路径没有盘符前缀‘.’当前目录；‘..’上级目录
　　　　（三）File实例常用方法：
　　　　　　createNewFile();
　　　　　　mkdir():在指定的位置创建最后一级目录，如果上级目录不存在就会报错
　　　　　　mkdirs():创建指定目录，如果上级目录不存在就创建
　　　　　　renameTo(File dest)重命名文件夹
　　　　　　delete():删除文件或文件夹，如果文件夹不为空删不了
　　　　　　判断：exists();isFile();isDirectory();isHidden();isAbsolute();
　　　　　　获取：getName();getPath();getAbsolutePath();length();getParent();lastModified();
　　　　　　listRoots()：这个返回所有的根目录；
　　　　　　list():返回目录下的文件，文件的话返回null
　　　　　　list(FilenameFilter filter)返回指定当前目录中符合过滤条件的文件或者文件夹
　　　　　　listFiles():返回目录下的文件或者目录（File类实例）

　　　　（四）题目
　　　　　　a.列出指定目录中所有的子孙文件与子孙目录名，只需要列出名称即可
　　　　　　b.列出指定目录中所有扩展名为.java的文件,写一个工具类传入一个参数后缀名
　　　　　　这里列出代码：
　　　　　

    /**
     * 从指定路径中找到所有的文件和文件夹
     * @param path
     */
    public static void listAllFilesAndDirs(String path){
        File f1=new File(path);
        File[] files=f1.listFiles();
        for(File i:files){
            if(i.isFile()){
                System.out.println(("子文件："));
                System.out.println("\t" + i.getName());
            }else if(i.isDirectory()){
                System.out.println(("子目录："));
                System.out.println("\t" + i.getName());
            }
        }
    }

/**
     * 从指定路径中找出指定扩展名的文件
     * @param path
     * @param extension
     */
    public static void listAllFiles(String path,String extension){
        File f1=new File(path);
        File[] names=f1.listFiles();
        for(File i:names){
            if(i.getName().endsWith(extension)){
                System.out.println(i.getName());
            }
        }
    }

　　2.IO流
　　　　（一）注意：
　　　　　　a.File能表示存在文件也可表示不存在，但我们想要操作文件内容就需要IO流技术
　　　　　　b.java对设备中数据通过流来操作；设备是指硬盘，内存，网络等
　　　　　　c.java中操作流的对象都在IO包中
　　　　　　d.流分类.数据类型：字节流；字符流;按流向：输入流；输出流
　　　　（二）字节流：
　　　　　　a.计算机中数据都是以字节流的方式存储的，我们的64位操作系统就是指最大流宽度8个字节
　　　　　　b.基类java.io.InputStream;java.io.OutputStream
　　　　　　c.字节流处理的单位是字节，用于操作二进制文件
　　　　（三）InputStream输入字节流基类抽象类
　　　　　　a.FileInputStream:读取文件数据的输入字节流
　　　　　　步骤：1.找到目标文件
　　　　　　        2.建立数据输入通道
　　　　　  　　　3.读取文件中数据
　　　　　　  　　4.关闭资源
　　　　　　注意：读完文件一定要释放资源否则别人不能使用
　　　　　　例子：

    /**
     * 这个方法只能读取一部分，大小由存放流数据文件的buff决定
     * 因为文件读取到buff满了后没有地方可放了
     * 所以正确的还要加个循环就好了
     * @param path
     * @throws IOException
     */
    public static void readTest1(String path) throws IOException{
        File f=new File(path);
        FileInputStream fis=new FileInputStream(f);
        byte[] buff=new byte[1024*67];
        int length=fis.read(buff);
        System.out.println("length:"+ length);
        String content=new String(buff,0,length);
        System.out.println(content);
        fis.close();
    }
    /**
     * 完善后的读取文件都能读取了
     * @param path
     * @throws IOException
     */
    public static void readTest2(String path) throws IOException{
        File f=new File(path);
        FileInputStream f1=new FileInputStream(f);
        byte[] buff=new byte[1024];
        int length=0;//存放读取的文件长度
        int lenz=0;
        while((length=f1.read(buff))!=-1){
            System.out.print(new String(buff,0,length));
            lenz+=length;
        }
        System.out.println(lenz);
        f1.close();
    }

　　　　　　b.BufferedInputStream:就是维护了一个8kb的字节数组
　　　　　　　步骤：1.找到目标文件
　　　　　　　　2. 建立缓冲输入字节流
　　　　　　　　3.读取
　　　　　　　　注意：凡是缓冲流都不具备读写文件的能力
　　　　　　　　提问：1.为什么创建BufferInputStream时需要传递FileInputStream?
　　　　　　　　　　　　 BufferInputStream 本身不具备读文件的能力，所有需要借助FileInputStream来读取数据
　　　　　　　　　　　2.BufferInputStream出现目的是提高读取文件的效率，但是BufferInputStream方法每次读取一个字节数据 而FileInputStream每次也是只读一个字节的数据，那么这个东西它效率高的原因？

这个需要查看器read()方法发现原因：本质原因是内存读取速度快要硬盘读取速度；
                                   内部原理：先获取8kb数据放到缓存区中，然后再从缓存区中一个字节一个字节获取数据，所有这里的每次获取一个字节和FileInputStream每次获取一个字节所处读取环境不一样一个是内存一个是硬盘

　　　　　　例子：复制文件

    public static void copyImage1(String pathfrom,String pathTo) throws IOException{
        File f1=new File(pathfrom);
        File f2=new File(pathTo);

        FileInputStream input=new FileInputStream(f1);
        FileOutputStream output=new FileOutputStream(f2);

        byte[] buff=new byte[1024];
        int length=0;
        while((length=input.read(buff))!=-1){
            output.write(buff, 0, length);
        }

        output.close();
        input.close();
    }

　　　　（四）OutputStream输出字节流基类抽象类
　　　　　　a.FileOutStream向文件输入数据
　　　　　　步骤：1找到目标文件
　　　　　　　　2.建立数据输出通道
　　　　　　　　3.读取文件中的数据
　　　　　　　　4.关闭资源
　　　　　　注意：1.使用FileOutStream时，如果目标文件不存在，那么会创建
　　　　　　　　2.使用期写数据时，如果目标文件已存在，会清空目标文件中的数据，然后再写入
　　　　　　　　3.如果想要在已存在的目标文件中末尾写，需要new FileOutStream(file,true)//第二个参数为true才行
　　　　　　　　4.write()方法如果传入的是数字，他也只会截取前8位一个字节的大小
　　　　　　例子：public static void writeTest1() throws IOException{
　　　　　　　　　　File f=new File("C:/a/e.txt");
　　　　　　　　　　FileOutputStream out=new FileOutputStream(f);
　　　　　　　　　　String content="adasdfasdf";
　　　　　　　　　　//out.write('a');
　　　　　　　　　　out.write(content.getBytes());
　　　　　　　　　　out.close();
　　　　　　　　　}
　　　　（五）例子：
　　　　　　　a.复制文件

public static void copyImage1(String pathfrom,String pathTo) throws IOException{
        File f1=new File(pathfrom);
        File f2=new File(pathTo);

        FileInputStream input=new FileInputStream(f1);
        FileOutputStream output=new FileOutputStream(f2);

        byte[] buff=new byte[1024];
        int length=0;
        while((length=input.read(buff))!=-1){
            output.write(buff, 0, length);
        }

        output.close();
        input.close();
}

b.用缓冲输入输出字节复制文件

public static void copyFile(String pathFrom,String pathTo) throws IOException{
         File f=new File(pathFrom);
         File t=new File(pathTo);

         FileInputStream fis=new FileInputStream(f);
         FileOutputStream fos=new FileOutputStream(t);

         BufferedInputStream buffI=new BufferedInputStream(fis);
         BufferedOutputStream buffO=new BufferedOutputStream(fos);
         //边读边写
         int content=0;
          //int length=buffI.read(buffer)//如果传入了缓冲数组，内容是存储到缓冲数组中，返回值是存储到缓冲数组中的字节个数。
         while((content=buffI.read())!=-1){//read没有传参数返回值就是读取到的内容
         buffO.write(content);
     }
     buffO.close();
     buffI.close();
}
 

　　3.IO异常处理(这里是比较麻烦的)：
　　　　注意：IO异常时，代码后面都不需要执行了所以必须用throw关键字阻止后面代码执行且能出现异常信息
　　　　　　　　每次关资源的时候也需要这样弄下
　　　　　　　　我们抛出的异常用RuntimeException（e）本质是抛出e，但是有这个包着，编译器就不会认为是IO异常立马让我们处理
　　　　模板例子：

public static void copyFile(String pathForm,String pathTo){
       FileInputStream input=null;
       FileOutputStream output=null;
       try{
            File f1=new File(pathForm);
            File f2=new File(pathTo);
            input =new FileInputStream(f1);
            output=new FileOutputStream(f2);
            int length=0;
            byte[] buff=new byte[1024];
            while((length=input.read(buff))!=-1){
                  output.write(buff, 0, length);
             }
        }catch(IOException e){
           //IO异常，后后面的代码就不进行了所以用throw
          throw new RuntimeException(e);
        }
        finally{
                  try{
                        if(output!=null){
                                 output.close();
                                 System.out.println("关闭输出流对象成功...");
                         }
                       }catch(IOException e){
                         System.out.println("关闭输出流资源失败...");
                         throw new RuntimeException(e);
                       }finally{
                                   try{
                                      if(input!=null){
                                                    input.close();
                                                    System.out.println("关闭输入流资源成功...");
                                      }
                                  }catch(IOException e){
                                      System.out.println("关闭输入流资源失
败...");
                                      throw new RuntimeException(e);
                                  }

                     }

             }

}