实训第十一天

最新推荐文章于 2024-08-12 16:47:32 发布

小柳不言败

最新推荐文章于 2024-08-12 16:47:32 发布

阅读量821

点赞数 26

文章标签： java 开发语言 idea

本文链接：https://blog.csdn.net/m0_74459453/article/details/136437432

版权

今天主要学习了File类和IO流

一、File类

1.基本概念

java.io.File类主要用于描述文件或目录的路径信息，可以获取该文件的名称、大小、修改时间等，不能对文件的内容进行访问。

2.常用的方法

File(String pathname)-根据参数指定的路径名来构造对象
boolean exists()-测试此抽象路径名表示的文件或目录是否存在
boolean delete（）-删除文件，当删除目录时要求是空目录
boolean createNewFile()-创建新的空文件
boolean mkdir()-创建此抽象路径名指定的目录。
boolean mkdirs()-创建多级目录。
String getName (）-获取文件或目录的名称。
long length()-获取文件的大小（长度）。

package Demo01;

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

public class FileDemo01 {
    public static void main(String[] args) {
        File file = new File("d:/a.text");
        if (file.exists()) {
            String fileName = file.getName();
            long len = file.length();
            System.out.println("文件的名称：" + fileName + "，文件大小：" + len);
            System.out.println(file.delete() ?"删除成功":"删除失败");
        } else {
            try {
                System.out.println(file.createNewFile()? "创建成功":"创建失败");
            } catch (IOException e) {
                e.printStackTrace();
            }

        }

    }
}

文件的名称：a.text，文件大小：0
删除成功

Process finished with exit code 0

package Demo01;

import java.io.File;

public class FileDemo02 {
    public static void main(String[] args) {

        File file = new File("d:/捣乱/猜猜我是谁/你猜我猜不猜/死鬼");
        if (file.exists()) {
            System.out.println(file.delete() ? "删除成功":"删除失败");
        } else{
            System.out.println(file.mkdirs() ? "创建目录成功" : "创建目录失败");
        }
    }
}

创建目录成功

Process finished with exit code 0

二.I/O流

1.基本概念

l/O就是Input/Output的简写，也就是输入/输出的含义。I/O流就是指像流水一样不间断地进行读写的过程。

2.基本分类

根据读写数据的单位不同分为字节流和字符流。其中字节流主要指以单个字节为单位进行读写的流，可以读写任意类型的文件。其中字符流主要指以单个字符2个字节为单位进行读写的流，只能读写文本文件。
根据数据流动的方向不同分为输入流和输出流，站在程序的角度。其中输入流主要指将文件中的数据内容读取出来输入到程序中，也就是读文件。其中输出流主要指将程序中的数据内容输出到文件中，也就是写文件。

3.FileOutputStream类（重点）

（1）基本概念

java.io.FileOutputStream类主要用于将图像数据之类的原始字节流写入到输出流中。

（2）常用的方法

FileOutputStream(String name)-根据参数指定的文件名来构造对象。
FileOutputStream(String name,boolean append)-表示以追加的方式根据参数指定的文件名来构造对象.。
void write(byte[ ] b)-将b.length个字节从指定byte数组写入此文件输出流中。
void write(byte[]b,int off,int len)-将指定知byte数组中从偏移量off开始的len个字节写入此文件
输出流。
void write(int b)-将指定字节写入此文件输出流。
void close()-关闭此文件输出流并释放与此流有关的所有系统资源。

package Demo01;

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

public class FileDemo03 {
    public static void main(String[] args) {
        try {
            FileOutputStream fos = new FileOutputStream("d:/aa.txt",true);
            fos.write(97);
            fos.write('a');
            fos.write("hello".getBytes());
            System.out.println("写入成功");

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

    }
}

写入成功

Process finished with exit code 0

4.FilelnputStream类（重点）

(1)基本概念

java.io.FilelnputStream类主要用于从输入流中读取数据数据之类的原始字节流。

(2)常用的方法

FileInputStream(String name)-根据参数指定的文件路径名来构造对象。
int read()-从此输入流中读取一个数据字节。-1是EOF。
int read(byte[] b)-从此输入流中将最多知b.length个字节的数据读入一个byte数组中。返回读取字节的个数
int read(byte[]b,int off,int len)-从此输入流中将最多len个字节的数据读入一个byte数组中。
void close()-关闭此文件输入流并释放与此流有关的所有系统资源。

package Demo01;

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

public class FileInputStreamDemo {
    public static void main(String[] args) {


    //1.构造FileInputStream类型的对象与d:/aa.txt文件进行关联
    FileInputStream fis;

    {
        try {
            fis = new FileInputStream("d:/aa.txt");
            int res = 0;
            while ((res = fis.read()) != -1) {
                System.out.println((char)res);
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}
 }

a
a
h
e
l
l
o

Process finished with exit code 0

三种拷贝方法（优缺点）

package Demo01;

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

public class FileDemo04 {
    public static void main(String[] args) {

        try {
            //1.构造FileOutputStream和FileInputStream类型的对象，并于相关文件进行关联
            FileInputStream fis = new FileInputStream("d:/aa.txt");
            FileOutputStream fos = new FileOutputStream("d:/b.txt");
            //2.读取文件后，进行写入，完成拷贝
            System.out.println("正在玩命的拷贝中...");
            //方式一：是以单个字节为单位进行读写  缺点：效率太低
//            int res = 0;
//            while ((res = fis.read()) != -1) {
//                fos.write(res);
//            }
            //方式二：准备一个和文件大小一样的缓冲区，将文件中的内容一次性读写到另一个文件中

//            int len = fis.available();
//            byte[] bArr = new byte[len];
//            //实际读取到文件的大小
//            int res = fis.read(bArr);
//            fos.write(bArr);
//            System.out.println("拷贝完成...");

            //方式三：准备一个相对合理的缓冲区，分多次读写、
            byte[] bArr = new byte[1024*8];
            int res = 0;
            while ((res = fis.read(bArr)) != -1) {
                fos.write(bArr,0,res);
            }
            System.out.println("拷贝完成...");

            //3.释放资源

            fos.close();
            fis.close();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

正在玩命的拷贝中...
拷贝完成...

Process finished with exit code 0

5.Printstream类

（1）基本概念

java.io.PrintStream类主要用于更加方便地打印各种数

（2）常用方法

PrintStream(OutputStream out)-根据参数指定的引用来构造对象，其中Outputstream类是一个抽象类，实参需要传递子类的对象
void print(String str)-用于将参数指定的字符串内容打印出来
void printin(String x)-用于打印字符串后并终止该行
void close()-用于关闭文件输出流并释放相关的资源

package Demo01;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.PrintStream;

public class printStreamDemo {
    public static void main(String[] args) {
        try {
            PrintStream ps = new PrintStream(new FileOutputStream("d:/b.txt"));
            ps.print("鲜衣怒马少年时，不负韶华行且知");
            System.out.println("成功写入文件");
        } catch (FileNotFoundException e) {
            throw new RuntimeException(e);
        }

    }
}

成功写入文件

Process finished with exit code 0

6.BufferReader类

（1）基本概念

java.io.BufferedReader类用于从输入流中读取单个字符、字符数组以及字符串。

（2）常用方法

BufferedReader (Reader in)-根据参数指定的引用来构造对象。其中Reader类是个抽象类，实参需要传递子类的对象
String readLine()-用于读取一行字符串并返回
void close()-用于关闭文件输出流并释放有关的资源。

package Demo01;

import java.io.*;

public class BufferedReaderDemo {
    public static void main(String[] args) {
        //构造BuffereddReader类型的对象，形参需要Reader类型
        //因为Reader是抽象类，所以构造对象需要传递子类InputStreamReader
        //构造InputStreamReader对象是，形参需要InputStream类型，因为InputStream也是抽象类
        //所以使用FilieInputStream类型构造对象
        try {
            BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("d:/b.txt")));
            String text = br.readLine();
            System.out.println(text);
            br.close();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }

    }
}

鲜衣怒马少年时，不负韶华行且知

Process finished with exit code 0

7.ObjectOutputStream类

（1）基本概念

java.io.ObjectOutputStream类主要用于将一个对象的所有内容整体写入到输出流中。

注意：只能将支持ava.io.Serializable接口的对象写入流中。
类通过实现ava.io.Serializablef接口以弃用其序列化功能。所谓序列化主要指将一个对象需要存储的相关信息有效组织成字节序列的转化过程。

（2）常用方法

ObjectouStream(OutputStream out)-根据参数指定引用来构造对OutputStreamd类是一个
抽象类，因此实参需要传递子类对象
void writeobject (Object obj)-用于将参数指定的对象整体写入到输出流中
void close()-用于关闭文件输出流并释放相关资源

package Demo01;

import java.io.Serializable;

public class User implements Serializable {
    private String name;
    private String password;
    private String phoneNumber;

    public User(String name, String password, String phoneNumber) {
        this.name = name;
        this.password = password;
        this.phoneNumber = phoneNumber;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", password='" + password + '\'' +
                ", phoneNumber='" + phoneNumber + '\'' +
                '}';
    }
}

package Demo01;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutput;
import java.io.ObjectOutputStream;

public class ObjectOutputDemo {
    public static void main(String[] args) {
        try {
            ObjectOutput oop = new ObjectOutputStream(new FileOutputStream("d:/c.txt"));
            User user = new User("柳","123456","13843438");
            oop.writeObject(user);
            System.out.println("写入成功");
            oop.close();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }

    }
}

写入成功

Process finished with exit code 0

8.ObjectInputstream类

（1）基本概念

java.io.ObjectlnputStream类主要用于从输入流一次性将对象整体读取出来
所谓反序列化主要指将有效组织的字节序列恢复为一个对象及相关信息的转化过程。

（2）常用方法

ObjectInputStream(InputStream is)-根据参数指定的引用来构造对象，其中InputStream类是一个抽象类，实参需要传递子类的对象。
Object readObject (）-主要用于从输入流中读取一个对象并返回无法通过返回值来判断是否读取到文件的末尾。
void close()-用于关闭文件输出流并释放相关的资源

package Demo01;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectInputStream;

public class ObjectInputDemo {
    public static void main(String[] args)  {
        try {
            ObjectInputStream ois = new ObjectInputStream(new FileInputStream("d:/c.txt"));
            Object os = ois.readObject();
            System.out.println(os);
            ois.close();
        } catch (IOException | ClassNotFoundException e) {
            throw new RuntimeException(e);
        }

    }
}

User{name='柳', password='123456', phoneNumber='13843438'}

Process finished with exit code 0

transient关键字

transient是java语言的关键字，用来表示一个域不是该对象串行化的一部分。当一个对象被串行化的时候，transient型变量的值不包括在串行化的表示中，然而非transient型的变量是被包括进去的。

小柳不言败

关注

26
点赞
踩
20

收藏

觉得还不错? 一键收藏
1
评论
实训第十一天

File类，I/O流
复制链接

扫一扫