黑马程序员——java学习10（IO流）

---------------------- ASP.Net+Android+IO开发S、 .Net培训、期待与您交流！ ----------------------

一、  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>  
 

[java] view plaincopy 
<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)            向此文件写入指定的字节。

1.        public class RandomAccessFileDemo{  
2.                  public static void main(String args[]) throws Exception{  
3.                  File f = new File("G:" + File.separator + "test.txt") ;    
4.                  RandomAccessFile rdf = null ;         
5.                  rdf = new RandomAccessFile(f,"r") ;// 以只读的方式打开文件  
6.                  String name = null ;  
7.                  int age = 0 ;  
8.                  byte b[] = new byte[12] ;      
9.                  // 读取第二个人的信息，意味着要空出第一个人的信息  
10.                  rdf.skipBytes(12) ;         
11.                  for(int i=0;i<b.length;i++){  
12.                      b[i] = rdf.readByte() ;   
13.                 }  
14.                  name = new String(b) ;    // 将读取出来的byte数组变为字符串  
15.                 age = rdf.readInt() ;   
16.                 System.out.println("第二个人的信息 --> 姓名：" + name + "；年龄：" + age) ;  
17.                  rdf.seek(0) ;      
18.                  for(int i=0;i<b.length;i++){  
19.                      b[i] = rdf.readByte() ;    
20.                  }  
21.                  name = new String(b) ;    // 将读取出来的byte数组变为字符串  
22.                  age = rdf.readInt() ;   
23.                  System.out.println("第一个人的信息 --> 姓名：" + name + "；年龄：" + age) ;  
24.                 rdf.skipBytes(12) ;     
25.                 for(int i=0;i<b.length;i++){  
26.                      b[i] = rdf.readByte() ;     
27.                  }  
28.                  name = new String(b) ;    // 将读取出来的byte数组变为字符串  
29.                  age = rdf.readInt() ;    
30.                 System.out.println("第三个人的信息 --> 姓名：" + name + "；年龄：" + age) ;  
31.                  rdf.close() ;                // 关闭  
32.                 }  
33.               }</span>  

---------------------- ASP.Net+Android+IO开发S、 .Net培训、期待与您交流！ ----------------------