IO流与反射

最新推荐文章于 2024-08-26 16:40:46 发布

A_xiaon

最新推荐文章于 2024-08-26 16:40:46 发布

阅读量760

点赞数 11

文章标签： java 开发语言

本文链接：https://blog.csdn.net/A_xiaon/article/details/141298519

版权

java I/O主要完成文件及文件夹的管理(File)。其中包含了流的概念。

8.1File

File表示一个文件的抽象类，是相关记录或放在一起的数据集合。能够实现对于文件或者是目录的管理。file类的API：

public static void main(String[] args) {
    //创建对象
    File file = new File("d:\\dic") ;
    
    //需求:如果某个文件夹不存在，则进行创建
    if(!file.exsits()) {
        file.mkdir() ; //创建一级目录
        file.mkdirs() ;//同时创建多级目录
    }
    
    file = new File(file,"a.txt") ;
    
    if(!file.exists()) {
        file.createNewFile() ; //创建一个新的文件
    }
    
    //如果dic文件夹存在，则删除
    if(file.exsits()) {
        file.delete() ; 
    }
    
    file = new File("d:") ;
    
    String[] files = file.list() ; //返回字符串数组，表示所有的文件的抽象路径。
    
    File[] fileList = file.listFiles() ; //返回File对象数组，因此在遍历时能够调用file对象进行相关的操作。
    
    file.getPath() ； //返回一个路径
    
    file.getAbsolutePath() ; //返回一个绝对路径
    
    file.getName() ; //获取到文件名
    
    file.length() ; //获取到文件的大小(长度)
    
    file.isDirectory() ; //判断是否是一个文件夹
    
    file.renameTo(file) ; // 重命名文件
    
    file.isFile() ; //是否是一个文件类型
}

8.2流

8.2.1输入流(Input)

8.2.1.1字节文件流

InputStream(抽象类)

FileInputStream

该类主要用于对文件进行读入，该类拥有多个异常，所以使用时要解决异常(throws |try...catch...finally)

FileInputStream fis = new FileInputStream(file对象 | 字符串抽象路径) ;
//如果文件不存在，那么FileInputStream 对象会自动创建该文件.

// 读取数据
int num = fis.read() ; //每次读取一个字节
//适合于大文件
byte[] bytes = new byte[1024] ;
int num = fis.read(bytes) ;

while((num = fis.read(bytes)) != -1) { //当读取到文件末尾时，返回-1
    String str = new String(bytes,0,num) ;
}

//最后不要忘记关闭资源
fis.close() ;

BufferedInputStream

FileInputStream fis = new FileInputStream(file对象 | 字符串抽象路径) ;

BufferedInputStream bis = new BufferedInputStream(fis) ;
//如果文件不存在，那么FileInputStream 对象会自动创建该文件.

// 读取数据
int num = bis.read() ; //每次读取一个字节
//适合于大文件
byte[] bytes = new byte[1024] ;
int num = bis.read(bytes) ;

while((num = bis.read(bytes)) != -1) { //当读取到文件末尾时，返回-1
    String str = new String(bytes,0,num) ;
}

//最后不要忘记关闭资源
fis.close() ;
bis.close() ;

8.2.1.2字符文件流

Reader(抽象类)

FileReader

Reader reader = new FileReader(file对象 | 字符串抽象路径) ;

//如果文件不存在，那么FileInputStream 对象会自动创建该文件.

// 读取数据
int num = reader.read() ; //每次读取一个字节
//适合于大文件
char[] chars = new char[1024] ;
int num = reader.read(chars) ;

while((num = reader.read(chars)) != -1) { //当读取到文件末尾时，返回-1
    String str = new String(chars,0,num) ;
}

//最后不要忘记关闭资源
reader.close() ;

BufferedReader

Reader reader = new FileReader(file对象 | 字符串抽象路径) ;

BufferedReader br = new BufferedReader(reader) ;

//如果文件不存在，那么FileInputStream 对象会自动创建该文件.

// 读取数据
int num = br.read() ; //每次读取一个字节
//适合于大文件
char[] chars = new char[1024] ;
int num = br.read(chars) ;

br.readLine() ; //读取一行的内容，如果读到文件末尾就会返回 null

while((num = br.read(chars)) != -1) { //当读取到文件末尾时，返回-1
    String str = new String(chars,0,num) ;
}

//最后不要忘记关闭资源
br.close() ;
reader.close() ;

8.2.2输出流(Output)

8.2.2.1字节文件流

OutputStream(抽象类)

FileOutputStream

FileOutputStream fos = new FileOutputStream(file对象 | 字符串抽象路径) ;
//如果文件不存在，那么FileInputStream 对象会自动创建该文件.

// 写出数据
fos.write(int num) //每次写出一个字节

byte[] bytes = "hello,world".getBytes() ;

fos.write(bytes,0,bytes.length) ;

fos.flush() ;
//最后不要忘记关闭资源
fos.close() ;

BufferedOutputStream

FileOutputStream fos = new FileOutputStream(file对象 | 字符串抽象路径) ;

BufferedOutputStream bos = new BufferedOutputStream(fos) ;
//如果文件不存在，那么FileInputStream 对象会自动创建该文件.

// 写出数据
bos.write(int num) //每次写出一个字符

byte[] bytes = "hello,world".getBytes() ;

fos.write(bytes,0,bytes.length) ;

bos.flush();
//最后不要忘记关闭资源
fos.close() ;
bos.close() ;

8.2.2.2字节文件流

Writer(抽象类)

FileWriter

FileWriter fw = new FileWriter (file对象 | 字符串抽象路径) ;
//如果文件不存在，那么FileInputStream 对象会自动创建该文件.

// 写出数据
fw.write(int c) //每次写出一个字符

char[] chars = new char[1024] ;
chars[0] = 'a' ;
chars[1] = 'b' ;

String str = new String(chars) ;
fw.write(str,0,str.trim().length()) ;

fw.flush() ;
//最后不要忘记关闭资源
fw.close() ;

BufferedWriter

FileWriter fw = new FileWriter (file对象 | 字符串抽象路径) ;

BufferedWriter bw= new BufferedWriter(fw) ;
//如果文件不存在，那么FileInputStream 对象会自动创建该文件.

// 写出数据
bw.write(int c) //每次写出一个字符

bw.write(str,0,str.length()) ;

bw.flush() ;
//最后不要忘记关闭资源
fw.close() ;
bw.close() ;

8.3序列化和反序列化

序列化的步骤：

注意：可以使用集合保存对象，然后将集合中的所有对象进行序列化。

反序列化的步骤：

注意：如果向文件中使用序列化机制写入多个对象，那么反序列化恢复对象时，必须按照写入的顺序读取

package com.csi.Test;

import com.csi.domain.Good;
import com.csi.domain.ShopCar;

import java.io.*;
import java.util.List;
import java.util.Scanner;

public class Function {

    //init方法提供从控制台输入购买信息
    public Good init(){
        Scanner input = new Scanner(System.in);
        String goodsNo;//商品编号
        String goodsName;//商品名称
        double goodsPrice;//产品单价
        int num;//商品数量
        System.out.println("产品号：");
        goodsNo = input.next();
        System.out.println("名称：");
        goodsName = input.next();
        System.out.println("产品单价：");
        goodsPrice = input.nextDouble();
        System.out.println("购买数量：");
        num = input.nextInt();
        Good goods = new Good(goodsName,goodsNo,goodsPrice,num);
        return goods;
    }

    //save方法（序列化） 保存对象到“save.bin”
    public void save(List<Good> list, File file) throws Exception{
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(file));
        oos.writeObject(list);
        System.out.println("成功序列化！");
        oos.flush();
        oos.close();
    }
    //load方法获取对象（反序列化），计算客户所需付款
    public void load() throws Exception{
        double total = 0;
        List<Good> lists = null;
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("d:\\save.bin"));
        lists = (List<Good>) ois.readObject();
        ois.close();
        System.out.println("产品名\t单价\t数量");
        for (Good good : lists){
            System.out.println(good.getGoodsName()+"\t\t"+good.getGoodsPrices()+"\t\t"+good.getGoodsNum());
            total += good.getGoodsPrices()* good.getGoodsNum();
        }
        System.out.println(total);

    }
}