Java小专题之IO

File类

File

package cn.com.oneqinglong .FileDemo;

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

/**
 * 
 * @author oneqinglong 
 *
 *File表示硬盘上的一个文件或者目录
 *
 *java语言中表示路径:
 *
 *      1.D:\\01170301\\JAVASE\\开发工具
 *
 *      2.D:/01170301/JAVASE/开发工具
 *
 *File类中常用的方法:
 *
 *  String getName();功能:获取文件名
 *
 *  File getAbsoluteFile();功能:获取文件的绝对路径
 *
 *  String getParent();功能:获取文件的父级目录
 *
 *  File getParentFile();功能:获取文件父级目录 如果该文件没有父级目录 则返回null
 *
 *  boolean canRead();功能:判断文件是否是可读的
 *
 *  boolean canWrite();功能:判断文件是否是可写的
 *
 *  boolean isFile();功能:判断文件是否是标准文件
 *
 *  boolean isHidden();功能:判断文件是否是隐藏的
 *
 *  long lastModified();功能:获取文件最后一次修改时间
 *
 *  long length();功能:获取文件大小 单位是字节
 */
public class FileDemo {

    public static void main(String[] args) {

        File file=new File("D:\\01170301\\JAVASE\\开发工具\\eclipse-java-helios-SR2-win32.zip");
        //获取文件名
        String nae=file.getName();
        System.out.println(nae);
        //获取文件绝对路径
        File f=file.getAbsoluteFile();
        System.out.println(f);
        //获取文件父级目录
        String s=file.getParent();
        System.out.println(s);
        //获取文件的父级目录
        File fi=file.getParentFile();
        System.out.println(fi);
        //判断文件是否是可读的
        boolean bn=file.canRead();
        System.out.println(bn);
        //判断文件是否是可写的
        boolean bm=file.canWrite();
        System.out.println(bm);
        //判断文件是否是标准文件
        boolean c=file.isFile();
        System.out.println(c);
        //判断文件是否是隐藏的
        boolean d=file.isHidden();
        System.out.println(d);
        //获取文件最后一次修改时间
        long time=file.lastModified();
        System.out.println(time);
        String st=new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss").format(new Date(time));
        System.out.println(st);
        //获取文件大小
        long xx=file.length();
        System.out.println(xx/1024/1024);

    }
}

package cn.com.oneqinglong .FileDemo;

import java.io.File;
import java.io.IOException;
/**
 * 
 * @author oneqinglong 
 *
 *boolean createNewFile();功能:创建文件 但是不能创建文件
 *
 *boolean exists();功能:判断目录是否存在
 *
 *boolean mkdir();功能:只能一级目录的文件夹 不能创建文件
 *
 *boolean mkdirs();功能:创建一级或者多级目录 不能创建文件
 *
 *boolean delete();功能:只能删除文件  不能删除文件夹
 *
 *
 *路径:
 *
 *  1.绝对路径 该文件路径的完整描述形式 (很少使用的)
 *
 *  2.相对路径 相当于当前文件而言的就是相对路径 (推荐使用)
 *
 */
public class FileDemo2 {

    public static void main(String[] args) {
        //在盘符的根目录下创建文件
        File file=new File("D:\\123.txt");

        try {
            //创建文件 但是不能创建文件夹
            file.createNewFile();

        } catch (IOException e) {
            e.printStackTrace();
        }

        //创建一级目录的文件
        File file2=new File("D:\\111\\234.java");

        //获取文件的父级目录
        File f=file2.getParentFile();
        //判断父级目录是否存在
        if(f.exists()==false){//!f.exists();

            //创建一级目录 不能创建文件
            f.mkdir();

        }


        try {
            file2.createNewFile();
        } catch (IOException e) {
            e.printStackTrace();
        }


        //创建多级目录的文件
        File file3=new File("D:\\444\\111\\222\\1234.txt");
        //获取父级目录
        File f3=file3.getParentFile();
        //判断目录是否存在的
        if(!f3.exists()){
            //创建多级目录
            f3.mkdirs();
        }

        try {
            file3.createNewFile();
        } catch (IOException e) {
            e.printStackTrace();
        }


        //创建相对路径的文件
        File file4=new File("111.txt");
        try {
            file4.createNewFile();
        } catch (IOException e) {
            e.printStackTrace();
        }

        File file5=new File("abc\\aaa\\bbb.txt");
        File f5=file5.getParentFile();
        if(!f5.exists()){

            f5.mkdirs();
        }

        try {
            file5.createNewFile();
        } catch (IOException e) {
            e.printStackTrace();
        }

        file5.delete();
    }
}

流

字节流–>文件输入–>FileInputStream

package cn.com.oneqinglong .FileInputStreamDemo;

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

/**
 * 
 * @author oneqinglong 
 *
 *流的概念:
 *
 *  流是一组有序的 有起点和重点的字节集合
 *
 *流的本质就是传输数据.
 *
 *流的分类:
 *
 *  1.按照传输方向
 *
 *      输入流和输出流
 *
 *  2.按照处理单位
 *
 *      字节流和字符流
 *
 *  3.按照功能
 *
 *      节点流和处理流
 *
 *
 */
public class FileInputStreamDemo {

    /**
     * 
     * @param args
     * @throws IOException 
     */
    public static void main(String[] args) throws IOException {
        //建立待读取的文件   文件一定是存在的
        File file=new File("D:\\一封程序员的告白书.txt");
        //建立字节输入流
        FileInputStream input=new FileInputStream(file);
        //建立字节数组
        byte[] by=new byte[1024];//放几都可以 1024速度是最快的
        //读取文件
        int a=input.read(by);
        //把字节转换为字符串
        String str=new String(by,0,a);
        System.out.println(str);
        //流用完之后要关闭流
        input.close();
    }
}

package cn.com.oneqinglong .FileInputStreamDemo;

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

public class FileInPutStreamDemo2 {

    public static void main(String[] args) {
        //建立待读取的文件
        File file=new File("D:\\一封程序员的告白书.txt");

        FileInputStream input=null;

        try {
            //建立待读取的文件
            input=new FileInputStream(file);
            //建立byte数组
            byte[] by=new byte[1024];

            int a=0;
            //循环读取文件
            while((a=input.read(by))!=-1){

                String str=new String(by,0,a);
                System.out.println(str);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally{

            if(input!=null){

                try {
                    input.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

字节流–>文件输出–>FileOutputStream

package cn.com.oneqinglong .FileOutputStreamDemo;

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

public class FileOutputStreamDemo {

    public static void main(String[] args) {

        //建立待写入的文件   文件不一定存在的
        File file=new File("D:\\字节输出流演示.txt");
        //获取文件父级目录
        File f=file.getParentFile();
        //判断目录是否存在
        if(!f.exists()){
            //创建目录
            f.mkdirs();
        }

        try {
            //创建文件
            file.createNewFile();
        } catch (IOException e) {
            e.printStackTrace();
        }

        FileOutputStream out=null;

        try {
            //建立字节输出流 会覆盖掉以前的内容
            //out=new FileOutputStream(file);
            //表示续写 就是不会覆盖以前的 内容
            out=new FileOutputStream(file,true);
            //建立待发送的消息
            String str="静夜思\r\n床前明月光\r\n疑是地上霜\r\n举头望明月\r\n低头思故乡\r\n";
            //把字符串转换为byte数组
            byte[] by=str.getBytes();
            //写出信息
            out.write(by);

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally{

            if(out!=null){

                try {
                    out.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

字节流–>Copy

package cn.com.oneqinglong .Copy;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
/**
 * 
 * @author oneqinglong 
 *
 *字节流:是以字节为传输单位 也就意味着 字节流可以处理任何类型的文件  包括图片 声音 视频 文字...
 *
 */
public class Copy {

    public static void main(String[] args) {

        //建立待复制的文件 
        File formFile=new File("D:\\123.jpg");
        //建立复制去往的目的地
        File toFile=new File("D:\\123副本.jpg");
        //获取文件父级目录
        File f=toFile.getParentFile();
        //判断目录是否存在
        if(!f.exists()){
            //创建目录
            f.mkdirs();
        }

        try {
            //创建文件
            toFile.createNewFile();
        } catch (IOException e) {
            e.printStackTrace();
        }

        FileInputStream input=null;
        FileOutputStream out=null;

        try {
            //建立字节输入流
            input=new FileInputStream(formFile);
            //建立字节输出流
            out=new FileOutputStream(toFile);

            byte[] by=new byte[1024];
            int len=0;
            while((len=input.read(by))!=-1){//while((len=input.read())!=-1){out.write(len);}

                out.write(by, 0, len);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally{

            if(input!=null){

                try {
                    input.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

            if(out!=null){

                try {
                    out.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

---

字符流–>文件输入–>FileReader

package cn.com.oneqinglong .FileReaderDemo;

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

public class FileReaderDemo {

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

        File file=new File("D:\\123.txt");

        FileReader fr=new FileReader(file);

        //建立char数组
        char[] array=new char[1024];

        int b=fr.read(array);
        String str=new String(array,0,b);
        System.out.println(str);
        //关闭流
        fr.close();
    }
}

package cn.com.oneqinglong .FileReaderDemo;

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

public class FileReaderDemo2 {

    public static void main(String[] args) {

        File file=new File("D:\\一封程序员的告白书.txt");

        FileReader fr=null;

        try {
            fr=new FileReader(file);

            char[] array=new char[1024];

            int len=0;

            while((len=fr.read(array))!=-1){

                String str=new String(array,0,len);
                System.out.println(str);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally{

            if(fr!=null){

                try {
                    fr.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

---

字符流–>文件输出–>FileWriter

package cn.com.oneqinglong .FileWriterDemo;

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
/**
 * 
 * @author oneqinglong 
 *
 *字符输出流是带有缓冲区的 当缓冲区满时 会自动刷新缓冲区
 *
 *可以调用flush方法 刷新缓冲区
 *
 *
 *调用close方法时 会自动调用flush方法刷新缓冲区
 *
 *
 */
public class FileWriterDemo {

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

        File file=new File("D:\\字符输出流演示.txt");

        File f=file.getParentFile();
        if(!f.exists()){

            f.mkdirs();
        }

        try {
            file.createNewFile();
        } catch (IOException e) {
            e.printStackTrace();
        }

        FileWriter fw=new FileWriter(file);

        String str="字符输出流演示,java你好,哥们来了!!!";
        //把字符串转换为char数组
        //char[] array=str.toCharArray();
        //fw.write(array);
        fw.write(str);

        //刷新缓冲区
        fw.flush();//当缓冲区满时  系统会自动刷新缓冲区

        //因为调用close方法时  会自动调用flush方法 刷新缓冲区
        fw.close();
    }
}

字符流–>Copy

package cn.com.oneqinglong .Copy;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
/**
 * 
 * @author oneqinglong 
 *
 *字符流是字符为传输单位 也就意味着字符流只能用来操作文本
 *
 */
public class Copy2 {

    public static void main(String[] args) {

        File formFile=new File("D:\\123.txt");

        File toFile=new File("D:\\图片副本.txt");

        File f=toFile.getParentFile();
        if(!f.exists()){

            f.mkdirs();
        }

        try {
            toFile.createNewFile();
        } catch (IOException e) {
            e.printStackTrace();
        }

        FileReader fr=null;
        FileWriter fw=null;

        try {
            fr=new FileReader(formFile);

            fw=new FileWriter(toFile);
            char[] array=new char[1024];
            int len=0;
            while((len=fr.read(array))!=-1){

                fw.write(array,0,len);

                //速度比较慢
                //fw.flush();

            }

            fw.flush();

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally{

            if(fr!=null){

                try {
                    fr.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

            if(fw!=null){

                try {
                    fw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }


    }
}

---

缓冲流–>输入输出

BufferedInputStream

BufferedOuputStream

package cn.com.oneqinglong .BufferedOuputStreamDemo;

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

public class BufferedOuputStreamDemo {

    public static void main(String[] args) {

        File file=new File("D:\\处理流演示.txt");

        File f=file.getParentFile();

        if(!f.exists()){

            f.mkdirs();
        }

        try {
            file.createNewFile();
        } catch (IOException e) {
            e.printStackTrace();
        }

        FileOutputStream out=null;
        BufferedOutputStream bos=null;

        try {
            //建立节点流
            out=new FileOutputStream(file);
            //建立处理流对象
            bos=new BufferedOutputStream(out);

            String str="处理流演示";

            byte[] by=str.getBytes();

            bos.write(by);

            bos.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally{

            if(bos!=null){

                try {
                    bos.close();//关闭处理流的同时 会自动调用节点流的close方法
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

Object流

ObjectInputStream

package cn.com.oneqinglong .ObjectDemo;

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

public class ObjectInputStreamDemo {

    public static void main(String[] args) {

        File file=new File("D:\\Object流演示.txt");

        FileInputStream input=null;
        ObjectInputStream ois=null;

        try {
            input=new FileInputStream(file);

            ois=new ObjectInputStream(input);

            Object obj=ois.readObject();

            System.out.println(obj);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }finally{

            if(ois!=null){

                try {
                    ois.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }
}

ObjectOutputStream

package cn.com.oneqinglong .ObjectDemo;

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

public class ObjectOutputStreamDemo {

    public static void main(String[] args) {

        File file=new File("D:\\Object流演示.txt");

        File f=file.getParentFile();

        if(!f.exists()){

            f.mkdirs();
        }

        try {
            file.createNewFile();
        } catch (IOException e) {
            e.printStackTrace();
        }

        FileOutputStream out=null;
        ObjectOutputStream oos=null;

        try {
            out=new FileOutputStream(file);

            oos=new ObjectOutputStream(out);

            String str="高级流演示,你就看不懂了!!!";

            oos.writeObject(str);

            oos.flush();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally{

            if(oos!=null){

                try {
                    oos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

---

流操作自定义对象

package cn.com.oneqinglong.Demo;

import java.io.Serializable;

public class Student implements Serializable,Comparable<Student>{

    /**
     * 序列化id号 写几都可以 如果不写 系统默认提供
     */
    private static final long serialVersionUID = 1L;

    private String name;//姓名

    private int age;//年龄

    public Student(){}


    public Student(String name, int age) {

        this.name = name;
        this.age = age;
    }


    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }


    @Override
    public int compareTo(Student stu) {

        if(this.age!=stu.getAge()){

            return this.age-stu.getAge();
        }
        return this.name.compareTo(stu.getName());
    }


}

package cn.com.oneqinglong .Demo;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.util.ArrayList;
import java.util.Collections;
/**
 * 
 * @author oneqinglong 
 *
 *java.io.NotSerializableException:没有序列化
 *
 *用流操作自定义对象时 该对象要实现java.io.Serializable标示型接口 以启用序列化和反序列化功能
 *
 *java.io.Serializable:标示型接口
 *
 *标示型:就是标示当前类的对象 可以转换有序的数据序列 进行持久化保存
 *
 *序列化:就是把当前类的对象转换为有序的数据序列 通过对象输出流保存到指定位置
 *
 *反序列化:就是把指定的位置的数据 通过对象输入流 加载至内存 重新构建
 *
 *
 */
public class ObjectOuputStreamDemo2 {

    public static void main(String[] args) {

        //Student stu=new Student("张三", 20);
        //Student st=new Student("李四", 22);

        ArrayList<Student> list=new ArrayList<Student>();
        list.add(new Student("张三", 20));
        list.add(new Student("李四", 22));
        list.add(new Student("王五", 25));
        list.add(new Student("赵六", 21));
        list.add(new Student("田七", 19));
        list.add(new Student("孙八", 20));
        Collections.sort(list);

        File file=new File("D:\\学生信息.txt");

        File f=file.getParentFile();
        if(!f.exists()){

            f.mkdirs();
        }

        try {
            file.createNewFile();
        } catch (IOException e) {
            e.printStackTrace();
        }

        FileOutputStream out=null;
        ObjectOutputStream oos=null;

        try {
            out=new FileOutputStream(file);

            oos=new ObjectOutputStream(out);

            oos.writeObject(list);

            oos.flush();

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally{

            if(oos!=null){

                try {
                    oos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

package cn.com.oneqinglong .Demo;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class ObjectInputStreamDemo2 {

    public static void main(String[] args) {

        File file=new File("D:\\学生信息.txt");


        FileInputStream input=null;
        ObjectInputStream ois=null;

        try {
            input=new FileInputStream(file);

            ois=new ObjectInputStream(input);

            Object obj=ois.readObject();
            //判断一下该对象是否是List对象
            if(obj instanceof List){

                //向下转型
                @SuppressWarnings("unchecked")
                ArrayList<Student> list=(ArrayList<Student>)obj;

                Iterator<Student> it=list.iterator();
                while(it.hasNext()){

                    Student stu=it.next();
                    System.out.println("姓名:"+stu.getName()+"--->年龄:"+stu.getAge());
                }
            }




        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }finally{

            if(ois!=null){

                try {
                    ois.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }


    }
}

---

总结

字节流--输入--读文件 
input=new FileInputStream(file);
byte[] by=new byte[1024];
int len=0;
while((len=input.read(by))!=-1){
    String str=new String(by,0,a);
    System.out.println(str);
}

字节流--输出--写文件 
out=new FileOutputStream(file,true);
String str="静夜思\r\n床前明月光,\r\n疑是地上霜,\r\n举头望明月,\r\n低头思故乡。"
byte[] by=str.getBytes();
out.write(by);

字符流--输入--读文件
FileReader fr=new FileReader(file);
char[] array=new char[1024];
int b=fr.read(array);
String str=new String(array,0,b);
System.out.println(str);

字符流--输出--写文件
fr=new FileReader(file);
char[] array=new char[1024];
int len=0;
while((len=fr.read(array))!=-1){
    String str=new String(array,0,len);
    System.out.println(str);
}

Object流--输入--读文件
input=new FileInputStream(file);
ois=new ObjectInputStream(input);
Object obj=ois.readObject();
System.out.println(obj);

Object流--输出--写文件
output=new FileOutputStream(file);
oos=new ObjectOutputStream(output);
String str="圣诞节福利速度快放假了多久";
oos.writeObject(str);
oos.flush();