文件的操作

绝对路径：从盘符到文件，完整的路径表示形式，d:\data\a.txt

相对路径：就是指由这个文件所在的路径引起的跟其它文件（或文件夹）的路径关系。即相对某一路径下的路径。比如当前在d：/data，要描述d：/datda下的a.txt文件，只需要写a.txt

方法

exists()
createNewFile()
getName()
getPath()
getAbsolutePath()
getParent()
canRead()
canWrite()
isFile()
long lastModified()
long length()
boolean delete()

File目录

目录是一个包含其他文件和路径列表的File 类对象。
即File类主要用来获取文件（或者目录）本身的一些信息，对文件的名字，不涉及对文件内容的操作

方法

判断方法： boolean isDirectory() ；boolean exists()
获得方法： String [] list()； File[] listFiles()
其它方法： mkdir() ；mkdirs()

import java.io.File;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Date;

/** File:文件的操作一*/
public class TestFile {

    public static void main(String[] args)  throws IOException{
        //指定绝对路径
        //File f = new File("d:/data/a.txt");
        //没有指定绝对路径，那么相对路径在项目下
        File f = new File("a.txt");
        //父路径，子路径
        //File f = new File("d:/data","a.txt");
        //父路径
    //  File f1 = new File("d:/data");
        //File f = new File(f1,"a.txt");

        //文件 或 目录 是否存在
        System.out.println(f.exists());//false

        //新建文件
        f.createNewFile();
        System.out.println(f.exists());//true

        //获得文件名
        /*System.out.println(f.getName());

        //获得路径
        System.out.println(f.getPath());

        //获得绝对路径
        System.out.println(f.getAbsolutePath());

        //获得父路径
        System.out.println(f.getParent());

        //文件是否可读，可写
        System.out.println(f.canRead());
        System.out.println(f.canWrite());

        //判断是否文件
        System.out.println(f.isFile());

        //最后一次修改的时间
        System.out.println(f.lastModified());//1527645016120毫秒
        SimpleDateFormat format = new SimpleDateFormat("yyyy年MM月dd  hh:mm:ss");
        Date date = new Date(f.lastModified());
        System.out.println(format.format(date));


        //文件内容的长度（字节数   :英文一个字节，汉字两个字节）
        long len = f.length();//"hello"
        System.out.println(len);//5

        //删除文件*/
        f.delete();
    }

}

package day24;

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

public class TestFileOutStream {

    public static void main(String[] args) throws IOException {
        //输出 ：String s = "hello" 存到d:/data/b.txt中
        //1.
        //FileOutputStream fout = new  FileOutputStream ("d:/data/b.txt" );

        File f = new File("d:/data/a.txt");
        //添加的内容变为追加而不是覆盖
        FileOutputStream fout = new FileOutputStream(f,true); 

        //2.写
        String s = "hello";

        //写一个字节
        fout.write(97);
        //写一个字节数组
        fout.write(s.getBytes());
        //              从什么位置开始，写几个字节
        fout.write(s.getBytes(),2,2);//写“ll”

        //3.关闭
        fout.close();
    }

}

/**文件操作示例代码*/
import java.io.File;

/**显示一个文件夹及子文件夹中的所有文件    递归  */

public class Ex1 {

    //显示目录下的文件
    public void show(File f){
        if(f.exists()){
            if(f.isDirectory()){
                File [] fs = f.listFiles();
                if(fs == null){
                    return;
                }
                for(File ff : fs){
                    if(ff.isFile()){
                        System.out.println(ff.getName());
                    }else{
                        System.out.println("-----目录 " + ff.getName());
                        show(ff);//递归，是目录继续展示
                    }
                }
            }else{
                return;
        }
        String [] str = f.list();
    }else{
        return ;
    }
    }

    public static void main(String[] args) {
    File f = new File("d:/Drivers");
    System.out.println(f.exists());
    new Ex1 ().show(f);

    }
    }

文件过滤器

文件名过滤器：
FilenameFilter
文件过滤器
FileFilter

import java.io.File;
import java.io.FileFilter;
import java.io.FilenameFilter;

/**File:目录操作二*/

public class TestFile2 {

    public static void main(String[] args) {
        File f = new File("d:/data");
        //文件是否存在
        System.out.println(f.exists());

        //是否是文件夹
        System.out.println(f.isDirectory());

        //创建目录方法一
        //f.mkdir();//父路径存在时，可以创建不存在的目录
        //创建目录方法二
        f.mkdirs();//可以创建不存在的父目录
        // 
        System.out.println("---------目录下的文件和目录-------");
        //获得指定路径下的文件和目录名称。String[]
        String [] strs = f.list();
        for(String s : strs){
            System.out.println(s);
        }
        //过滤文件名，过滤出".txt"文本文件         文件名过滤器
/*      String [] strs1 = f.list(new FilenameFilter(){
                    @Override          //父路径                 子路径
                    public  boolean accept(File dir, String name){
                        return name.endsWith("txt");
                    }
                });*/
        String [] strs1 = f.list((dir,name) -> name.endsWith("txt"));
        for(String s : strs1){
            System.out.println(s);
        }

        //获得指定目录下的，文件和目录本身的file形式
    /*  File[] fs = f.listFiles();
        for(File fi : fs){
            if(fi.isFile()){
                System.out.println(fi.getName());
            }else{
                System.out.println("目录" + fi.getPath());
            }
        }*/


        //过滤文件名，过滤出".txt"文本文件 
        File [] fs = f.listFiles(new FileFilter(){
            @Override
             public boolean accept(File pathname){
                 return pathname.getName().endsWith("txt");
             }
        });

        for(File fi : fs){
            System.out.println(fi.getName());
        }

    }

}

流

Java在java.io包定义多个流类型来实现输入和输出。对文件中的内容进行读写操作的技术。

流可以理解为一组有顺序的额，有起点和终点的动态数据集合

流的分类

按照流的运动方向，分为输入流和输出流

输入流：读，从硬盘的文件中到内存中

        a.txt          到    String s....

输出流：写,存内存到硬盘的文件中

        String s....   到   a.txt

- 按照数据类型分：字节流，字符流

字节流：一次处理一个字节

字符流：一次处理一个字符

按照功能分为：节点流，处理流

节点流：直接对数据源（文件）读写

处理流（过滤流，包装流）

字节流

以字节为单位对数据进行读写。
字节流由两个抽象类定义：
- InputStream：所有字节输入流的父类
- int read() :从输入流中读取一个字节，到达文件末尾返回-1
- void close():关闭此输入流，并且释放与改流相关的所有资源
- OutputStream ：所有字节输出流的父类
- abstract void write(int b):将指定的字节写入此输入流
- void close关闭此输出流并释放与此流有关的所有资源
字节流包括：
- 文件流
- 转换字符流
- 缓冲流
- 数据流
- 对象流

字节流图解：

这里写图片描述

1.文件字节流

FileInputStream /输入流/ 节点流

FileOutputStream /输出流/ 节点流

/**FileInputStream一*/
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;

public class TestFileInputStream {

    public static void main(String[] args) throws IOException {
           //1.创建流对象    
            File f = new File("d:/data/a.txt");
            //字节流
            FileInputStream fin = new FileInputStream(f); 

            //2.读数据
            //文件字符大小
            byte [] b = new byte[(int) f.length()];
            fin.read(b);
            //存储到字节数组的其实位置，字节数
            fin.read(b, 1, 2);

            //把字节数组转换成字符串
            String s = new String (b,"gbk");
            System.out.println(s);

            //3.关闭
            fin.close();


    }

}


import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;

/** FileInputStream二 */
public class TeatInputStream {

    public static void main(String[] args) throws IOException  {
        //d:/data/a.txt文件内容读出来，在控制台显示
        //输入流 FileInputStream
        //1.创建流对象
       //FileInputStream fin = new FileInputStream("d:/data/a.txt");

        File f = new File("d:/data/a.txt");
        //字节流
        FileInputStream fin = new FileInputStream(f); 
        //转换流： 字符流  把字节流 包装成字符流       一次处理一个字符
        InputStreamReader ir = new InputStreamReader(fin);

        //2.读数据
        /*for(int i = 0 ; i < f.length() ; i ++){
        int temp =fin.read();//读一字节
        System.out.println((char)temp);
        }*/
    /*  int temp;
        while ((temp = fin.read()) != -1){
            System.out.println((char)temp);
        }*/

        int temp;
        while ((temp = ir.read()) != -1){
            System.out.println((char)temp);
        }
        //3.关流
        fin.close();
        ir.close();//由内向外关闭


    }

}

/FileInputStream示例代码*/

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

public class TestFileInputStream3 {

    public static void main(String[] args) {
        //1.创建流对象   
        File f = new File("d:/data/a.txt");
        //字节流
        FileInputStream fin = null;
        try {
            fin = new FileInputStream(f);
        //2.读数据
        //文件字符大小
        byte [] b = new byte[(int) f.length()];
        fin.read(b);
        //存储到字节数组的其实位置，字节数
        //fin.read(b, 1, 2);

        //把字节数组转换成字符串
        String s = new String (b,"gbk");
        System.out.println(s);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally{
        //3.关闭
            if(fin != null){
                try {
                    fin.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }

    }

}

/**字节流示例代码 */

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Scanner;

public class Ex3 {

    public static void main(String[] args) throws IOException {
        //输入
        Scanner input = new Scanner(System.in);

        FileOutputStream fout  = null;
        //创建
        File f = new File("d:/data/name.txt");
        String name = " ";
        while( ! name .equals("q")){
        System.out.println("请输入姓名");
         name = input.next();
        fout = new FileOutputStream(f,true);    
        //读写
        fout.write(name.getBytes());
        fout.write("\r\n".getBytes());
        }
        //关闭
        fout.close();
        input.close();

    }

}

中文字出现乱码处理方法（因为一个中文字占两个字节）
1. 转换流 InputStreamReader
2. 把字节数组转换成字符串 resd(byte [])

缓冲流

作用：提高效率

BufferedInputStream
BufferedOutputStream

package day24;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class Ex2 {

    public static void main(String[] args) throws IOException {

        //1.创建对象
        File f1 = new File("d:/data/aoteman.jpg");
        FileInputStream fin = new FileInputStream(f1);
        //包装进缓冲流
        BufferedInputStream bfin = new BufferedInputStream(fin);//板车

        File f2 = new File("d:/data/aotemannew.jpg");
        FileOutputStream fout = new FileOutputStream(f2);
        BufferedOutputStream bfout= new BufferedOutputStream(fout);//汽车
        //1.读,写

        int temp;
        while ((temp = fin.read()) != -1){
            fout.write(temp);
        }
        bfout.flush();//刷新缓冲区，相当于把汽车的东西运到仓库

        //3.关闭
        fin.close();
        bfin.close();
        fout.close();
        bfout.close();

    }

}

数据流

DataInputStream
DataOutputStream

/**数据流示例代码*/

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class TestDataOutputStream {

    public static void main(String[] args) throws IOException {
        //写-----------------------
        File f = new File("d:/data/stu.txt");
        FileOutputStream fout = new FileOutputStream(f);
        DataOutputStream dout = new DataOutputStream(fout);
        int [] no = {11,22,33};

        String [] name = {"aa","bb","cc"};

        for(int i = 0 ; i < no.length ; i ++){
            dout.writeInt(no[i]);
            dout.writeUTF(name[i]);
        }   
        dout.close();

        //读-----------------------------------------
        FileInputStream fin = new FileInputStream (f);
        DataInputStream din = new DataInputStream(fin);

        for(int i = 0; i < no.length ; i++){
            System.out.println(din.readInt());
            System.out.println(din.readUTF());
        }
        din.close();


    }

}

对象流

永久性地保存对象
1. ObjectOutputStream
2. ObjectInputStream

package day24;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

class Student implements Serializable{
    private static final long serialVersionUID = 1L;//版本号
    private int age;
    private int no;
    private String name;
    public int getNo() {
        return no;
    }
    public void setNo(int no) {
        this.no = no;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Student(int no, String name) {
        super();
        this.no = no;
        this.name = name;
    }
    public Student() {
        super();
        // TODO Auto-generated constructor stub
    }

}
public class TestObject {
    public static void main(String [] args) throws IOException, ClassNotFoundException{
    Student zhangsan = new Student();
    zhangsan.setName("张三");
    zhangsan.setNo(11);
    //想存储对象张三
    //序列化：把对象以二进制地形式存储到文件中
    //1.
    File f = new File("d:/data/student.txt");
    FileOutputStream fout = new  FileOutputStream(f);
    ObjectOutputStream objOut = new ObjectOutputStream (fout);

    //2.写，存
    objOut.writeObject(zhangsan);
    //3.
    objOut.close();

    //---------反序列化：从文件中把对象还原出来 ---------读出来，还原--------
//  FileInputStream fin = new   FileInputStream(f);
//  ObjectInputStream objIn = new ObjectInputStream(fin);
//  
//  //2.读，还原
//  Student stu = (Student)objIn.readObject();
//  System.out.println(stu.getName() + "," + stu.getNo());
//  objIn.close();
    }


}

打印输出字节流

PrintStream

package day24;

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

public class TestPrintStream {

    public static void main(String[] args) throws IOException {
        //把一个文件地内容读出来，在控制台上显示
        System.out.println("abc");

        //读
        //1.
        FileInputStream fin = new FileInputStream ("d:/data/a.txt");
        //2.
        byte [] b = new byte[fin.available()];//获得流中读取的字节数
        fin.read(b);
        String s = new String(b,"gbk");
        //3.
        fin.close();

        //写PrintStream
        //System.in 键盘输入   System.out控制台输出
        PrintStream p = new PrintStream(System.out);
        p.println("内容"+s);
        p.close();

    }

}

package day24;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.Scanner;

public class TestScanner {

    public static void main(String[] args) throws IOException {
        //Scanner
        //                          键盘输入源
        //                          （数据源）
//      Scanner input = new Scanner(System.in);
//      int n = input.nextInt();
//      
//      if(input.hasNextInt()){
//          n = input.nextInt();
//          System.out.println(n);
//      }else{
//          System.out.println("不是整数");
//      }


//      
//      FileInputStream fin = new FileInputStream("d:/data/a.txt");
//      //从流中获得数据源
//      Scanner input = new Scanner(fin);
//      
//      //获得一行
//      String s = input.nextLine();
//      System.out.println(s);
//      
//      fin.close();
//      input.close();

        Scanner input = new Scanner("aaa bb cc dd");
        //String s = input.next();
        String s1 = input.nextLine();
        //System.out.println(s);
        System.out.println(s1);
    }

}

========================================================================================================================

字符流

字符流的使用

操作字符提高效率。

Reader和Writer

Reader是定义Java的流式字符输入模式的抽象类
- int read （）：读一个字符
- close（）：关闭字符流
Writer 是定义流式字符输出的抽象类
- void close（）：关闭流
- void write（int c）throws IOException写入c
  3.字符流包括：
- 文件流
- 缓冲流
- 文本输出流

字符流图解：

这里写图片描述

文件字符流

FileWriter
FileReader

/**读取字符示例代码*/
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class Ex1 {

    public static void main(String[] args) throws IOException {
        //读取d:/data/a.txt
        //1.
        FileReader fr = new FileReader("d:/data/a.txt");

        //2.读
        int temp1;
        while((temp1 = fr.read()) != -1){
        //System.out.println(temp1);
        System.out.println((char)temp1);
        }


        //
        fr.close();
    }

}

/**写入字符代码示例*/
import java.io.FileWriter;
import java.io.IOException;

public class TeatFileWriter {

    public static void main(String[] args) throws IOException {
        //把一个String s = ”hello“存到b.txt
        //1.
        FileWriter fw = new FileWriter("d:/data/b.txt");

        //2.写
        String s = "hello";
        fw.write(s);

        //3
        fw.close();
    }

}

缓冲流

/**缓冲流示例代码*/
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class TestBufferReader {

    public static void main(String[] args) throws IOException {
        //1
        FileReader fr = new FileReader("d:/data/temp.txt");
        //2.
        BufferedReader bfr = new BufferedReader(fr);

//      String s = bfr.readLine();//读一行
//      System.out.println(s);

        String s;
        while((s= bfr.readLine()) != null){
            System.out.println(s);
        }

        fr.close();


    }

}

打印输出字符流

PrintWriter

/**PrintWriter示例代码一：*/
import java.io.FileNotFoundException;
import java.io.PrintWriter;

public class TestPrintWriter {

    public static void main(String[] args) throws FileNotFoundException {

        PrintWriter pw = new PrintWriter("d:/data/num.txt");

        for(int i = 0 ; i < 5; i++){
            pw.println(i);
        }

        pw.close();

    }

自动资源释放

try（声明要释放资源的流）{

}catch（）{

}

/**自动释放资源示例代码*/
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;

public class TestPrintWriter2 {

    public static void main(String[] args) throws IOException {
        //BufferedReader  读一行
        //PrintWriter   写一行
        //try(){}catch(){}自动资源释放，要实现AutoCloseable的才可以

        //1
        //包装一个字符流
        try(    BufferedReader bfr = new BufferedReader(new InputStreamReader(System.in));
                PrintWriter pw = new PrintWriter("d:/data/name.txt");){


            //2
            String sr; //读到的内容存储
            while(true){
                sr = bfr.readLine();
                if(sr.equals("q")){
                    break;
                }
                pw.print(sr);
            }
        }catch(IOException e){
            System.out.println(e.getMessage());
        }


    /*  bfr.close();
        pw.close();*/

    }

}

day17_java文件与流的应用