文章标题

import  java .lo.File

/*
IO流  向右反斜杠在Java中是作为转义序列的开始
转义序列后面跟上3个数表示八进制转义
问：\123  为什么不用\1而是用\123呢
答：编译器有着贪婪的原则，

file类既可以表示一个文件，也可以表示一个路径（文件夹）
当我们创建File类型的对象时，在硬盘上不会生成任何的信息
如果要下硬盘上生成相应的文件时，我们需要调用createNewFile方法。
  使用createNewFile创建文件时，文件所在的路径必须存在，
  否则，会产生IOException异常。

 createNewFile()会抛出IOException受检异常，当调用了一个可能会抛受检异常的方法时
 相当于调用者可能会发生受检异常 那就需要处理可以用两种方式
 第一种是把他交个上一级用throws声明,抛到虚拟机时，虚拟机不会处理             
 会把栈信息打印出来，没有实际意义，第二种用try-catch捕huo

 问：如果把file.createNewFile()注释掉会有什么问题
 答：如果try块中不产生任何异常，catch却来捕获这个异常，
 如果是运行时异常不会有什么问题，如果是受检异常，
 就不可以（除了Exception）

*/
public  calss FileTest{
    public static void main(String[] args){
        File file = new File("c:/12345.txt");

        try{
            //创建新的文件
            file.createNewFile();       
           }catch( IOException e ){    
             e.printStackTrace();        
           } 

           //返回文件的名字（12345.txt)
           System.out.println(file.getName());

           //File file = new File(12345.txt");
           //相对路径  返回路径 (包含文件)（12345.txt)
           System.out.println(file.getPath());

            //File file = new File("12345.txt");
            //绝对路径基于Java文件所在的路径
            //返回路径（包含文件）的名字<c:/12345.txt>
            System.out.println(file.getPath());

            //返回父路径信息
            System.out.println(file.getParent());

            //返回file文件对象所表示的文件（夹）是否存在，
            //存在返回true，否则返回false
            System.out.println(file.exist());

            //判断文件是否可写，可写返回true，否则返回false
            System.out.prinltn(file.canWrite());

            //判断文件是否可读，可读返回true，否则返回false
            System.out.println(file.canRead());

            //判断file对象所表示的是否是一个文件，是返回true，否则返回false
            System.out.println(file.isFile());

            //判断file对象所表示的是否是一个路径，是返回true，否则返回false，
            System.out.println(file.isDirectory());

            //返回文件最后一次修改的时间。（毫秒）
            System.out.println(file.lastModifile());
            //获得data时间,
            Date date = new Date(file.lastModifile());
            //对时间进行格式化
            DateFormat df = new SimpleDateFormat("yyyy/MM/dd/ HH:mm:ss");
            System.out.println(df.format(date));

            //返回文件的长度（以字节为单位）
            System.out.println(file.length());


            //删除file所表示的文件（夹）.如果删除成功
            //返回true，否则返回false
            System.out.println(file.delete());

            File dir = new File("c:/abc");
            //创建file所表示的路径（文件夹），
            //如果成功返回true，否则返回false
            System.out.println(dir.madir());

            /*
                mkdir与mkdirs的区别
                mkdir在父路径不存在时，无法创建成功，返回false
                mkdirs在父路径不存在时，
                也能创建成功，会连同父路径一同创建
            */

            //返回file所表示的路径（文件夹），
            //如果成功返回true，否则返回fals
            System.out.println(dir.mkdirs());

            File dir =new File("c:");
            //返回一个String[]，包含当前路径下所有文件和子路径的名字
            String[] names = dir.list();
            for(String name : names){
                System.out.println(name);
            }

            /*
                如果只想要文件或者路径的名字就用String
                如果知道以上还不够，还想知道文件的大小等
                就用file
            */

            //返回一个File[] ，包含当前路径下所有文件和子路径的名字
            File[] files = dir.listFiles();
            for(File f : files){
                System.out.println(f.getName());
            }
    }
}

/*流是一组有顺序的，有起点和终点的数据
Java程序的输入输出功能是通过流（Stream）来实现的
在Java中有关流的操作类存放在Java.io包中


我们是以当前的程序作为参照物，如果要读取数据的时候，
就是把数据源里的数据移动到当前程序中去，这就是《读取》
这个时候数据源里的数据要流向当前的程序，
就是输入流，因此输入流就是读取数据的

当前程序的数据移动到数据源中就是《写入》，
这时数据从当前程序流入到数据源中，这就是输出流
因此输出流就是写入数据的

流的分类
流按照处理数据的单位可以分为两种
1.字节流（8位）
2.字符流（16位）

二进制文件的基本存储单位是字节
文本文件的基本存储单位是字符

字节流和字符流
1.字节流用于处理字节的输入和输出，例如使用字节流读取或则写入
二进制数据
2.字符流为字符输入和输出提供了方便，在某些场合，
字符流比字节流更高效
3.字节流的父类是InputStream和OutputStream
  字符流的父类是Reader 和 Writer

  IntputStream类提供了相应的方法用来给数据源进行读取

  问：读取的是一个字节，为什么返回的是int类型的
  答：因为读取的时候这个字节是无符号的，也就是说返回值是0-255
  byte类型的范围是-128到127且有符号 无符号的最大值会超过有符号
  所以用int类型表示

*/

public class InputStreamTest
{
    public static void main(String[] args){
        System.out.println("Hello World");

        /*
            InputStream是抽象类不能创建对象，使用它的子类
            FileInputStream,  创建FileInputStream的时候会抛出
            受检异常FileNotFoundException,(当读取文件时不确定文件存在不存在，
            如果不存在就会产生异常) 这是就需要对它进行捕获处理
        */
        try{
            //使用InputStream读取文件时，文件必须存在，否则会产生异常
            InputStream input = new FielInputStream("D:/User/123.java");

            //返回剩余可读的字节数
            System.out.println(input.available());

            //读取一个字节，返回所读取的字节，如果到了文件末尾，返回-1
            int data 
            while( (data = input.read()) != -1){
                System.out.println( (char)data );//把读取的字节转换成字符
            }

            byte[] data = new byte[10];
            /*将读取的字节存放在字节数组当中，尽可能去填满字节数组
            返回实际所读取的字节数，如果没有字节可读，返回-1
            问：为什么返回-1
            答：读取的字节是无符号的，其不能取到负数，所以用-1来表示
            */
            int length ;
            while( (length = input.read(data)) != -1 ){
                for(int i = 0;i <length;i++){
                    System.out.println((char) data[i]);
                }
            }

            /*将读取的数组放入字节数组中以第二个参数开始，
            第三个参数长度的区间中，尽可能填满整个区间，
                返回实际所读取的字节数
                */
            while( (length = input.read(data)) != -1 ){
                for(int i = 2; i < length+2;i++){
                    System.out.println((char)data[i]);
                }
            }

            /* 如果读取中文的时候，中文会乱码，因为一次只读取一个字节
                而现在用的编码是UTF-8编码，在其中汉字是占用3个字节，
                英文只占用一个字节，

            */

            //用
            while((length = input.read(data)) != -1){
                //使用byte数组的数据来构建String
                System.out.println(new String(data , 0 , length);
            }

        }catch( FileNotFoundException e){
            e.printStackTrace();
        }
    }
}


/*资源的释放
 try  - with - resources
  try(资源){

  }catch(){

  }finally{

  }
    在try的小括号中可以声明资源，
    资源在try语句块执行完毕后可以得到自动的释放

    什么可以成为try()中的资源？
    资源必须是AutoCloseable的子类型，因为这个借口里面有一个方法
    这个是释放资源所调用的方法，是 void close() throws Exception
    自动释放必须有释放的标准，实现了这个接口或者作为这个接口的子类型
    一定会有这个close()方法


*/
public class Release
{
    public static void main(String[] args){

        InputStream input = null;
        try {
            input = new FileInputStream("D:/eclipse/workspace/test/src/day16/HelloWorld.java");
            input.read();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (input != null) {
                try {
                    input.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }   
        }
    }


    public void tryWithResource() {
        // input流在try语句块执行完毕后，可以得到自动的释放。
        try (InputStream input = new FileInputStream("D:/eclipse/workspace/test/src/day16/HelloWorld.java");) {
            input.read();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

}

/*OutputStream类
1.void write (int b )往流中写一个字节b
2.void write( byte b[])往流中写一个字节数组b
3.void write( byte b[] ,int off,int len)把字节数组b中
从下标off开始，长度为len的字节写入流中
4.flush()刷新输出类，并输出所有被缓存的字节，由于某些流
支持缓存工能，该方法将把缓存中所有内容强制输出到流中
5.close() 流操作完毕后必须关闭
*/

//对于输入流，如果要读取的文件不存在，就会产生FileNotFoundException异常
//对于输出流，如果要写入的文件不存在，但是文件的父路径存在，则该文件会自动创建（不会产生异常）
//如果文件不存在，文件所在路径也不存在，就会产生FileNotFoundEXception异常

public class OutputStream
{
    public static void main(String[] args){
        try(OutputStream out = new FileOutputStream("c:/1234.txt")){
            /*  问：既然可以自动创建文件，FileNotFoundException还捕获干什么
                答：如果文件所在的路径不存在，就会产生异常

            */

            //写入一个字节
            out.write(65);

            //写入一个字节数组
            byte[] b = new byte[]{65,66,67,68};
            out.write(b);

            //写入字节数组的一个区间
            out.write(b,1,2);

            //将String转换成字节数组
            String data = "我想要写入一个String类型";
            out.write(data.getBytes());

        }catch(FileNotFoundException e){
            e.printStackTrace();
        }catch(IOException e){
            e.printStackTrace();
        }   
    }
}

//输入流和输出流综合实例：复制    

public class Copy
{
    publc static void main(String[] args){
        try(InputStream in = new FileInputStream("c:/第15天.pdf");
             OutputStream out = new FileOutputStream("c:/copy.pdf")){

            //一个字节复制
            int data;
            while((data = in.read()) != -1){
                out.write(data);
            }

            //字节数组复制
            byte[] data = new byte[100];
            int length;
            while( (length = in.read()) != -1){
                out.write(data,0,length);
            }
        }catch(FileNotFoundException e){
            e.printStackTrace();
        }catch(IOException e){
            e.printStackTrace();
        }
    }
}