java的IO操作

常用的 操作方法：

如：File test = new File("/mnt/sdcard/imags/a.txt");

1、test.getParentFile() //获取 文件名所在的路径，但不包括文件名

2、test.mkdirs()//创建 文件夹

3、test.createNewFile()//创建文件，前提是 文件所在的 路径 必须 存在

4、test.exists()//判断 文件或者文件夹是否存在

5、test.isDirectory()//判断是否是一个目录

5、test.getAbsolutePath()//获取 绝对路径

6、test.delete()//Deletes this file. Directories must be empty before they will be deleted.  Returns:true if this file was deleted,false otherwise.

--------------- 流操作 --------------

File file = new File("/mnt/sdcard/imags/a.txt");

if (!file.getParentFile().exists()) {
    file.getParentFile().mkdirs();
}
InputStream in = conn.getInputStream();//输入流in 和 某个 输入文件关联
FileOutputStream out = new FileOutputStream(file);//输出流out 和 file文件关联
BufferedOutputStream os = new BufferedOutputStream(out);//os和out 关联，相当于os 和 file关联
BufferedInputStream is = new BufferedInputStream(in);//is 和 in关联，相当于 is 和 某个 输入文件

int len = -1;
byte[] buffer = new byte[1024];

while ((len = is.read(buffer)) != -1) {
    os.write(buffer, 0, len);
    os.flush();
}

os.close();
out.close();
is.close();
in.close();

+++++++++++++++++++++++++++++++

String name = "AAAA.txt";
String lujing = "1"+"/"+"2";//定义路径
File a = new File(lujing,name);
那么，a的意义就是“1/2/AAAA.txt”。

这里a是File，Java里，File至少可以表示文件或文件夹。也就是说，在“1/2/AAAA.txt”真正出现在磁盘结构里之前，它既可以表示 这个文件，也可以表示 这个路径的文件夹。那么，如果没有getParentFile(), 直接执行a.mkdirs()，就会直接 创建“1/2/AAAA.txt/”这个的文件夹，在此之后，执行a.createNewFile()，试图创建a文件，然而以a为名的文件夹已经存在了，所以createNewFile()实际是执行失败的。你可以用System.out.println(a.createNewFile())这样来检查是不是真正创建文件成功。

所以，这里，你想要创建的是“1/2/AAAA.txt”这个文件。在创建AAAA.txt之前，必须要1/2这个目录存在。所以，要得到1/2，就要用a.getParentFile()，然后要创建它，也就是a.getParentFile().mkdirs()。在这之后，a作为文件所需要的文件夹存在了，就可以执行a.createNewFile()创建a文件。

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

File类

         为了很方便的代表文件的概念，以及存储一些对于文件的基本操作，在java.io包中设计了一个专门的类——File类。

         在File类中包含了大部分和文件操作的功能方法，该类的对象可以代表一个具体的文件 或 文件夹，所以以前曾有人建议将该类的类名修改成FilePath，因为该类也可以代表一个文件夹，更准确的说是可以代表一个文件路径。

         下面介绍一下File类的基本使用。

         1、File对象代表文件路径 和 代表文件 的例子

File类的对象可以代表一个具体的文件路径，在实际代表时，可以使用绝对路径也可以使用相对路径。

下面是创建的文件对象示例。

                   public File(String pathname)

        该示例中使用一个文件路径表示一个File类的对象，例如：

                   File f1 = new File(“d:\\test\\1.txt”);

                   File f2 = new File(“1.txt”);

                  File f3 = new File(“e:\\abc”);

这里的f1和f2对象分别代表一个文件，f1是绝对路径，而f2是相对路径，f3则代表一个文件夹，文件夹也是文件路径的一种。

public File(String parent, String child)

                           也可以使用父路径和子路径结合，实现代表文件路径，例如：

                                     File f4 = new File(“d:\\test\\”,”1.txt”);

                           这样f4代表一个文件，路径是：d:\test\1.txt。

         2、File类常用方法

File类中包含了很多获得文件或文件夹属性的方法，使用起来比较方便，下面将常见的方法介绍如下：

                   a、createNewFile方法

                                     public boolean createNewFile() throws IOException

该方法的作用是创建指定的文件。该方法只能用于创建文件，不能用于创建文件夹，且文件路径中包含的文件夹必须存在。

                   b、delect方法

                                     public boolean delete()

该方法的作用是删除当前文件或文件夹。如果删除的是文件夹，则该文件夹必须为空。如果需要删除一个非空的文件夹，则需要首先删除该文件夹内部的每个文件和文件夹，然后在可以删除，这个需要书写一定的逻辑代码实现。

                   c、exists方法

                                     public boolean exists()

                           该方法的作用是判断当前文件或文件夹是否存在。

                   d、getAbsolutePath方法

                                     public String getAbsolutePath()

该方法的作用是获得当前文件或文件夹的绝对路径。例如c:\test\1.t则返回c:\test\1.t。

                   e、getName方法

                                     public String getName()

                           该方法的作用是获得当前文件或文件夹的名称。例如c:\test\1.t，则返回1.t。

                   f、getParent方法

                                     publicStringgetParent()

                           该方法的作用是获得当前路径中的父路径。例如c:\test\1.t则返回c:\test。

             getParentfile()返回 file

                   g、isDirectory方法

                                     public boolean isDirectory()

                           该方法的作用是判断当前File对象是否是目录。

                   h、isFile方法

                                     public boolean isFile()

                           该方法的作用是判断当前File对象是否是文件。

                   i、length方法

                                     public long length()

该方法的作用是返回文件存储时占用的字节数。该数值获得的是文件的实际大小，而不是文件在存储时占用的空间数。

                   j、list方法

                                     public String[] list()

该方法的作用是返回当前文件夹下所有的文件名和文件夹名称。说明，该名称不是绝对路径。

                   k、listFiles方法

                                     public File[] listFiles()

                           该方法的作用是返回当前文件夹下所有的文件对象。

                   l、mkdir方法

                                     public boolean mkdir()

该方法的作用是创建当前文件文件夹，而不创建该路径中的其它文件夹。假设d盘下只有一个test文件夹，则创建d:\test\abc文件夹则成功，如果创建d:\a\b文件夹则创建失败，因为该路径中d:\a文件夹不存在。如果创建成功则返回true，否则返回false。

                   m、mkdirs方法

                                     public boolean mkdirs()

该方法的作用是创建文件夹，如果当前路径中包含的父目录不存在时，也会自动根据需要创建。

                   n、renameTo方法

                                     public boolean renameTo(File dest)

该方法的作用是修改文件名。在修改文件名时不能改变文件路径，如果该路径下已有该文件，则会修改失败。

                   o、setReadOnly方法

                                     public boolean setReadOnly()

                           该方法的作用是设置当前文件或文件夹为只读。

         3、File类基本示例

                  以上各方法实现的测试代码如下：

                            import java.io.File;

/**

 * File类使用示例

 */

public class FileDemo {

         public static void main(String[] args) {

                   //创建File对象

                   File f1 = new File("d:\\test");

                   File f2 = new File("1.txt");

                   File f3 = new File("e:\\file.txt");

                   File f4 = new File("d:\\","1.txt");

                   //创建文件

                   try{

                            boolean b = f3.createNewFile();

                   }catch(Exception e){

                            e.printStackTrace();

                   }

                   //判断文件是否存在

                   System.out.println(f4.exists());

                   //获得文件的绝对路径

                   System.out.println(f3.getAbsolutePath());

                   //获得文件名

                   System.out.println(f3.getName());

                   //获得父路径

                   System.out.println(f3.getParent());

                   //判断是否是目录

                   System.out.println(f1.isDirectory());

                   //判断是否是文件

                   System.out.println(f3.isFile());

                   //获得文件长度

                   System.out.println(f3.length());

                   //获得当前文件夹下所有文件和文件夹名称

                   String[] s = f1.list();

                   for(int i = 0;i < s.length;i++){

                            System.out.println(s[i]);

                   }

                   //获得文件对象

                   File[] f5 = f1.listFiles();

                   for(int i = 0;i < f5.length;i++){

                            System.out.println(f5[i]);

                   }

                   //创建文件夹

                   File f6 = new File("e:\\test\\abc");

                   boolean b1 = f6.mkdir();

                   System.out.println(b1);

                   b1 = f6.mkdirs();

                   System.out.println(b1);

                   //修改文件名

                   File f7 = new File("e:\\a.txt");

                   boolean b2 = f3.renameTo(f7);

                   System.out.println(b2);

                   //设置文件为只读

                   f7.setReadOnly();             

         }

}

         4、File类综合示例

下面以两个示例演示File类的综合使用。第一个示例是显示某个文件夹下的所有文件和文件夹，原理是输出当前名称，然后判断当前File对 象是文件还是文件夹，如果则获得该文件夹下的所有子文件和子文件夹，并递归调用该方法实现。第二个示例是删除某个文件夹下的所有文件和文件夹，原理是判断 是否是文件，如果是文件则直接删除，如果是文件夹，则获得该文件夹下所有的子文件和子文件夹，然后递归调用该方法处理所有子文件和子文件夹，然后将空文件 夹删除。则测试时谨慎使用第二个方法，以免删除自己有用的数据文件。示例代码如下：

                            import java.io.File;

/**

 *文件综合使用示例

 */

public class AdvanceFileDemo {

         public static void main(String[] args) {

                   File f = new File("e:\\Book");

                   printAllFile(f);

                   File f1 = new File("e:\\test");

                   deleteAll(f1);

         }

        

         /**

          *打印f路径下所有的文件和文件夹

          * @param f文件对象

          */

         public static void printAllFile(File f){

                   //打印当前文件名

                   System.out.println(f.getName());

                   //是否是文件夹

                   if(f.isDirectory()){

                            //获得该文件夹下所有子文件和子文件夹

                            File[] f1 = f.listFiles();

                            //循环处理每个对象

                            int len = f1.length;

                            for(int i = 0;i < len;i++){

                                     //递归调用，处理每个文件对象

                                     printAllFile(f1[i]);

                            }

                   }

         }

        

         /**

          *删除对象f下的所有文件和文件夹

          * @param f文件路径

          */

         public static void deleteAll(File f){

                   //文件

                   if(f.isFile()){

                            f.delete();

                   }else{ //文件夹

                            //获得当前文件夹下的所有子文件和子文件夹

                            File f1[] = f.listFiles();

                            //循环处理每个对象

                            int len = f1.length;

                            for(int i = 0;i < len;i++){

                                     //递归调用，处理每个文件对象

                                     deleteAll(f1[i]);

                            }

                            //删除当前文件夹

                            f.delete();

                   }

         }

}

         关于File类的使用就介绍这么多，其它的方法和使用时需要注意的问题还需要多进行练习和实际使用。

读取文件 -- 流

按照前面介绍的知识，将文件中的数据读入程序，是将程序外部的数据传入程序中，应该使用输入流——InputStream或Reader。而由于读取的是特定的数据源——文件，则可以使用输入对应的子类FileInputStream或FileReader实现。

         在实际书写代码时，需要首先熟悉读取文件在程序中实现的过程。在Java语言的IO编程中，读取文件是分两个步骤：

1、将文件中的数据转换为流，

2、读取流内部的数据。其中第一个步骤由系统完成，只需要创建对应的流对象即可，对象创建完成以后步骤1就完成了，第二个步骤使用输入流对象中的read方法即可实现了。

         使用输入流进行编程时，代码一般分为3个部分：1、创建流对象，2、读取流对象内部的数据，3、关闭流对象。

下面以读取文件的代码示例：

                   import java.io.*;

/**

 *使用FileInputStream读取文件

 */

public class ReadFile1 {

         public static void main(String[] args) {

                   //声明流对象

                   FileInputStream fis = null;                 

                   try{

                            //创建流对象

                            fis = newFileInputStream("e:\\a.txt");

                            //读取数据，并将读取到的数据存储到数组中

                            byte[] data = new byte[1024]; //存储数据的数组

                            int i = 0; //当前下标

                            //读取流中的第一个字节数据

                            int n = fis.read();

                            //依次读取后续的数据

                            while(n != -1){ //未到达流的末尾，这里；有问题 如果 本身 数据是 -1，这种情况；

                                     //将有效数据存储到数组中

                                     data[i] = (byte)n;

                                     //下标增加

                                     i++;

                                     //读取下一个字节的数据

                                      n = fis.read();

                            }

                           

                            //解析数据

                            String s = new String(data,0,i);

                            //输出字符串

                            System.out.println(s);

                   }catch(Exception e){

                            e.printStackTrace();

                   }finally{

                            try{

                                     //关闭流，释放资源

                                     fis.close();

                            }catch(Exception e){}

                   }

         }

}

         在该示例代码中，首先创建一个FileInputStream类型的对象fis：

                   fis = new FileInputStream("e:\\a.txt");

         这样建立了一个连接到数据源e:\a.txt的流，并将该数据源中的数据转换为流对象fis，以后程序读取数据源中的数据，只需要从流对象fis中读取即可。

        读取流fis中的数据，需要使用read方法，该方法是从InputStream类中继承过来的方法，该方法的作用是每次读取流中的一个字节，如果需要读取流中的所有数据，需要使用循环读取，当到达流的末尾时，read方法的返回值是-1。

         在该示例中，首先读取流中的第一个字节：

                   int n = fis.read();

         并将读取的值赋值给int值n，如果流fis为空，则n的值是-1，否则n中的最后一个字节包含的时流fis中的第一个字节，该字节被读取以后，将被从流fis中删除。

         然后循环读取流中的其它数据，如果读取到的数据不是-1，则将已经读取到的数据n强制转换为byte，即取n中的有效数据——最后一个字节，并存储到数组data中，然后调用流对象fis中的read方法继续读取流中的下一个字节的数据。一直这样循环下去，直到读取到的数据是-1，也就是读取到流的末尾则循环结束。

         这里的数组长度是1024，所以要求流中的数据长度不能超过1024，所以该示例代码在这里具有一定的局限性。如果流的数据个数比较多，则可以将1024扩大到合适的个数即可。

         经过上面的循环以后，就可以将流中的数据依次存储到data数组中，存储到data数组中有效数据的个数是i个，即循环次数。

         其实截至到这里，IO操作中的读取数据已经完成，然后再按照数据源中的数据格式，这里是文件的格式，解析读取出的byte数组即可。

         该示例代码中的解析，只是将从流对象中读取到的有效的数据，也就是data数组中的前n个数据，转换为字符串，然后进行输出。

         在该示例代码中，只是在catch语句中输出异常的信息，便于代码的调试，在实际的程序中，需要根据情况进行一定的逻辑处理，例如给出提示信息等。

         最后在finally语句块中，关闭流对象fis，释放流对象占用的资源，关闭数据源，实现流操作的结束工作。

         上面详细介绍了读取文件的过程，其实在实际读取流数据时，还可以使用其它的read方法，下面的示例代码是使用另外一个read方法实现读取的代码：

                   import java.io.FileInputStream;

/**

 *使用FileInputStream读取文件

 */

public class ReadFile2 {

         public static void main(String[] args) {

                   //声明流对象

                   FileInputStream fis = null;                 

                   try{

                            //创建流对象

                            fis = new FileInputStream("e:\\a.txt");

                            //读取数据，并将读取到的数据存储到数组中

                            byte[] data = new byte[1024]; //数据存储的数组

                            int i = fis.read(data);

                           

                            //解析数据

                            String s = new String(data,0,i);

                            //输出字符串

                            System.out.println(s);

                   }catch(Exception e){

                            e.printStackTrace();

                   }finally{

                            try{

                                     //关闭流，释放资源

                                     fis.close();

                            }catch(Exception e){}

                   }

         }

}

        该示例代码中，只使用一行代码：

                   int i = fis.read(data);

        就实现了将流对象fis中的数据读取到字节数组data中。该行代码的作用是将fis流中的数据读取出来，并依次存储到数组data中，返回值为实际读取的有效数据的个数。

         使用该中方式在进行读取时，可以简化读取的代码。

         当然，在读取文件时，也可以使用Reader类的子类FileReader进行实现，在编写代码时，只需要将上面示例代码中的byte数组替换成char数组即可。

使用FileReader读取文件时，是按照char为单位进行读取的，所以更适合于文本文件的读取，而对于二进制文件或自定义格式的文件来说，还是使用FileInputStream进行读取，方便对于读取到的数据进行解析和操作。

读取其它数据源的操作和读取文件类似，最大的区别在于建立流对象时选择的类不同，而流对象一旦建立，则基本的读取方法是一样，如果只使用最基本的read方法进行读取，则使用基本上是一致的。这也是IO类设计的初衷，使得对于流对象的操作保持一致，简化IO类使用的难度。

 程。

         基本的输出流包含OutputStream和Writer两个，区别是OutputStream体系中的类(也就是OutputStream的子类)是按照字节写入的，而Writer体系中的类(也就是Writer的子类)是按照字符写入的。

         使用输出流进行编程的步骤是：

                   1、建立输出流

                            建立对应的输出流对象，也就是完成由流对象到外部数据源之间的转换。

                   2、向流中写入数据

                            将需要输出的数据，调用对应的write方法写入到流对象中。

                   3、关闭输出流

                            在写入完毕以后，调用流对象的close方法关闭输出流，释放资源。

         在使用输出流向外部输出数据时，程序员只需要将数据写入流对象即可，底层的API实现将流对象中的内容写入外部数据源，这个写入的过程对于程序员来说是透明的，不需要专门书写代码实现。

         在向文件中输出数据，也就是写文件时，使用对应的文件输出流，包括FileOutputStream和FileWriter两个类，下面以FileOutputStream为例子说明输出流的使用。示例代码如下：

                   import java.io.*;

/**

 * 使用FileOutputStream写文件示例

 */

public class WriteFile1 {

         public static void main(String[] args) {

                   String s = "Java语言";

                   int n = 100;

                   //声明流对象

                   FileOutputStream fos = null;

                   try{

                            //创建流对象

                            fos = new FileOutputStream("e:\\out.txt");

                            //转换为byte数组

                            byte[] b1 = s.getBytes();

                            //换行符

                            byte[] b2 = "\r\n".getBytes();

                            byte[] b3 = String.valueOf(n).getBytes();

                            //依次写入文件

                            fos.write(b1);

                            fos.write(b2);

                            fos.write(b3);

                   } catch (Exception e) {

                            e.printStackTrace();

                   }finally{

                            try{

                                     fos.close();

                            }catch(Exception e){}

                   }

         }

}

         该示例代码写入的文件使用记事本打开以后，内容为：

                   Java语言

100

         在该示例代码中，演示了将一个字符串和一个int类型的值依次写入到同一个文件中。在写入文件时，首先创建了一个文件输出流对象fos：

                   fos = new FileOutputStream("e:\\out.txt");

         该对象创建以后，就实现了从流到外部数据源e:\out.txt的连接。说明：当外部文件不存在时，系统会自动创建该文件，但是如果文件路径中包含未创建的目录时将出现异常。这里书写的文件路径可以是绝对路径也可以是相对路径。

         在 实际写入文件时，有两种写入文件的方式：覆盖和追加。其中“覆盖”是指清除原文件的内容，写入新的内容，默认采用该种形式写文件，“追加”是指在已有文件 的末尾写入内容，保留原来的文件内容，例如写日志文件时，一般采用追加。在实际使用时可以根据需要采用适合的形式，可以使用：

                   public FileOutputStream(String name, boolean append) throws FileNotFoundException

         只需要使用该构造方法在构造FileOutputStream对象时，将第二个参数append的值设置为true即可。

         流对象创建完成以后，就可以使用OutputStream中提供的wirte方法向流中依次写入数据了。最基本的写入方法只支持byte数组格式的数据，所以如果需要将内容写入文件，则需要把对应的内容首先转换为byte数组。

         这里以如下格式写入数据：首先写入字符串s，使用String类的getBytes方法将该字符串转换为byte数组，然后写入字符串“\r\n”，转换方式同上，该字符串的作用是实现文本文件的换行显示，最后写入int数据n，首先将n转换为字符串，再转换为byte数组。这种写入数据的顺序以及转换为byte数组的方式就是流的数据格式，也就是该文件的格式。因为这里写的都是文本文件，所以写入的内容以明文的形式显示出来，也可以根据自己需要存储的数据设定特定的文件格式。

         其实，所有的数据文件，包括图片文件、声音文件等等，都是以一定的数据格式存储数据的，在保存该文件时，将需要保存的数据按照该文件的数据格式依次写入即可，而在打开该文件时，将读取到的数据按照该文件的格式解析成对应的逻辑即可。

         最后，在数据写入到流内部以后，如果需要立即将写入流内部的数据强制输出到外部的数据源，则可以使用流对象的flush方法实现。如果不需要强制输出，则只需要在写入结束以后，关闭流对象即可。在关闭流对象时，系统首先将流中未输出到数据源中的数据强制输出，然后再释放该流对象占用的内存空间。

         使用FileWriter写入文件时，步骤和创建流对象的操作都和该示例代码一致，只是在转换数据时，需要将写入的数据转换为char数组，对于字符串来说，可以使用String中的toCharArray方法实现转换，然后按照文件格式写入数据即可。

         对于其它类型的字节输出流/字符输出流来说，只是在逻辑上连接不同的数据源，在创建对象的代码上会存在一定的不同，但是一旦流对象创建完成以后，基本的写入方法都是write方法，也需要首先将需要写入的数据按照一定的格式转换为对应的byte数组/char数组，然后依次写入即可。

         所以IO类的这种设计形式，只需要熟悉该体系中的某一个类的使用以后，就可以触类旁通的学会其它相同类型的类的使用，从而简化程序员的学习，使得使用时保持统一。