一、  File类

         1.用来将文件或或者文件夹封装成对象

         2.方便对文件与文件夹的属性进行操作（流只能操作数据）

         3.File对象可以作为参数传递给流的构造函数

         4.聊解File类中的常用方法

      

         File类常见方法：

         1，创建。

            boolean createNewFile():

          //在指定位置创建文件，如果该文件已经存在，则不创建，返回false。

          //和输出流不一样，输出流对象一建立创建文件。而且文件已经存在，会覆盖。

            boolean mkdir():创建文件夹。

            boolean mkdirs():创建多级文件夹。

         2，删除。

             boolean delete()：删除失败返回false。如果文件正在被使用，则删除不了返回falsel。

             void deleteOnExit();在程序退出时删除指定文件。

         3，判断。

            boolean exists() :文件是否存在.

            isFile():

            isDirectory();

            isHidden();

            isAbsolute();

         4，获取信息。

            getName():

            getPath():

            getParent():

            getAbsolutePath() 

            long lastModified()

            long length()

实例代码：

<span style="font-size:18px;">     public class Iotest
         {
            public static void main(String[] args) throws IOException
            {
                 method05();
            }
             public static void method05()
             {
                 File f1 = new File("c:\\Test.java");
                File f2 = new File("d:\\hahah.java");
                sop("rename:"+f2.renameTo(f1));
       }
              public static void method04()
             {
                 File f = new File("file.txt");
                 sop("path:"+f.getPath());
                 sop("abspath:"+f.getAbsolutePath());
                 sop("parent:"+f.getParent());
                //该方法返回的是绝对路径中的父目录。如果获取的是相对路径，返回null。
                //如果相对路径中有上一层目录那么该目录就是返回结果。
             }
             public static void method03()throws IOException
            {
                 File f = new File("d:\\java\\test.txt");
               //创建文件
                  f.createNewFile();
                 //创建目录
                 //f.mkdir();
                 //记住在判断文件对象是否是文件或者目的时，必须要先判断该文件对象封装的内容是否存在。
                 //通过exists判断。
                 sop("dir:"+f.isDirectory());
                 sop("file:"+f.isFile());
               //判断是否是绝对路径
                 sop(f.isAbsolute());
            }
            public static void method02()
             {
                 File f = new File("file.txt");
                File dir = new File("java\\test\\testme");
                     sop("mkdir:"+dir.mkdirs());
             }
                public static void method01()throws IOException
                      {
                        File f = new File("file.txt");
                      }
                //创建File对象
             public static void consMethod()
             {
                 //将a.txt封装成file对象。可以将已有的和为出现的文件或者文件夹封装成对象。
                 File f1 = new File("a.txt");
                 //指定目录下的文件
                 File f2 = new File("D:\\abc","b.txt");
                 File d = new File("D:\\abc");
                 File f3 = new File(d,"c.txt");
                 sop("f1:"+f1);
                 sop("f2:"+f2);
                 sop("f3:"+f3);
                 File f4 = new File("c:"+File.separator+"abc"+File.separator+"sss"+File.separator+"a.txt");
             }
           //方便打印对象
             public static void sop(Object obj)
             {
                 System.out.println(obj);
             }
         }</span>

 

       IO包中的其他类：

          *打印流：

            PrintWriter与PrintStream

             可以直接操作输入流和文件

         *序列流

            sequenceInputStream

            对多个流进行合并

          *操作对象：

           ObjectInputSteam与ObjectOutputStream

            被操作的兑现更要实现Serealizable(标记接口)

           Serializalble接口：对象序列化即使把一个对象变为二进制的数据流的一种方法，通过对象实例化，可以方便地实现独享的传输或存储。

 

转换流的字符编码：

         ASCII:美国标准洗洗交换表用一个字节的7位表示；

         ISO8859-1：拉丁码表。欧洲码表用一个字节的8位表示

         GB2312：中国的中文编码表。

         GBK:中国饿中文编码表升级，融合了更多的中文文字符号。

         Unicode:国际标准码，融合了多种文字，所有文字都用两个字节来表示，JAVA语言使用的就是UNICODE

         UTF_8:最多用三个字节来表示一个字符.

  字节流和字符流的转换：

         OutputStreamWriter：是Writer的子类，将输出的字符流变为字节流，即将一个字符流的输出对象变为字节流的输出对象。

         InputSttreamReader: 是Reader的子类, 将输入的字节流变为字符流，即将一个字节流的输入对象变为字符流的输入对象。

          如果以文件的操作为例，则内存中的字符流需要通过OutputStreamWriter变为字节流才能保存文件，读取时需要将读入的字节流通过InputSteamReader变为字符流。代码示例：

        

<span style="font-size:18px;">public class InputStreamReaderDemo{
       public static void main(String args[]) throws Exception{
             File f = new File("d:" + File.separator + "test.txt") ;
             Reader reader = null ;
             reader = new InputStreamReader(new FileInputStream(f)) ;    // 将字节流变为字符流
             char c[] = new char[1024] ;
             int len = reader.read(c) ;    // 读取
             reader.close() ;    // 关闭
             System.out.println(new String(c,0,len)) ;
       }
}</span>

 

<span style="font-size:18px;">public class OutputStreamWriterDemo01{
    public static void main(String args[]) throws Exception {   // 所有异常抛出
        File f = new File("d:" + File.separator + "test.txt") ;
        Writer out = null ; // 字符输出流
        out = new OutputStreamWriter(new FileOutputStream(f)) ; // 字节流变为字符流
        out.write("hello world!!") ;    // 使用字符流输出
        out.close() ;
    }
}</span>

RandromAccessFile类：

         该类不算是IO体系中子类，而是继承自Object。但他是IO包中成员，因为它具备写和读的功能。

         内部封装了一个数组，而且通过指针对数组的元素进行操作。

         可以通过getFilePointer获取指针位置。

         同时可以通过seek改变指针的位置。

         其实完成读写的原理即使内部风转过了字节流和输入流

         主要操作方法：

         read()           从此文件中读取一个数据字节。

         readLine()       从此文件读取文本的下一行。

         close()         关闭此随机访问文件流并释放与该流关联的所有系统资源。

         readInt()         从此文件读取一个有符号的整数。

         write(byte[] b, int off, int len)           将 len 个字节从指定 byte 数组写入到此文件，并从偏移量 off 处开始。

         write(int b)            向此文件写入指定的字节。

<span style="font-size:18px;">         public class RandomAccessFileDemo{
                 public static void main(String args[]) throws Exception{
                 File f = new File("G:" + File.separator + "test.txt") ;
                 RandomAccessFile rdf = null ;
                 rdf = new RandomAccessFile(f,"r") ;// 以只读的方式打开文件
                 String name = null ;
                 int age = 0 ;
                 byte b[] = new byte[12] ;
                 // 读取第二个人的信息，意味着要空出第一个人的信息
                 rdf.skipBytes(12) ;
                 for(int i=0;i<b.length;i++){
                     b[i] = rdf.readByte() ;
                }
                 name = new String(b) ;    // 将读取出来的byte数组变为字符串
                age = rdf.readInt() ;
                System.out.println("第二个人的信息 --> 姓名：" + name + "；年龄：" + age) ;
                 rdf.seek(0) ;
                 for(int i=0;i<b.length;i++){
                     b[i] = rdf.readByte() ;
                 }
                 name = new String(b) ;    // 将读取出来的byte数组变为字符串
                 age = rdf.readInt() ;
                 System.out.println("第一个人的信息 --> 姓名：" + name + "；年龄：" + age) ;
                rdf.skipBytes(12) ;
                for(int i=0;i<b.length;i++){
                     b[i] = rdf.readByte() ;
                 }
                 name = new String(b) ;    // 将读取出来的byte数组变为字符串
                 age = rdf.readInt() ;
                System.out.println("第三个人的信息 --> 姓名：" + name + "；年龄：" + age) ;
                 rdf.close() ;                // 关闭
                }
              }</span>