Java文件流

File 类

• 什么是文件？ 相关记录或放在一起的数据的集合

• 文件流主要的一些方法:

      // 创建文件实例，建立磁盘上的文件和对象的影像。
      File file = new File("pathname")    
     //   文件属性
      boolean b = file.exists()   //判断文件是否存在。
      file.createNewFile()    //创建一个新文件  需要try-catch  
      file.isFile()   //是否是文件  
      file.getPath()     //返回一个相对地址。
      file.getAbsoultPath //返回一个文件的绝对路径名 
      file.getName        //返回文件名的名称
      file.length()    //返回文件的长度，单位为字节，如果文件不存在，则返回OL
      flie.isDirectory()  //判断是否是目录
      file.delete         //删除此对象指定的文件或目录 
      flie.mkdir          //创建此抽象路径名指定的目录
      flie.mkdirs      
      flie.list()         //将flie下的文件和目录返回一个String[]的数组。  
      flie.listFiles()    //将file 下的文件和目录返回一个File[]的数组 。
      //创建此抽象路径名指定的目录，包括所有必需但不存在的目录。
  

  ~~- 文件名的过滤

• FilenameFilter()
• File file = new file
• file.list(new )~~

Demo1:递归删除文件下的所有文件和目录（因为delete()方法删除不掉里面有文件的目录）

import java.io.File;

public class deleteMuliteDir {
    /**
     * 创建递归删除的方法 
     * @param curent 要删除的文件
     * @return 是否删除成功
     */
    public static boolean delete(File curent) {
        // 如果是目录，对目录的文件执行本方法进行删除。
        if (curent.isDirectory()) {
            for (File file : curent.listFiles()) {
                delete(file);
            }
        }
        // 返回删除是否成功
        return curent.delete();
    }

    public static void main(String[] args) {
        File file = new File("d:/1");
        boolean b = delete(file);
        System.out.println(b);
    }
}

• 在Java中，目录页被看作是文件。

  ---

• RandomaAccessFile类

  • RandomAccessFiLe对像的文件位置指针遵循下面的规律:
    
    • 可以通过getFilePointer方法来获得文件位置指针的的位置，通过seek/skipBytes的方法来设置文件指针的位置。
    • 每次读写操作之后，文件位置的指针都相应后移到读写的字节数；
    • 新建RandomAccessFile对象的文件位置指针位于文件的开头处。

Java流向的分类

• 整个JavaI/O框架都在java.io中。
• 如何读写文件？
  
  • 通过流来读写文件:流是一组有序的数据序列,以先进先出方式发送信息的通道
• 输入流： InputStream和Reader
• 输出流 OutputStream和Writer
• 读文件的的时候，要使用输入流，写文件的时候使用输出流。
  
  • 输入输出流是相对于计算机内存来说。
  • 从中读入数据序列的对象称为输入流
• 来源流和接受流都是节点流。
• 节点流可被认为是：文件、内存以及线程或进程之间的管道。
  内存和文件之间的通讯、网络之间的通讯。
  一个字符 两个字节。

String = new String

---

• Java流向的分类
  按流向区分：输出流和输入流
  

按流向分	基类	按处理数据分	基类
输入流	InputStream和Reader	字节流	InputStream和OutputStream
输出流	OutputStreamWriter	字符流	Reader和Witer

输入输出流是相对与计算机内存来说；
字节流是8位通用字节流，字符流是16位Unicode字符流。
以上类均是抽象类，只能他的子类来实例化。

另外还有一种包装流，相当于其延伸 BufferedReader //为了提高封装性能。
String str = new String(byte,”UTF-8”) //将字节转换成字符串
byte [] bytes = str.getBytes(“utf-8”) //将字符串转换成字节 后面将会用到。
- InputStream 抽象类
- int read() //一次读一个字节 读取到结尾，返回-1。
- int read(byte[] b) //从流中读取一个字符，存储在byte[]数组中。
- read(byte[] b, int off, int len) //从流中off开始读取最多len个字节，存入b数组中
- int available()：可以从输入流中读取的字节数目

读取文件步骤：

FileInputStream extends InputStram 来实现。
- 创建对象；
- 读取数据；
- 关闭文件；

    FlieInputStream fis =null;
    public class FileDemo {
    public static void main(String[] args) {
        FileInputStream fis = null;
        //创建流对象
        try {
            fis = new FileInputStream("d:/a.txt");
            int i;
            byte [] b =new byte[1024];
            //循环读数据 read()方法是从输入流读取1个8位的字节，把它转化为0-255之间的整数返回。将返回的整数转换为字符
            while ((i = fis.read(b)) != -1) {
                String str = new String(b);
                System.out.print(str);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                //关闭流对象
                fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

FileOutStream

• OutputStream类常用方法
  
  • write(int c)
  • write(byte[] buf)
  • write(byte[] b,int off,int len)
  • close()
  • flush()：// 强制把缓冲区的数据写到输出流中
    示例：文件的拷贝

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

/**
 * 将文件从d:/我的青春我做主.txt的内容拷贝到桌面的myPrime.txt中。
 */

public class FileCopyDemo {
    public static void main(String[] args) {
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try {
            // 创建输入流
            fis = new FileInputStream("d:/我的青春我做主.txt");
            // 创建输出流
            fos = new FileOutputStream(
                    "C:/Users/Administrator/Desktop/myPrime.txt");
            byte[] b = new byte[1024];
            int data = -1;
            // 循环读取文件，并写入。
            while ((data = fis.read(b)) != -1) {
                // 写入文件，write写入的文件不存在时，会自动创建，但不会创建文件夹。
                fos.write(b,0,data);
                // 控制台中展示读取的数据。
                String str = new String(b);
                System.out.print(str);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                // 关闭输入流及输出流
                fis.close();
                fos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

---

Reader类

int read ();  
int read (char[] c)  
read(char [] c,int off,int len)  
void close();  

- 子类InputStreamReader
- FileReader类是InputStreamReader
- FileReader(String name)
- StringBuffer sbf
示例：FileReader类读取字符流

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class FileReaderDemo {
    public static void main(String[] args) throws FileNotFoundException {
        FileReader fr = null;
        StringBuffer sbf = null;
        try {
        // 创建字符流。
            fr = new FileReader("d:/我的青春谁做主.txt");
            sbf =new StringBuffer();
            char [] ch = new char [1024];
            int length =-1;
                // 读取字符流，并将返回到length。
                while((length=fr.read(ch))!=-1){
                    //添加到字符中的时候尽量使用这个方法。
                    sbf.append(ch, 0, length);
                }
            } catch (IOException e) {
                e.printStackTrace();
            }finally{
                try {
                    fr.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
    }
}

BufferedReader 类 Reader类的子类

• BufferedReader类带有缓冲区
• readLine();按行读取内容
• 构造方法
  
  • BufferedReader(Reader in)
• 多个流打开时，关闭顺序：先打开的后关闭，后打开的先关闭。
  示例：BufferedReader类

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;

public class BuffereReaderDemo {
    public static void main(String[] args) {
        Reader reader = null;
        BufferedReader br = null;
        StringBuffer sbf = null;
        try {
            // 创建文件。
            reader = new FileReader("d:/我的青春谁做主.txt");
            // 创建BufferedReader字符流.
            br = new BufferedReader(reader);
            sbf = new StringBuffer();
            String data = null;
            // 按行读取文件，返回到data中，并在控制台中输出。
            while ((data = br.readLine()) != null) {
                System.out.println(data);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                // 关闭文件流
                br.close();
                reader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }

        }
    }
}