File类
File类是java.io包中很重要的一个类；
File类的对象可以表示文件，还可以表示目录，在程序中一个File类对象可以代表一个文件或目录；
File对象可以对文件或目录的属性进行操作，如：文件名、最后修改日期、文件大小等；
File对象无法操作文件的具体数据，即不能直接对文件进行读/写操作。
//在当前目录下创建一个与aaa.txt文件名相关联的文件对象
File f1 = new File("aaa.txt");
//指明详细的路径以及文件名，请注意双斜线或用反斜杠
File f2 = new File("D:\\Java\\Hello.java");
//指明详细的路径以及目录名，请注意双斜线
File f3 = new File("D:\\Java");
File类的常用方法
| 方 法 原 型 | 说 明 |
|---|---|
| boolean exists() | 判断文件是否存在，存在返回true，否则返回false |
| boolean isFile() | 判断是否为文件，是文件返回true，否则返回false |
| boolean isDirectory() | 判断是否为目录，是目录返回true，否则返回false |
| String getName() | 获得文件的名称 |
| long length() | 获得文件的长度（字节数） |
| boolean createNewFile()throws IOException | 创建新文件，创建成功返回true，否则返回false，有可能抛出IOException异常，必须捕捉 |
| boolean delete() | 删除文件，删除成功返回true，否则返回false |
| public String[] list() | **将目录下的子目录及文件的名字，返回到String数组中 |
| public File[] listFiles() | 将目录下的子目录及文件的实例返回到File数组中 |
三种构造方法
//File类的三种构造方法
File f = new File("D:/java.txt");//创建File对象时，不检测文件是否存在
String p = "D:\\";
File f1 = new File(p,"java.txt");
File fp = new File("E:\\");
File f2 = new File(fp,"java.txt");
对文件进行操作
System.out.println(f.length());//获得文件内容长度，以字节为单位
System.out.println(f.getParent());
System.out.println(f.getName());
System.out.println(f.getAbsolutePath());//获得相对路径的文件的绝对路径
System.out.println(f.exists());//文件是否存在，返回布尔类型
System.out.println(f.isDirectory());//判断是否是文件夹
System.out.println(f.isHidden());//判断是否是隐藏文件
System.out.println(f.isAbsolute());//判断路径是否为绝对路径
System.out.println(f.canRead());//能不能读
System.out.println(f.canWrite());//能不能写
System.out.println(f.canExecute());
System.out.println(f.getPath());
System.out.println(f.lastModified());//最后一次修改时间，输出为long类型的
String d = DateUtil.dateToString(f.lastModified(),"yyyy-MM-dd HH:mm:ss");
System.out.println(d);
File f = new File("D:/java.txt");
try {
System.out.println(f.createNewFile());//文件已存在，不会再创建，返回false，文件不存在，创建成功返回true
} catch (IOException e) {
e.printStackTrace();
}
f.delete();//文件存在，删除成功，返回true，文件不存在，返回false
File f1 = new File("D：/demo");
System.out.println(f1.mkdir());//只能创建单级文件夹
File f2 = new File("D：/demo/demo");
f2.mkdirs();//可以创建多级文件夹
f2.delete();//删除文件夹，删除时，文件及必须为空
//获取指定目录下所有子级的文件或目录,以字符串形式返回
/*String [] farray = f2.list();
for(String arr:farray){
System.out.println(arr);
}
*/
//添加过滤条件，筛选文件
String [] farray = f2.list(new FilenameFilter() {
@Override
public boolean accept(File dir, String name) {
//return name.endsWith("txt");
return StringUtil.subFileType(name).equalsIgnoreCase("txt");
}
});
for(String arr:farray){
System.out.println(arr);
}
File [] fs = f2.listFiles();
for(File n:fs){
System.out.println(n.delete());//删除
}
File fa = new File("D:\\java.txt");
File fb = new File("D:\\java2.txtx");
fa.renameTo(fb);//重命名
输入输出
输入输出的概念
把电脑硬盘上的数据读到程序中，称为输入,即input,进行数据的read操作
从程序往外部设备写数据，称为输出，即output，进行数据的write操作
输入和输出是相对于程序
输入流与输出流
流按着数据的传输方向分为：
输入流：往程序中读叫输入流。
输出流：从程序中往外写叫输出流。
字符流与字节流
从数据流编码格式上划分为
字节流
以字节为单位读取，以Stream结尾
InputStream和OutputStream的子类都是字节流
可以读写二进制文件，主要处理音频、图片、歌曲、字节流,处理单元为1个字节。
字节流中常用类
文件字节输入流 FileInputStream
InputStream的基本方法
读取一个字节并以整数的形式返回(0~255),如果返回-1已到输入流的末尾。
int read() throws IOException
读取一系列字节并存储到一个数组buffer，
返回实际读取的字节数，如果读取前已到输入流的末尾返回-1
int read(byte[] buffer) throws IOException
关闭流释放内存资源
void close() throws IOException
文件字节输出流 FileOutputStream
OutputStream的基本方法
向输出流中写入一个字节数据,该字节数据为参数b的低8位
void write(int b) throws IOException
将一个字节类型的数组中的从指定位置（off）开始的
len个字节写入到输出流
void write(byte[] b, int off, int len) throws IOException
关闭流释放内存资源
void close() throws IOException
/*
创建FileInoutStream对象，指定要输入的文件，文件不存在就抛出异常
*/
FileInputStream in = new FileInputStream("D:\\java.txt");
/*
创建FileOutputStream对象,会自动创建输出的目标文件
*/
out = new FileOutputStream("D:\\java1.txt");
int b =0;//记录每一次读到的字节的值
while ((b = in.read())!=-1){
//每read一次，从输入流中读取一个字节，返回，文件内容全部返回后就返回-1
out.write(b);
}
//关闭通道，释放资源
in.close();
out.close();
高效读取
FileInputStream in = new FileInputStream("D:\\java.txt");
FileOutputStream out = new FileOutputStream("D:\\java1.txt");
byte[] b = new byte[10];//存储读到的内容
int length = 0;
while ((length =in.read(b))!=-1){
System.out.println(length);
// out.write(b);
out.write(b,0,length);//向外写出一个byte数组个字节，从数组指定位置开始，写length个字节
}
/*
read()每次从输入流中读取一个字节，返回字节值，读完返回1
read(byte[] b)每次从输入流中读取一个byte数组长度个字节，返回数组中实际装入内容个数，读完返回-1
*/
//关闭通道，释放资源
in.close();
out.close();
字符流
以字符为单位读取，以Reader和Writer结尾只能z纯文本文件能读取
Reader和Writer的子类都是字符流
主要处理字符或字符串，字符流处理单元为1个字符。
字节流将读取到的字节数据，去指定的编码表中获取对应文字。
字符流中常用类
字符输入流 FileReader
字符输出流 FileWriter
Reader 的基本方法
读取一个字符并以整数的形式返回,
如果返回-1已到输入流的末尾。
int read() throws IOException
读取一系列字符并存储到一个数组buffer，
返回实际读取的字符数，如果读取前已到输入流的末尾返回-1
int read(char[] cbuf) throws IOException
关闭
void close() throws IOException
Writer 的基本方法
向输出流中写入一个字符数据,该字节数据为参数b的16位
void write(int c) throws IOException
一个字符类型的数组中的数据写入输出流，
void write(char[] cbuf) throws IOException
将一个字符类型的数组中的从指定位置（offset）开始的length个字符写入到输出流
void write(char[] cbuf, int offset, int length) throws IOException
关闭
void close() throws IOException
/*
字符流以字符为单位读写数据
只能读纯文本文件
Reader
转换流 InputStreamReader
FileReader
BufferedReader
Writer
转换流 OutputStreamWriter
FileWriter
BufferedWriter
*/
FileReader reader = new FileReader("D:\\javasc.txt");
FileWriter writer = new FileWriter("D:\\java1.txt");
/*int c = ' ';
while((c= reader.read())!=-1){
writer.write(c);
}*/
char [] c = new char[5];
int length = 0;
while((length=reader.read(c))!=-1){
System.out.println(Arrays.toString(c));
writer.write(c,0,length);
}
writer.close();
reader.close();
FileReader reader = new FileReader("D:\\javasc.txt");
BufferedReader breader = new BufferedReader(reader);
FileWriter writer = new FileWriter("D:\\java2.txt",true);//向文件中追加内容
BufferedWriter bwriter = new BufferedWriter(writer);
/*char [] c = new char[10];
breader.read()*/
String line = null; //readLine() 一次读一行数据
while((line=breader.readLine())!=null){
bwriter.write(line);//一次写一个字符串
bwriter.newLine();//换行
}
节点流与处理流
根据封装类型不同流又分为
节点流
处理流
节点流
如果流封装的是某种特定的数据源，如文件、字符串、字符串数组等，则称为节点流。
节点流中常用类
字节输入流 FileInputStream
字节输出流 FileOutputStream
字符输入流 FileReader
字符输出流 FileWriter
处理流
如果流封装的是其它流对象，称为处理流。
处理流提供了缓冲功能，提高读写效率,同时增加了一些新的方法。
处理流中常用类
缓冲字节输出流 BufferedOutputStream
缓冲字节输入流 BufferedInputStream
缓冲字符输入流 BufferedReader
缓冲字符输出流 BufferedWriter
//创建输入节点流
FileInputStream in = new FileInputStream("D:\\Organic.thmx");
//创建处理，内部有一个缓冲数组，默认为8192个字节
BufferedInputStream bin =new BufferedInputStream(in);
FileOutputStream out = new FileOutputStream("D:\\Organica.thmx");
BufferedOutputStream bout = new BufferedOutputStream(out);
// int b = 0;
// while ((b=bin.read())!=-1){
// bout.write(b);
// }
byte [] b = new byte[1024];
int length = 0;
while ((length=bin.read(b))!=-1){
bout.write(b,0,length);
}
bout.flush();//刷新缓冲区
bout.close();
bin.close();
打印流
Print 打印流：只做输出没有输入
打印流分为字节打印流和字符打印流
PrintWriter：字符打印流
print方法可以打印各种类型数据
public static void main(String[] args) throws FileNotFoundException {
/*
打印流：单向的从程序中向外输出数据
PrintWriter：打印字符流
例如：从服务器端向客户端浏览器输出网页信息
*/
PrintWriter pw = new PrintWriter("D:\\javasc.html");//打印字符流
pw.print("<h1>这是从服务端响应回来的数据<h1>");
pw.print("<h1>这是从服务端响应回来的数据<h1>");
pw.print("<h1>这是从服务端响应回来的数据<h1>");
pw.print("<h1>这是从服务端响应回来的数据<h1>");
pw.close();
}
对象输入输出流
对象的输入输出流 : 主要的作用是用于写入对象信息与读取对象信息。 对象信息一旦写到文件上那么对象的信息
就可以做到持久化了
对象的输出流： ObjectOutputStream 对象的输入流: ObjectInputStream
要将序列化之后的对象保存下来，需要通过对象输出流(ObjectOutputStream)将对象状态保存，之后再通过对象
输入流(ObjectInputStream)将对象状态恢复。
在ObjectInputStream 中用readObject()方法可以直接读取一个对象
在ObjectOutputStream中用writeObject()方法可以直接将对象保存到输出流中。
public class ObjectStreamDemo {
/*
对象输入输出字节
对象：内存中的对象
为什么要将对象输出
内存中的数据电脑关闭,服务器停止数据就会消失
有时候,需要将这些数据保存起来(这个过程被称为对象序列化)
*/
public static void main(String[] args) throws IOException, ClassNotFoundException {
FileOutputStream out = new FileOutputStream("D:\\javasc.txt");
ObjectOutputStream oout = new ObjectOutputStream(out);
String s= "abc";
Date date = new Date();
oout.writeObject(s);
oout.writeObject(date);
oout.close();
FileInputStream in = new FileInputStream("D:\\javasc.txt");
ObjectInputStream oin = new ObjectInputStream(in);
String s1 = (String)oin.readObject();
Date date1 = (Date)oin.readObject();
System.out.println(s1);
System.out.println(date1);
oin.close();
}
}
对象序列化
内存中的数据电脑关闭,服务器停止数据就会消失
有时候,需要将这些数据保存起来(这个过程被称为对象序列化)
对象的寿命通常随着生成该对象的程序的终止而终止。
有时候，可能需要将对象的状态保存下来，在需要时再将对象恢复。
既然对象的输出流将对象写入到文件中称之为对象的序列化，所以必须要实现Serializable接口。
Serializable接口中没有任何方法。当一个类声明实现Serializable接口后，表明该类可被序列化。
在类中可以生成一个编号
private static final long serialVersionUID = -5974713180104013488L;
随机生成 唯一的
serialVersionUID 用来表明实现序列化类的不同版本间的兼容性。某个类在与之对应的对象已经序列化出去后做
了修改，该对象依然可以被正确反序列化
实现Serializable接口的类
import java.io.Serializable;
/*
需要被序列化类的对象,此类必须实现Serializable接口
实现此接口后,此类默认会生成一个序列化id号,当此类的内容发生修改后,id号会发生变化(之前对象中的id号与修改后类中的id不匹配)
也可以使用工具生成一个序列化id号,这样类发生修改后,此id依然不会改变
*/
public class Student implements Serializable {
private static final long serialVersionUID = -6586564915174296422L;
int num;
/*
被transient关键字修饰的属性,可以不被序列化
*/
transient String name;//最后输出的name=null
public Student(int num, String name) {
this.num = num;
this.name = name;
}
@Override
public String toString() {
return "Student{" +
"num=" + num +
", name='" + name ;
}
}
设置提示生成序列化接口
序列化
对象的输出流将指定的对象写入到文件的过程，就是将对象序列化的过程
import java.io.*;
public class ObjectStreamDemo1 {
public static void main(String[] args) throws IOException {
//序列化
FileOutputStream out = new FileOutputStream("D:\\javasc.txt");
ObjectOutputStream oout = new ObjectOutputStream(out);
Student stu = new Student(101,"jim");
oout.writeObject(stu);
oout.close();
}
}
反序列化
对象的输入流将指定序列化好的文件读出来的过程，就是对象反序列化的过程。
import java.io.*;
public class ObjectStreamDemo2 implements Serializable{
public static void main(String[] args) throws IOException, ClassNotFoundException {
//反序列化
FileInputStream in = new FileInputStream("D:\\javasc.txt");
ObjectInputStream oin = new ObjectInputStream(in);
Student student = (Student)oin.readObject();
System.out.println(student);
oin.close();
}
}
扫一扫
104
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
