File类以及IO流

1、File类

package LESSON12;
import java.io.File;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class demo1 {
    /**
     * Windows中文件或者目录的表示D:\test\1.txt
       Java中文件或者目录的表示D:\\test\\1.txt，或者D:/test/1.txt
     */
    public static void main(String[] args) {
        //File:表示磁盘上的文件或者目录
        File f1=new File("E:/aa/a/a.txt");
        //File f=new File("E:\\aa\\a/a.txt");//这样写也行
        File f2=new File("E:\\aa\\a\\a.txt");

        File f3=new File("E:/aa/a","a.txt");
        File f4=new File("E:\\aa\\a","a.txt");

        File f5=new File("E:/aa/a");
        File f6=new File(f5,"a.txt");

        System.out.println(f1.getName());//获取文件对象名(文件夹或文件)
        System.out.println(f2.getName());
        System.out.println(f3.getName());
        System.out.println(f4.getName());
        System.out.println(f5.getName());
        System.out.println(f6.getName());

        //System.out.println(f.canRead());
        System.out.println(f1.canWrite());//是否可读
        System.out.println(f1.canRead());//是否可写
        //f1.delete();//删除
        //f1.deleteOnExit();//退出JVM时删除。即运行完一次程序删除文件，下次在运行时文件已经删除

        System.out.println("-------------------------");
        System.out.println(f1.exists());
        System.out.println(f1.getPath());//以String类型返回绝对路径
        System.out.println(f1.getAbsolutePath());//以String类型返回绝对路径
        System.out.println(f1.getAbsoluteFile());//以File类型返回绝对路径
        System.out.println(f1.getParent());//以String类型返回父类
        System.out.println(f1.getParentFile());//以File类型返回父类
        System.out.println(f1.isFile());//是否是文件
        System.out.println(f1.isDirectory());//是否是目录
        System.out.println(f1.isHidden());//是否隐藏
        System.out.println(f1.length());//返回文件对象的长度

        System.out.println("-----------------");
        long lastime=f1.lastModified();//表示文件最后一次被修改的时间的 long 值，用与时间点（1970 年 1 月 1 日，00:00:00 GMT）之间的毫秒数表示
        System.out.println(lastime);//毫秒数 1561176411802

        //public Date(long date)
        //分配 Date 对象并初始化此对象，以表示自从标准基准时间（称为“历元（epoch）”，即 1970 年 1 月 1 日 00:00:00 GMT）以来的指定毫秒数。
        String time=new SimpleDateFormat("yyyy年MM月dd日  hh:mm:ss").format(new Date(lastime));
        System.out.println(time);

        System.out.println("---------------------");
        File f7=new File("E:/aa");
        String strList[]=f7.list();//以String类型返回该文件对象下的其他文件
        for (int i = 0; i < strList.length; i++) {
            System.out.println(strList[i]);//只有名称
        }

        File fileList[]=f7.listFiles();//以File类型返回该文件对象下的其他文件
        for (int i = 0; i < fileList.length; i++) {
            System.out.println(fileList[i]);
            String sonList[]=fileList[i].list();
            for (int j = 0; j < sonList.length; j++) {
                System.out.println(sonList[j]);//只有名称
            }

        }

        System.out.println("-------------------------");
        File file8=new File("E:/aaaa/aaa/aaa.txt");
        System.out.println(file8.getName());//无论文件是否存在都能得到文件名
        System.out.println(file8.canRead());//未创建文件时为false

        File parentFile=file8.getParentFile();
        if(!parentFile.exists()){
            //parentFile.mkdir();//创建单个文件夹,如用其创建file8时会报错java.io.IOException: 系统找不到指定的路径。
            parentFile.mkdirs();//创建多个文件夹(连同子文件夹一起创建)
        }
        try {
            file8.createNewFile();//创建文件
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        File file9=new File("E:/aaa/aa");
        file9.mkdirs();//创建文件夹
    }
}

2、流

流是一组有序的，有起点和终点的字节集合，是对计算机中数据    传输的总称或者抽象。
     即数据在两个设备间的传输称为流，流的本质是数据传输的载体。  
    流序列中的数据可以是没有进行加工的原始数据（二进制字节数    据），也可以是经过编码的符合某种格式规定的数据，Java中提    供了不同的流类对它们进行处理。
3、IO流

输入输出是对程序而言，不是对数据源。输入即输入数据到程序中也就是从流中读取数据，输出即从程序中输出数据也就是向流中写入数据。

输入流（InputStream）
    在Java中，程序可以打开一个输入流，输入流的信息源可以位于文件、内存或网络套接字(socket)等地方，信息源的类型可以是包括对象、字符、图像、声音在内的任何类型。一旦打开输入流后 程序就可从输入流串行地读取数据。

输出流（OutputStream）
    类似地，程序也能通过打开一个输出流并顺序地写入数据来将信息送至目的端。

4、字节流

字节流的概念
    传输的数据单位是字节，也意味着字节流能够处理任何一种文件
字节流的组成
    字节输入流 InputStream
    字节输出流 OutputStream

字节输入流FileInputStream

package LESSON12;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
public class demo2 {
    public static void main(String[] args) throws Exception {
        //创建字节输入流对象
        FileInputStream fis=new FileInputStream(new File("E:\\abc\\a.txt"));
        //读取数据
        //int i=fis.read();//1读取单个字符
        //System.out.println(i);
//        System.out.println(i);
//        System.out.println(i);
//        System.out.println(i);

//        byte b[]=new byte[1024];//2
//        fis.read(b);//以数组字节的长度读取数据
//        System.out.println(new String(b).trim());

        byte b[]=new byte[20];//3
        //int read(byte[] bs, int off, int len) off为偏移量，即等多少字节之后再开始读取
        //off+len不能超过byte数组的长度,否则会报java.lang.IndexOutOfBoundsException异常
        fis.read(b, 0, b.length);

        System.out.println(new String(b));
        fis.close();//关流
    }
}

字节输出流FileOutputStream

package LESSON12;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class demo3 {
    public static void main(String[] args) throws Exception {
        File file8=new File("E:xyz/xyz.txt");
        File parentFile=file8.getParentFile();
        if(!parentFile.exists()){
            //parentFile.mkdir();//创建单个文件夹,如用其创建file8时会报错java.io.IOException: 系统找不到指定的路径。
            parentFile.mkdirs();//创建多个文件夹(连同子文件夹一起创建)
        }
        try {
            file8.createNewFile();//创建文件
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        //创建字节输出流对象
        FileOutputStream fos=new FileOutputStream(file8,true);//true:追加,即执行完一次程序后第二次运行还会添加相同的1内容
        //fos.write(100);//1写入数据  显示为b
        fos.write("今天周六".getBytes());//2以字节数组的形式写入数据
        byte b[]="明天休息".getBytes();
        fos.write(b, 0, b.length);//3

        fos.close();
    }
}

字节流的拷贝

package LESSON12;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.text.DecimalFormat;
public class demo4 {
    public static void main(String[] args) throws Exception {
        // 字节流的拷贝
        File filefrom=new File("D:/弹性表达式.doc ");//待拷贝文件
        File fileto=new File("E:文档/弹性表达式.doc  ");//拷贝之后的文件
        File parentFile =fileto.getParentFile();//以File类型返回父类
        if(!parentFile.exists()){//如果父类文件对象不存在
            parentFile.mkdirs();//创建多个文件夹
        }
        fileto.createNewFile();//创建文件
        FileInputStream fis=new FileInputStream(filefrom);
        FileOutputStream fos=new FileOutputStream(fileto);

//        int i=fis.read();//单个字符读取，速度慢
//        while(i!=-1){
//            fos.write(i);
//            i=fis.read();
//        }

        byte b[]=new byte[1024];
        int i=fis.read(b);
        while(i!=-1){
            fos.write(b);
            i=fis.read(b);
        }

        //关流：先开的后关
        //先关过滤流，再关节点流，先关输出流，再管输入流
        fos.close();
        fis.close();

    }

}

5、字符流

字符节点输入流   复制图片会出现错误

字符输入流

package LESSON12;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
public class demo6 {
	public static void main(String[] args) throws Exception {
		//创建字符输入流对象(将文件中的每个数据当作字符来读取)
		FileReader fr=new FileReader(new File("E:\\abc\\a.txt"));
		//读取数据
		//	int i=fr.read();
		//System.out.println(i);
		char b[]=new char[100];
		fr.read(b);
		System.out.println(new String(b).trim());
		//关流
		fr.close();
	}
}

字符输出流

package LESSON12;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
public class demo7 {
    public static void main(String[] args) throws Exception {
        //创建字符输出流(在关闭时才能写入数据)
        FileWriter fw=new FileWriter(new File("E:\\abc\\a.txt"),true);
        fw.write("今天周一，开始上班咯");//字符流可以直接写入数据，但是在调用关闭方法的时候才会执行
        fw.close();
    }
}

字符流复制

package LESSON12;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
public class demo8 {
    public static void main(String[] args) throws Exception {
        // 字符流复制
        File filefrom=new File("E:abc\\a.txt");
        File fileto=new File("E:文档\\a.txt");
        FileReader fr=new FileReader(filefrom);
        FileWriter fw=new FileWriter(fileto);
        File parentfile=fileto.getParentFile();
        if(!parentfile.exists()){
            parentfile.mkdirs();
        }
        fileto.createNewFile();
        char b[]=new char[1024];
        int i=fr.read(b);
        while(i!=-1){
        fw.write(b);
        i=fr.read(b);
        }
        fr.close();
        fw.close();
    }
}

6、过滤流

过滤流速度读写数据更快

过滤流:使用节点流作为输入或输出。过滤流是使用一个已经存在的输入流或输出流连接创建的。
过滤流的开发步骤
    创建节点流
    基于节点流创建过滤流
    读/写数据
    关闭外层流

输入流

package LESSON12;
import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileReader;
public class demo9 {
    public static void main(String[] args) throws Exception {
        //字节流类型要和过滤流类型一致
        //FileInputStream 对 BufferedInputStream
        //FileReader对 BufferedReader

//        FileInputStream fis=new FileInputStream("E:abc\\a.txt");//字节节点输入流
//        BufferedInputStream bis=new BufferedInputStream(fis);//字节过滤输入流
//        byte b[]=new byte[1024];
//        bis.read(b);
//        System.out.println(new String(b));
        FileReader fr = new FileReader("E:abc\\a.txt");//字符节点输入流
        BufferedReader br = new BufferedReader(fr);//字符节点输入流
        char b[]=new char[100];
        br.read(b);
        System.out.println(new String(b).trim());
    }
}

输出流

package LESSON12;
import java.io.BufferedOutputStream;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileWriter;
public class demo10 {
    public static void main(String[] args) throws Exception {
        //节点流类型要和过滤流的类型一致
//        FileOutputStream fos=new FileOutputStream("E:abc\\a.txt",true);//字节节点输出流
//
//        BufferedOutputStream bos=new BufferedOutputStream(fos);//过滤节点输出流
//
//        bos.write("JJJJJ".getBytes());
//        bos.close();
//        fos.close();
        FileWriter fw = new FileWriter("E:abc\\a.txt",true);//字符节点输出流
        BufferedWriter bw = new BufferedWriter(fw);//字符过滤输出流
        bw.write("我爱学习");
        bw.close();
        fw.close();
    }
}

注：关闭的顺序，先关过滤流，再关节点流，先关输入流，再关输出流。
7、对象流

在java中，如果想在对象流中储存或者传送任何一个类，我们需要对类实现序列化，即该类必须实现Serializable接口。