io流的文件相关层次图
File类
文件是用来保存数据的，目录是管理文件的特殊机制
在Java语言中，文件和目录的管理是由java.io.File类来实现的。File类也属于java.io包，但它不是InputStream或者OutputStream的子类，因此不负责数据的输入和输出，而是专门管理磁盘的文件和目录。
每个File类的对象表示一个磁盘文件或目录，其对象属性中包含了文件或目录的相关信息，如名称、长度、所含文件个数等，调用它的方法则可以完成对文件或目录的常用管理操作，例如，创建、删除等操作。
常用的File方法
判断
createNewFile() 在指定位置创建一个空文件，成功就返回true，如果已存在就不创建然后返回false
mkdir() 在指定位置创建目录，这只会创建最后一级目录，如果上级目录不存在就抛异常。
mkdirs() 在指定位置创建目录，这会创建路径中所有不存在的目录。
renameTo(File dest) 重命名文件或文件夹，也可以操作非空的文件夹，文件不同时相当于文件的剪切,剪切时候不能操作非空的文件夹。移动/重命名成功则返回true，失败则返回false。
删除：
delete() 删除文件或一个空文件夹，如果是文件夹且不为空，则不能删除，成功返回true，失败返回false。
deleteOnExit() 在虚拟机终止时，请求删除此抽象路径名表示的文件或目录，保证程序异常时创建的临时文件也可以被删除
判断：
exists() 文件或文件夹是否存在。
isFile() 是否是一个文件，如果不存在，则始终为false。
isDirectory() 是否是一个目录，如果不存在，则始终为false。
isHidden() 是否是一个隐藏的文件或是否是隐藏的目录。
isAbsolute() 测试此抽象路径名是否为绝对路径名。
获取：
getName() 获取文件或文件夹的名称，不包含上级路径。
getPath() 返回绝对路径，可以是相对路径，但是目录要指定
getAbsolutePath() 获取文件的绝对路径，与文件是否存在没关系
length() 获取文件的大小（字节数），如果文件不存在则返回0L，如果是文件夹也返回0L。
getParent() 返回此抽象路径名父目录的路径名字符串；如果此路径名没有指定父目录，则返回null。
lastModified() 获取最后一次被修改的时间。
文件夹相关：
staic File[] listRoots() 列出所有的根目录（Window中就是所有系统的盘符）
list() 返回目录下的文件或者目录名，包含隐藏文件。对于文件这样操作会返回null。
list(FilenameFilter filter) 返回指定当前目录中符合过滤条件的子文件或子目录。对于文件这样操作会返回null。
listFiles() 返回目录下的文件或者目录对象（File类实例），包含隐藏文件。对于文件这样操作会返回null。
listFiles(FilenameFilter filter)返回指定当前目录中符合过滤条件的子文件或子目录。对于文件这样操作会返回null。流
流是指同一台计算机或网络中不同计算机之间有序运动着的数据序列，Java把这些不同来源和目标的数据都统一抽象为数据流。流序列中的数据可以是没有进行加工的原始数据（二进制字节数据），也可以是经过编码的符合某种格式规定的数据，Java中提供了不同的流类对它们进行处理。1.输入流与输出流
一个流，必有源端和目的端，它们可以是计算机内存的某些区域，也可以是磁盘文件，甚至可以是Internet上的某个URL。流的方向是重要的，根据流的方向，流可分为两类：输入流和输出流。用户可以从输入流中读取信息，但不能写它。相反，对输出流，只能往输出流写，而不能读它。1.1输入流
在Java中，程序可以打开一个输入流，输入流的信息源可以位于文件、内存或网络套接字(socket)等地方，信息源的类型可以是包括对象、字符、图像、声音在内的任何类型。一旦打开输入流后，程序就可从输入流串行地读数据。1.2输出流
类似地，程序也能通过打开一个输出流并按顺序写入数据来将信息送至目的端。2.字节流与字符流
Java流包括字节流和字符流，字节流通过IO设备以字节数据的方式读入，而字符流则通过字节流读入数据转化成字符“流”的形式由用户驱使。计算机并不区分二进制文件与文本文件。所有的文件都是以二进制形式来存储的，因此，从本质上说，所有的文件都是二进制文件。所以字符流是建立在字节流之上的，它能够提供字符层次的编码和解码。例如，在写入一个字符时，Java虚拟机会将字符转为文件指定的编码（默认是系统默认编码），在读取字符时，再将文件指定的编码转化为字符。
字节流示例（输入输出）
package file;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class Demo04 {
public static void main(String[] args) throws IOException {
// TODO Auto-generated method stub
writefile(new File("D:\\e.txt"));
readfile(new File("D:\\e.txt"));
}
private static void readfile(File srcFile) throws IOException {
// TODO Auto-generated method stub
//创建从文件到程序的流通道
FileInputStream fileinputstream = new FileInputStream(srcFile);
byte [] buf = new byte[1024];
int len = 0;
//获取文件内容
while((len = fileinputstream.read(buf))!= -1){
System.out.println(new String(buf,0,len));
}
}
private static void writefile(File destFile) throws IOException {
// TODO Auto-generated method stub
FileOutputStream fileoutstream = new FileOutputStream(destFile);
String content = "java io text";
byte[] buf = content.getBytes();
fileoutstream.write(buf);
fileoutstream.close();
}
}
字符流示例（输入输出）
package file;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Reader;
import java.io.Writer;
//字符流
public class Demo14 {
public static void main(String[] args) throws IOException {
// TODO Auto-generated method stub
writerToFile(new File("D:\\a.txt"));
ReaderFromFile(new File("D:\\a.txt"));
}
private static void writerToFile(File path) throws IOException {
// TODO Auto-generated method stub
Writer fw = new FileWriter(path);
char[] cbuf = "java io".toCharArray();
fw.write(cbuf);
fw.close();
}
private static void ReaderFromFile(File path) throws IOException {
// TODO Auto-generated method stub
Reader rd = new FileReader(path);
char[] cbuf = new char[1024];
int len = 0;
while ((len = rd.read(cbuf))!= -1){
System.out.println(cbuf);
}
rd.close();
}
}3.常用类应用示例
1. SequenceInputStream序列流，对多个流进行合并。
SequenceInputStream表示其他输入流的逻辑串联。它从输入流的有序集合开始，并从第一个输入流开始读取，直到到达文件末尾，接着从第二个输入流读取，依次类推，直到到达包含的最后一个输入流的文件末尾为止。
package file;
/*SequenceInputStream 表示其他输入流的逻辑串联。它从输入流的有序集合开始，并从第一个输入流开始读取，直到到达文件末尾，
接着从第二个输入流读取，依次类推，直到到达包含的最后一个输入流的文件末尾为止
*/
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.SequenceInputStream;
public class Demo09 {
public static void main(String[] args) throws IOException {
String in1 = "D://a.txt";
String in2 = "D://b.txt";
String out = "D://k.txt";
sis(in1,in2,out);
}
private static void sis(String in1, String in2, String out) throws IOException {
// TODO Auto-generated method stub
FileInputStream fis1 = new FileInputStream(in1);
FileInputStream fis2 = new FileInputStream(in2);
FileOutputStream fos = new FileOutputStream(out);
SequenceInputStream s = new SequenceInputStream(fis1, fis2);
int len = 0;
byte[] buf = new byte[1024];
while((len = s.read(buf))!= -1){
fos.write(buf, 0, len);
}
s.close();
fos.close();
}
}SequenceInputStream 实现文件的切割与合并
2.对象序列化
ObjectOutputStream 和 ObjectInputStream 分别与 FileOutputStream 和 FileInputStream 一起使用时，可以为应用程序提供对对象图形的持久存储。ObjectInputStream 用于恢
复那些以前序列化的对象。其他用途包括使用套接字流在主机之间传递对象，或者用于编组和解组远程通信系统中的实参和形参。
对象的序列化： 将内存中的对象直接写入到文件设备中
对象的反序列化： 将文件设备中持久化的数据转换为内存对象
package file;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
public class Demo12 {
public static void main(String[] args) throws IOException, ClassNotFoundException {
// TODO Auto-generated method stub
person p1 = new person("Tom",22);
//序列化
FileOutputStream fos = new FileOutputStream(new File("D:\\person\\a.txt"));
ObjectOutputStream oos = new ObjectOutputStream(fos);
oos.writeObject(p1);
oos.close();
fos.close();
//反序列化
FileInputStream fis = new FileInputStream(new File("D:\\person\\a.txt"));
ObjectInputStream ois = new ObjectInputStream(fis);
person p = (person)ois.readObject();
System.out.println(p);
}
}
class person implements Serializable {
/*类通过实现 java.io.Serializable 接口以启用其序列化功能。
未实现此接口的类将无法使其任何状态序列化或反序列化。可序列化类的所有子类型本身都是可序列化的。
序列化接口没有方法或字段，仅用于标识可序列化的语义。
如果对象没有实现接口Serializable，在进行序列化时会抛出：NotSerializableException 异常。*/
private static final long serialVersionUID = 1L;
/*serialVersionUID 用于给类指定一个UID。该UID是通过类中的可序列化成员的数字签名运算出来的一个long型的值。
只要是这些成员没有变化，那么该值每次运算都一样。该值用于判断被序列化的对象和类文件是否兼容。
如果被序列化的对象需要被不同的类版本所兼容。可以在类中自定义UID。定义方式：static final long serialVersionUID = 1L;*/
public String name;
public int age;
public person(){
}
public person(String name , int age){
this.name = name;
this.age = age;
}
public String toString(){
return "[姓名："+name+",年龄："+age+"]";
}
}可以和流相关联的集合对象Properties.
Properties:该集合不需要泛型，因为该集合中的键值对都是String类型。
package file;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Properties;
//Properties：该类是一个Map的子类，提供了可以快速操作配置文件的方法
public class Demo15 {
public static void main(String[] args) throws IOException {
// TODO Auto-generated method stub
loadFile();
}
private static void loadFile() throws IOException {
// TODO Auto-generated method stub
//创建Properties对象
Properties prop = new Properties();
//创建流通道
FileInputStream fis = new FileInputStream("D:\\ini.properties");
//将配置文件加载到Properties集合中
prop.load(fis);
// 通过键获取指定的值
Object object = prop.get("java");
System.out.println(object);
// 通过键修改值
prop.setProperty("java", "77");
// 将集合中的数据写入到配置文件中。
FileOutputStream fos = new FileOutputStream("D:\\ini.properties");
// 注释：
prop.store(fos, "text properties");
fis.close();
fos.close();
}
}package file;
import java.io.File;
import java.io.IOException;
import java.io.PrintStream;
import java.io.PrintWriter;
public class Demo16 {
public static void main(String[] args) throws IOException{
/*PrintStream：是一个字节打印流，System.out对应的类型就是PrintStream。*/
PrintStream ps = System.out;
ps.print("中国");
ps.close();
//输出重定向
PrintStream ps2 = new PrintStream(new File("D:\\log.txt"));
System.setOut(ps2);
ps2.print("内容输出到指定的文件log.txt中");
//PrintWriter：是一个字符打印流
PrintWriter pw = new PrintWriter("D:\\b.txt", "gbk");
pw.append("中国");
pw.close();
}
}
InputStreamReader：字节到字符的桥梁。
OutputStreamWriter：字符到字节的桥梁。
package file;
//转换流
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
public class Demo17 {
public static void main(String[] args) throws IOException {
// TODO Auto-generated method stub
File file = new File("D:\\a.txt");
File fileGBK = new File("D:\\gbk.txt");
File fileUTF = new File("D:\\utf.txt");
// 写入
testWriteFile(file);// 使用系统默认码表写入
testWriteFile(fileGBK, "gbk");// 使用gbk编码向gbk文件写入信息
testWriteFile(fileUTF, "utf-8");// 使用utf-8向utf-8文件中写入信息
// 读取
testReadFile(file);// 默认编码
testReadFile(fileGBK, "gbk");// 传入gbk编码文件,使用gbk解码
testReadFile(fileUTF, "utf-8");// 传入utf-8文件,使用utf-8解码
}
private static void testReadFile(File file, String encod) throws IOException {
// TODO Auto-generated method stub
FileInputStream fis = new FileInputStream(file);
InputStreamReader isr = new InputStreamReader(fis,encod);
int len = 0;
char[] cbuf = new char[1024];
while((len = isr.read(cbuf))!= -1){
System.out.println(new String(cbuf,0,len));
}
}
private static void testWriteFile(File file, String encod) throws IOException {
// TODO Auto-generated method stub
FileOutputStream fos = new FileOutputStream(file);
OutputStreamWriter fosw = new OutputStreamWriter(fos,encod);
fosw.write("指定格式编码");
fosw.close();
fos.close();
}
private static void testReadFile(File file) throws IOException {
// TODO Auto-generated method stub
FileInputStream fis = new FileInputStream(file);
InputStreamReader isr = new InputStreamReader(fis);
int len = 0;
char[] cbuf = new char[1024];
while((len = isr.read(cbuf))!= -1){
System.out.println(new String(cbuf,0,len));
}
}
private static void testWriteFile(File file) throws IOException {
// TODO Auto-generated method stub
FileOutputStream fos = new FileOutputStream(file);
OutputStreamWriter fosw = new OutputStreamWriter(fos);
fosw.write("默认编码");
fosw.close();
fos.close();
}
}
1711
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
