IO
IO的体系结构
File类
文件和目录路径的抽象表示;
一个File类的对象表示计算机硬盘上的一个文件和目录;
File类的构造方法
//在当前目录下创建一个与demo.txt文件名相关联的文件对象
File f1 = new File("demo.txt");
//指明详细的路径以及文件名
File f2 = new File("E:","demo.txt");
//指明详细的路径以及目录名
File pf = new File("E:");
File cf = new File(pf,"demo.txt");
File类常用方法
public class FileDemo1 {
/*
一个File类的对象,表示计算机硬盘上的一个文件和目录。
*/
public static void main(String[] args) {
/*
File类的构造方法
File f1 = new File("E:/demo.txt");
File f2 = new File("E:","demo.txt");
File pf = new File("E:");
File cf = new File(pf,"demo.txt");
*/
//File类常用方法
File f = new File("E:/demo.txt");
System.out.println(f.canRead());
System.out.println(f.canWrite());
System.out.println(f.getPath()); //获得路径
System.out.println(f.getName()); //获取文件名
System.out.println(f.getParent()); //E:\
System.out.println(f.length());//文件内容长度,以字节为单位
System.out.println(f.isFile());//是否是文件
System.out.println(f.isDirectory());//是否为目录
System.out.println(f.isAbsolute());//路径名是否是绝对的
System.out.println(f.isHidden());//是否为隐藏文件
System.out.println(f.exists());//文件是否存在
System.out.println(f.lastModified());//对文件最后一次修改的是时间
System.out.println(new Date(1639485687368L));
}
}
输入流与输出流
输入:把电脑硬盘上的文件(数据)读入到程序中
输出:把程序上的数据写到目标地址中
流按着数据的传输方向分为:
输入流:往程序中读叫输入流。
输出流:从程序中往外写叫输出流。
字节流与字符流
字节流
每次读取数据时以字节为单位;
InputStream和OutputStream的子类都是字节流 ;
可以读写二进制文件,主要处理音频、图片、歌曲、字节流,处理单元
为1个字节。
public class Demo1 {
public static void main(String[] args) {
//把E盘中的demo.txt文件 复制到 F demo.txt
//File f = new File("E:/demo.txt");
FileInputStream in = null;
FileOutputStream out = null;
try {
//创建字节输入流对象.接入到指定的文件上,如果找不到文件 会报异常
in = new FileInputStream("E:/demo.txt");
//创建一个字节输出流对象,同时创建一个空文件, 如果路径不对,会报异常
out = new FileOutputStream("E:/demo1.txt");
//in.read() 返回int类 表示读到的那一个字节. 如果文件内容读完了,返回-1.
int b = 0;
while((b=in.read())!=-1){
out.write(b);
}
} catch (FileNotFoundException e) {
e.printStackTrace();
System.out.println("文件找不到");
} catch (IOException e) {
e.printStackTrace();
System.out.println("读或写异常");
}finally {
try {
if(in!=null){
in.close();//释放文件资源
}
if(out!=null){
out.close();
}
}catch (IOException ex){
}
}
}
}
字符流
每次以字符为单位进行读取操作;
Reader和Writer的子类都是字符流 ;
主要处理字符或字符串,字符流处理单元为1个字符。
节点流与处理流
根据封装类型不同流又分为 :节点流 、处理流
节点流
流对象中直接包含数据,对数据进行操作。
节点流中常用类:
字节输入流 FileInputStream
字节输出流 FileOutputStream
字符输入流 FileReader
字符输出流 FileWriter
public class Demo3 {
public static void main(String[] args) throws IOException {
//节点流: 直接包含数据,对数据进行操作
InputStream in = new FileInputStream("E:/feige.exe");
OutputStream out = new FileOutputStream("E:/feige1.exe");
//创建处理流(包装流) 底层有一个缓冲数组,每次将读到的数据先存入到缓冲数组中,等缓冲数组满了之后在实际操作
// 一旦自己定义的数组长度大于缓冲区数组大小,缓冲区数组就失效了
BufferedInputStream bin = new BufferedInputStream(in);
BufferedOutputStream bout = new BufferedOutputStream(out);
byte[] bytes = new byte[1024];
int size = 0;
while ((size = bin.read(bytes)) != -1) {
bout.write(bytes, 0, size);
}
bin.close();
bout.flush();//刷新缓冲区
bout.close();
}
}
处理流
如果流封装的是其它流对象,称为处理流。
处理流提供了缓冲功能,提高读写效率,同时增加了一些新的方法。
处理流中常用类 :
缓冲字节输出流 BufferedOutputStream
缓冲字节输入流 BufferedInputStream
缓冲字符输入流 BufferedReader
缓冲字符输出流 BufferedWriter
public class CharDemo2 {
public static void main(String[] args) throws IOException {
FileReader reader = new FileReader("E:/demo.txt");
FileWriter writer = new FileWriter("E:/demo.txt",true); //向文件中追加内容
BufferedReader breader = new BufferedReader(reader);
BufferedWriter bwriter = new BufferedWriter(writer);
//readLine()每次读一行数据,读完返回null
String s = null;
while ((s=breader.readLine())!=null){
bwriter.write(s);
bwriter.newLine(); //换行
}
breader.close();
bwriter.flush();
bwriter.close();
}
}
Print流
打印流只做输出,不做输入,单向从程序中向外输出。
public class PrintWriterDemo {
public static void main(String[] args) throws FileNotFoundException {
PrintWriter out = new PrintWriter("E:/demo.html");
out.print("<h1>aaa</h1>"); //print打印不换行
out.println("<h1>bbb</h1>"); //println打印换行
/*底层都用的是write()*/
out.write("<h1>ccc</h1>");
}
}
对象输入输出流
对象:程序运行时,创建的对象。
将对象信息写出到文件中,做到持久保存(序列化)。
对象的输出流: ObjectOutputStream
对象的输入流: ObjectInputStream
public class Users implements Serializable {
//为类生成一个唯一编号,
// 如果不显示的声明此编号,运行时默认会生成一个,但是类一旦改变编号也会变
private static final long serialVersionUID = 416774116252187404L;
private int num;
private String name;
public Users(int num, String name) {
this.num = num;
this.name = name;
}
public int getNum() {
return num;
}
public void setNum(int num) {
this.num = num;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Users{" +
"num=" + num +
", name='" + name + '\'' +
'}';
}
}
public class ObjectDemo1 {
public static void main(String[] args) throws IOException, ClassNotFoundException {
//对象输出
FileOutputStream fout = new FileOutputStream("E:/obj.txt");
ObjectOutputStream out = new ObjectOutputStream(fout);
Users users = new Users(100,"Amy");
out.writeObject(users); //对象序列化,将程序运行时创建的对象输出到指定的文件中,持久保存
out.close();
//对象输入
FileInputStream in = new FileInputStream("E:/obj.txt");
ObjectInputStream oin = new ObjectInputStream(in);
Users users1 = (Users) oin.readObject(); //对象反序列化,是java创建对象的方法之一
System.out.println(users1);
}
}