IO
把电脑硬盘中的数据读到程序中,称为输入,进行数据的read操作
把程序往外部设备写数据,称为输出,进行数据的write操作
File类
一个File对象可以表示计算机硬盘上的一个文件或目录(文件夹)
可以获取文件信息,创建文件,删除文件
但是不能对文件中的数据进行读写操作
一些File类的方法
public class FileDemo {
public static void main(String[] args) {
/*
File类中构造方法
*/
/*String p = "E:/";
File f1 = new File(p,"demo.txt");
File f2 = new File(p,"demo.txt");*/
/*
File pf = new File("E:");
File f2 = new File(pf,"demo.txt");
*/
File f = new File("E:/demo.txt");
System.out.println(f.canExecute());// 文件是否可以被执行
System.out.println(f.canRead());// 是否可以读取
System.out.println(f.canWrite());// 是否可以写
System.out.println("---------------------------");
System.out.println(f.exists());// 文件是否存在
System.out.println(f.getAbsolutePath());//获得文件绝对地址
System.out.println(f.getName());// 获取文件名字
System.out.println(f.getParent());// 获取父级地址
System.out.println(f.isAbsolute());//是否为绝对路径
System.out.println("---------------------------");
System.out.println(f.isDirectory());// 是否是文件夹
System.out.println(f.isFile());// 是否是文件
System.out.println(f.isHidden());// 是否隐藏文件
System.out.println(new Date(f.lastModified()));//文件最后一次修改的时间
System.out.println(f.length());//文件内容长度 以字节为单位
}
}
流的分类
按照流(java提供的读写文件的类)的读写单位划分为
字节流:每次读写是以字节为单位(计算机中的所有数据存储都是字节为单位) 可以读取任意文件(视频,音频...)
字符流:每次都写是以字符为单位 只能读取纯文本文件(txt,java,html)
字节流
输入字节流:InputStream
FileInputStream就是节点流 直接负责对接文件,对文件进行读写操作
输出字节流:OutputStream
FileOutputStream
public class StreamDemo1 {
public static void main(String[] args) throws IOException {
//创建一个输入字节流对象 并为其指定要读的文件
FileInputStream in = new FileInputStream("E:/demo.txt");//输入的源文件不存在,会报错
FileOutputStream out = new FileOutputStream("D:/demo.txt");//输出时文件不存在是可以自动创建
//in.read() 每次读到一个字节数据 并返回, 直到读完后返回-1.
int b = 0;
while ((b = in.read()) != -1) {
out.write(b);
}
in.close();
out.close();//关闭流通道 释放文件
}
}
public class StreamDemo2 {
public static void main(String[] args) throws IOException {
FileInputStream in= new FileInputStream("E:/feige.exe");
FileOutputStream out = new FileOutputStream("E:/demo.exe");
//read() write(int b) 每次只能读入 写出一个字节 效率低, 读写次数多
//in.read(b); 每次读一个byte数组个字节内容,返回实际向数组装入的字节数量 读完也是返回-1
byte[] b = new byte[1024];
int size=0;
// 每次最多读取b.length个字节数据为字节数组
while((size=in.read(b))!=-1){
System.out.println(size);
//每次向外写出一个byte数组个字节,从第0个开始,写size个,效率高
out.write(b,0,size);
}
in.close();
out.close();
}
}
根据封装类型不同流分为:
节点流: 封装的是某种特定的数据源,如文件、字符串、字符串数组等
FileInputStream就是节点流 直接负责对接文件,对文件进行读写操作
处理流:封装的是其他流对象,处理流提供了缓冲功能,提高读写效率,同时增加了一些新的方法
public class StreamDemo4 {
public static void main(String[] args) throws IOException {
//节点流 直接负责数据读和写
FileInputStream in = new FileInputStream("E:/feige.exe");
FileOutputStream out = new FileOutputStream("E:/demo.exe");
//处理流/包装流/缓存流(带缓冲区)
BufferedInputStream bin = new BufferedInputStream(in);
BufferedOutputStream bout = new BufferedOutputStream(out);
byte [] b = new byte[1024];
int size = 0;
while((size=bin.read())!=-1){
bout.write(b,0,size);
}
bin.close();
bout.flush();//刷新缓存区
bout.close();
}
}
字符流
字符流只能读纯文本文件
输入字符流:
Reader
InputStreamReader
输入转换流,可以把原始字节结合 编码转为字符
FileReader 可以读入一个字符
输出字符流:
Writer
OutputStreamWriter
将字符转为字节
FileWriter 可以写出一个字符
FileReader reader = new FileReader("E:/demo.txt");
FileWriter writer = new FileWriter("E:/demo1.txt");
char[] cs = new char[10];
int size = 0;
// reader.read();// 一次读到一个字符编码
while((size=reader.read(cs))!=-1){
System.out.println(size);
writer.write(cs,0,size);
}
reader.close();
writer.close();
//节点流 直接包含数据
FileReader reader = new FileReader("E:/demo.txt");
FileWriter writer = new FileWriter("E:/demo2.txt",true);//后面输出不会覆盖前面的,会保留前面的内容
//字符处理流
BufferedReader breader = new BufferedReader(reader);
BufferedWriter bwriter = new BufferedWriter(writer);
//readLine() 一次读一行数据 一次缓冲一行数据
String line = null;
while((line=breader.readLine())!=null){
bwriter.write(line);//一次写出一行数据
bwriter.newLine();//插入一个换行符
}
breader.close();
bwriter.flush();//缓冲流关闭前需要刷新
bwriter.close();
字符处理流这里我们可以一行一行的读和写,这样加大了读写操作的效率
对象输入流和对象输出流
对象---指的是java程序运行时产生的对象
将程序运行时,创建的对象,输出到一个文件中
为什么要将运行时的对象输出到文中?
为了实现数据 持久保存 有时,服务器要关闭(程序结束运行),结束运行时,将一些保存下来
对象输出-->对象序列化
对象输入流 将文件中存储的对象信息 在输入到程序中-->对象反序列化(java中创建对象的方式之一)
java中创建对象 不仅仅只有new一种 对象反序列化 反射
创建一个User类 并且实现Serializable接口,如果不实现的话,那么此类对象信息将无法被输出到文件中
//需要被序列化的类,必须实现Serializable接口,会为类生成一个序列化id号,是唯一与类对应
public class User implements Serializable {
private Integer id;
private String name;
public User(Integer id, String name) {
this.id = id;
this.name = name;
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
public class ObjectStream {
public static void main(String[] args) throws IOException, ClassNotFoundException {
/* Date date = new Date();
String s = new String("abc");
User user = new User(1, "jim");
// 讲对象信息输出到文件中 称为对象序列化 对象的类必须实现java.io.Serializable接口
FileOutputStream out = new FileOutputStream("E:/obj.txt");
ObjectOutputStream objectOut = new ObjectOutputStream(out);
objectOut.writeObject(date);
objectOut.writeObject(s);
objectOut.writeObject(user);
objectOut.flush();
objectOut.close();*/
// 对象反序列化 将文件中的信息输入到程序 再创建一个对象
FileInputStream in = new FileInputStream("E:/obj.txt");
ObjectInputStream objIn = new ObjectInputStream(in);
Date date = (Date) objIn.readObject();
String s = (String) objIn.readObject();
User user = (User) objIn.readObject();
System.out.println(date);
System.out.println(s);
System.out.println(user.getId()+":"+user.getName());
}
}