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);
}
}
8.4反射
反射：通过 .class文件来获取文件当中结构。可以根据获取到的属性或者是方法进行反射调用。反射具有一定危险性。 动态的从jvm虚拟机找到正在运行.class文件，之后可以动态地实现方法或者是属性的调用以及增强。
使用反射的基本步骤
Class类是java 反射机制的起源和入口
每个类都有自己的Class对象 用于获取与类相关的各种信息 提供了获取类信息的相关方法 Class类继承自Object类
Class类存放类的结构信息
类名、父类、接口、方法、构造方法、属性、注释
使用Class类获取类的结构信息
获取Class对象的方式
方法一：对象.getClass()
方法二: 类.Class
方法三：Class.forName()
操作属性的基本步骤
调用方法的基本步骤：
扫一扫
3525
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
