JavaIO

最新推荐文章于 2025-04-27 22:48:25 发布

Janemy_

最新推荐文章于 2025-04-27 22:48:25 发布

阅读量512

点赞数

文章标签： java

本文链接：https://blog.youkuaiyun.com/Janemy_/article/details/125724241

版权

File类

在程序中抽象的表示的计算机中的文件和目录(文件夹)

一个file类的对象可以表示一个具体的文件或目录

File类的对象只表示文件,不能对文件内容进行读写操作

File类的构造方法:

public static void main(String[] args) {
        File f1=new File("E:/demo.txt");//绝对路径,完整的路径.文件名
        File f3=new File("E:/demo");//目录名
        File f2=new File("a.txt");//相对路径,不是全路径,是两个文件的相对同一个父级的路径
        System.out.println(f2.getAbsolutePath());
}

常用方法:

public class FileDemo1 {
    public FileDemo1(File file) {
    }
    public static void main(String[] args) {
        File f1=new File("E:/demo.txt");//绝对路径,完整的路径.文件名
        File f3=new File("E:/demo");//目录名
        File f2=new File("a.txt");//相对路径,不是全路径,是两个文件的相对同一个父级的路径
        System.out.println(f2.getAbsolutePath());
        /*String p="E:/";
        new File("demo.txt");
        File f1=new File("E:/demo.txt");
         */
        System.out.println(f1.getAbsolutePath());//绝对路径
        System.out.println(f1.getParent());//父级
        System.out.println(f1.canRead());//判断文件是否可读
        System.out.println(f1.canWrite());//判断文件是否可写
        System.out.println(f1.lastModified());//文件最后修改时间
        System.out.println(f1.length());//获取文件内容长度(以字节为单位)
        System.out.println(f1.exists());//判断文件是否存在
        new Date(347827798475983L);
        if (!f1.exists()){
            try {
                f1.createNewFile();
            }catch (IOException e){
                e.printStackTrace();
                System.out.println("文件路径不合法");
            }
            System.out.println(f1.isFile());
            System.out.println(f1.isDirectory());
            System.out.println(f1.delete());
        }

        System.out.println(f1.isFile());//判断表示的是否是文件
        System.out.println(f1.isDirectory());//判断表示的是否是目录
        System.out.println(f1.delete());

输入和输出的概念

输入:把电脑硬盘上的数据读到程序中,即input

输出:进行数据的read操作从程序往外部设备写数据.进行数据的write操作.即output

输入流和输出流

输入流:往程序中读

输出流:从程序中往外写

InputStream和OutputStream的子类都是字节流可以读写二进制文
件，主要处理音频、图片、歌曲、字节流,处理单元为1个字节。
Reader和Writer的子类都是字符流主要处理字符或字符串，字符流处
理单元为1个字符。字节流将读取到的字节数据，去指定的编码表中获取
对应文字。

字节流与字符流

输入输出字节流

public class StreamDemo1 {
    public static void main(String[] args) throws IOException {
        FileInputStream in=new FileInputStream("E:/demo1.txt");
        int b=0;
        FileOutputStream out= new FileOutputStream("E:/demo2.txt");
        while((b = in.read())!=-1){
            out.write(b);
        }
        in.close();
        out.close();
    }
}

public class StreamDemo3 {
    public static void main(String[] args) throws IOException {
        FileInputStream in=new FileInputStream("E:/demo1.txt");
        FileOutputStream out=new FileOutputStream("E:/demo2.txt");
        byte[]b=new byte[5];
        int size=0;
        while((size=in.read(b))!=-1){
            System.out.println(size);
            out.write(b,0,size);
        }
    }
}

输入输出字符流

字符输入流 FileReader
字符输出流 FileWriter

字符流只能读取纯文本文件

public class chardemo2 {
    public static void main(String[] args) throws IOException {
        //FileReader extends InputStreamReader:转换流,将读到的字节按照指定charset转换为字符
        FileReader reader=new FileReader("E:/demo1.txt");
        FileWriter writer=new FileWriter("E:/demo2.txt",true);
        //true,写入数据时,保留之前的,向后面追加内容
        /*
        int c=0;
        while ((c=reader.read())!=-1){
            writer.write(c);
        }
         */
        char[]chars=new char[5];
        int size=0;
        while((size=reader.read(chars))!=-1){
            writer.write(chars,0,size);
        }//转换流,将字符转为字节写出字符流,只能读取纯文本文件
    }
}

节点流和处理流

节点流:如果流封装的是某种特定的数据源，如文件、字符串、字符串数组等.流对象是直接对数据操作,构造方法(文件).

字节输入流 FileInputStream
字节输出流 FileOutputStream

处理流/包装流:如果流封装的是其它流对象，称为处理流.流对象中包含的是另一个流.提供一些额外的的数据进行处理(缓冲功能,读写效率高).

缓冲字节输出流 BufferedOutputStream
缓冲字节输入流 BufferedInputStream
缓冲字符输入流 BufferedReader
缓冲字符输出流 BufferedWriter

public class StreamDemo4 {
    public static void main(String[] args) throws IOException {
        FileInputStream in=new FileInputStream("E:\\非凡英才\\java2204\\2022-7-11_java第八章IO\\练习\\feige.exe");
        FileOutputStream out=new FileOutputStream("E:\\非凡英才\\java2204\\2022-7-11_java第八章IO\\练习\\feige1.exe");
        BufferedInputStream bin=new BufferedInputStream(in);
        BufferedOutputStream bout=new BufferedOutputStream(out,2048);
        int size=0;
        byte[]b=new byte[1024];//自带缓存区
        while ((size=bin.read(b))!=-1){//read时,会把读到的数据缓冲到底层数组中去
            bout.write(b);//write时并不是每write一次就向磁盘写数据,等待内部的缓存数组写满时,再向磁盘输出
        }
        bout.flush();//关闭之前,刷新缓存区
        bin.close();//关闭流
        bout.close();
    }
}

public class chardemo1 {
    public static void main(String[] args) throws IOException {
        FileReader reader=new FileReader("E:/demo1.txt");
        FileWriter writer=new FileWriter("E:/demo1.txt");
        BufferedReader bufferedReader=new BufferedReader(reader);
        BufferedWriter bufferedWriter=new BufferedWriter(writer);
        String line=null;
        while ((line=bufferedReader.readLine())!=null){//readline一次读取一行
            System.out.println(line);
            bufferedWriter.write(line);
            bufferedWriter.newLine();//插入换行符
        }
        writer.flush();
        reader.close();
        writer.close();
    }
}

print流

打印流:单向的从程序中向目标输出数据

public class PrintDemo {
    public static void main(String[] args) throws FileNotFoundException {
        PrintWriter out=new PrintWriter("E:/demo3.txt");
        out.print("<h1>你好客户端<h1>");
        out.print("<h1>你好客户端<h1>");
        out.print("<h1>你好客户端<h1>");
        out.print("<h1>你好客户端<h1>");
        out.print("<h1>你好客户端<h1>");
        out.close();
    }
}

对象输入输出流

对象存储在内存中,程序终止运行,内存数据清空,有时需要保存对象中的数据,需要用流对象,将对象数据输出到文件中,做到对象数据的持久化(长久保存).此过程也称为对象的序列化和反序列化,其中反序列也是一种创建对象的方法

ObjectInputStream 两者都属于处理流

ObjectOutputStream

public class ObjectStreamDemo {
    public static void main(String[] args) throws IOException {
        FileOutputStream fout=new FileOutputStream("E:/obj.txt");
        ObjectOutputStream out=new ObjectOutputStream(fout);
        Date date=new Date();
        String s="abc";
        out.writeObject(date);
        out.writeObject(s);
        out.flush();
        out.close();
        fout.close();
    }
}

public class ObjectStreamDemo {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
//        FileInputStream in=new FileInputStream("E:/obj.txt");
//        ObjectInputStream oin=new ObjectInputStream(in);
//        Date date= (Date)oin.readObject();
//        String s=(String)oin.readObject();
//        System.out.println(date);
//        System.out.println(s);
//        oin.close();
//        in.close();
         }
        }
//反序列化,会新创建对象

 FileOutputStream fout=new FileOutputStream("E:/obj.txt");
        ObjectOutputStream out=new ObjectOutputStream(fout);
        Car car=new Car(100,"宝马");
        out.writeObject(car);
        out.flush();
        out.close();
        fout.close();
    }
}

Serialiazable:序列化接口

如果需要将某个类的对象进行序列化,那么此类必须实现Serialiazable 接口会为类生成一个版本号.如果不显得意义版本号,会自定义版本号,会自定默认生成,会有一个问题,每次当类改变了,版本号会重新生成.

public class Car implements Serializable {
    private int no;
    private String name;
    private int price;
    public Car(int i, String 宝马) {
    }
    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 int getPrice() {
        return price;
    }
    public void setPrice(int price) {
        this.price = price;
    }
}