Java File类和IO流

       IO流是整个Java开发包中最复杂的一个（重要）。那么我们一句话概括它的核心：“根据实例化子类的不同，完成的功能也不同”。

       学习它是需要些基础的，比如java的面向对象概念，要理解什么是抽象类。这里顺便说下个人对抽象类的理解，其实说抽象的话，很多人会懵的，确实是抽象了些，如果我们把它想成我们平常比较熟悉的事物或知识点，那就不一样咯！比如我就把抽象类看成是“套路”；在很多类中出现相同的功能或者很多事物中出现相同的特征，就可以归纳出他们相同的功能或特征，用一个类作为这些类的老大类（父类），老大类里面定义归纳过来的功能和特征为方法，不用去实现这些方法。

       File类是文件和目录的抽象表示形式，也是整个IO包中唯一一个与文件本身有关的操作类。文件本身是指文件的创建、查询、删除等操作。一个File类被创建时，它就不能再被改变内容。注意：在Java.IO包中的File类本身是一个跨平台的文件操作类，因此在操作中更多的要考虑到各个操作系统的区别。文件的概念：文件可以认为是相关记录或者放在一起的数据的集合。

       File类的创建：File类的创建有两种写法。IO流：字节流与字符流（重中之重 ）

       第1种写法：使用方法来创建文件，public boolean createNewFile() throws IOException    

 

package com.example;
import java.io.File;
public class MyClass {
    public static void main(String args[]) throws Exception{
        //File的构造：public File(String pathname)，directoryPath是文件的路径名
        //有三个构造函数可以用来生成File 对象：
        //File(String directoryPath)
        //File(String directoryPath, String filename)
        //File(File dirObj, String filename)
        //directoryPath是文件的路径名,filename是文件名,dirObj一个指定目录的File对象
        //建立File对象的时候需要指定一个路径
        File file=new File("D:\\temp.txt");
        file.createNewFile();
    }
}

 

      第二种写法：这种写法用的相对多一些

 

package com.example;

import java.io.File;
import java.io.IOException;

/**
 * Created by Dell on 2017/3/20.
 */
public class MyFile {
    public static void main(String args[]){
        MyFile myFile=new MyFile();
        myFile.createFile();
    }
    public  void createFile(){
        File file=new File("F:\\texts.txt");
        if (file.exists()){//判断文件是否存在  
            try {
                file.createNewFile();//创建文件
            }catch (IOException e){
                e.printStackTrace();
            }
        }
    }
}

      接下来讲File类的一些常用方法：

 

创建方法：

1.boolean createNewFile() //不存在返回true 存在返回false
2.boolean mkdir() //创建目录
3.boolean mkdirs()// 创建多级目录

判断方法：

1.boolean canExecute()//判断文件是否可执行
2.boolean canRead()//判断文件是否可读
3.boolean canWrite() //判断文件是否可写
4.boolean exists()// 判断文件是否存在
5.boolean isDirectory()//判断是否是目录
6.boolean isFile()//判断是否是文件
7.boolean isAbsolute()//判断是否是绝对路径 文件不存在也能判断

获取方法：

1.String getName()//获取文件名
2.String getPath()//获取文件
3.String getAbsolutePath()//路径
4.String getParent()//如果没有父目录返回null
5.long lastModified()//获取最后一次修改的时间
6.long length()//获取文件长度
7.boolean renameTo(File f)
8.File[] liseRoots()//获取机器盘符
9.String[] list()//列出文件全部内容
10.String[] list(FilenameFilter filter)//列出文件全部内容

删除方法：

1.boolean delete()// 删除文件
2.boolean deleteOnExit() //文件使用完成后删除

 

IO流：字节流与字符流（重中之重 ）

 

Java中的流，可以从不同的角度进行分类。

按照数据流的方向不同可以分为：输入流和输出流。

按照处理数据单位不同可以分为：字节流和字符流。

按照实现功能不同可以分为：节点流和处理流。

      字节流(8位二进制)和字符流(16位二进制)的原理是相同的，只不过处理的单位不同而已。后缀是Stream是字节流，而后缀是Reader，Writer是字符流。

 

     File类本身是与文件操作有关，如果想要操作文件里的内容则需要使用字节流或字符流来完成。不管是使用何种的输入输出流，其基本的操作原理是一样的（一文件流为准），

基本步骤：
     1.使用File类找到一个文件
     2.通过字节流或者字符流的子类进行对象的实例化
     3.进行读或写的操作
     4.最后关闭字节流或字符流（由于流的操作属于资源操作，所以在操作最后一步一定要关闭以释放资源。）

InputStream字节输入流：

      此类是抽象类，需要子类去完成文件输入，子类FileInputStream是经常用到的一个，它提供了最基础的文件读取数据操作。字节流有个特殊的地方，就是需要一个创建好且开辟了空间大小的数组来接受内容。

package com.example;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
/**
 * Created by Dell on 2017/3/20.
 */
public class MyFileInputStream {
    public static void main(String args[]){
        File file=new File("F:\\texts.txt");
        try {
            //根据文件流对象创建输入流
            InputStream inputStream=new FileInputStream(file);
            //创建字节数组
            byte buf[]=new byte[1024];
            //接受输入流的内容
            int ln=inputStream.read(buf);
            System.out.println("内容是+("+new String(buf,0,ln)+")");
        }catch (Exception e){

        }
    }
}

来点难的例子：

package com.example;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
/**
 * Created by Dell on 2017/3/20.
 */
public class MyFileInputStream {
    public static void main(String args[]){
        String path="F:\\texts.txt";//文件路径
        try {
            File file=new File(path);//根据文件名创建文件对象
            //判断文件是否存在，或是文件还是文件夹
            if (!file.exists()||file.isDirectory()){
                System.out.println("该文件不存在或是文件夹");
            }
            //根据文件流对象创建输入流
            FileInputStream fis=new FileInputStream(file);
            byte buf[]=new byte[1024];//创建字节数组
            StringBuffer sb=new StringBuffer();//创建一个字符串
            //按单个字节方式循环输入流中读文件数据，读到文件末尾（返回-1）
            //结束读取操作
            while ((fis.read(buf))!=-1){
                sb.append(new String(buf));
                buf=new byte[1024];//从新生成，避免和上次读取的数据重复
            }
            System.out.println(sb.toString());//打印输出文件内容
            fis.close();//关闭流
        }catch (Exception e){

        }
    }
}

OutputStream字节输出流：

      本类同样是抽象类，需要子类FileOutputStream子类去完成输出。

package com.example;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
/**
 * Created by Dell on 2017/3/20.
 */
public class MyFileOutputStream {
    public static void main(String args[]) {
        File file=new File("F:\\texts.txt");
        try {
            //实例化FileOutputStream对象
             FileOutputStream fops=new FileOutputStream(file);
            //要输出的字符串内容
             String info="Hello world";
            //将字符串转换为字节数组
             byte data[]=info.getBytes();
            fops.write(data);//输出内容
             fops.close();//关闭流
        }catch (IOException e){
            e.printStackTrace();
        }
    }
}

如果想要在末尾追加怎么办呢？只需改这两个地方即可

 

FileOutputStream fops=new FileOutputStream(file,true);//追加

String info="\r\nHello world";

字符流：

      FileReader类是完全继承了父类Reader的文件操作方法，只是重新构造了构造方法，方便创建字符流对象。

package com.example;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
/**
 * Created by Dell on 2017/3/21.
 */
public class MyFileReader {
    public static void main(String args[]){
        String mtxt=null;//用于存储文件的内容
        int mcount=0;//用于记录有多少行
        try {
            //根据文件路径创建输入流
            FileReader fr=new FileReader("F:\\texts.txt");
            //根据fr对象创建输入流缓冲区对象br
            BufferedReader br=new BufferedReader(fr);
            //br.readLine()从文件中读取一行数据
            while ((mtxt=br.readLine())!=null){
                mcount++;
                //打印文件内容并输出是第几行
                System.out.println();
            }
            br.close();//关闭流
        }catch (IOException e){
            e.printStackTrace();
        }
    }
}

       字符输出流我们写一个简单的吧！老套路，Writer是抽象类，那么跟它最亲的子类是FileWriter

package com.example;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;
/**
 * Created by Dell on 2017/3/21.
 */
public class MyFileWriter {
    public static void main(String args[]){
        File file=new File("F:\\texts.txt");
        try {
            Writer wt=new FileWriter(file);
            wt.write("Hello world!");
            wt.close();
        }catch (IOException e){
            e.printStackTrace();
        }
    }
}

字节流和字符流的区别：

      区别就是字节流不需要缓冲区且可以不关闭流，而字符流需要缓冲区且需要关闭流。

 

 

参考文献：

http://www.open-open.com/doc/view/63b0ce3147624878955b3404a35958bb   Java IO操作

http://blog.csdn.net/yuebinghaoyuan/article/details/7388059/    Java IO流分析整理