标准文件类File
文件是记录在存储介质上的一组数据的集合。目录(即文件夹)是一组相关文件的集合;
Java.io包中的File类将存储介质上的文件和目录转换成程序代码中的对象;
File类的构造方法
创建File对象是将磁盘文件或者目录封装成程序中可以操作的对象;
public File(String pathname):通过给定路径名将对应的文件或者目录封装成一个新的File对象,形参pathname可以是相对路径,也可以是绝对路径;
File f1=new File("abc.txt");//相对路径,与当前应用程序在同一目录下
File f2=new File("D:/abc.txt");//绝对路径
File对象产生后没有在磁盘上创建该目录,需要使用mkdir()和mikdirs()方法创建磁盘目录,
mkdir()创建此路径名指定的目录,当且仅当已创建目录时返回true,否则返回false;
mkdirs()创建此指定的目录,包括创建必需但不存在的父目录,当且仅当已创建该目录以及所有必须的父目录时返回true,否则返回false;
publi File(File parent,String child):根据父路径和子路径名字符串创建一个File对象
File类的成员方法
1、exists():判断文件或目录是否存在;
2、isFile():判断File对象是否是文件;
3、isDirectory():判断File对象是否是目录;
4、getName():仅返回文件名,为文件路径信息被忽略;
5、getPath():返回整个路径名;
6、getAbsolutePath():返回绝对路径字符串;
7、length():返回文件长度;
8、delete():删除文件或目录,目录必须为空才能删除
package test05.file;
import java.io.File;
import java.util.Date;
public class FileDemo {
public static void main(String[] args) {
// TODO Auto-generated method stub
int dirNum=0,fileNum=0;
//定义目录数目初始值和文件数目初始值为零
File file=new File("D:/abc.txt");//创建一个文件(文件大多是以有类型的,和目录不一样,目录没有类型,相当于是建立了一个空文件夹)
if(!file.exists()) {//判断是否存在这个文件,不存在则创建一个
try {//用try-catch语句将没有创建的文件创建出来,并捕获
file.createNewFile();
}catch(Exception e) {
System.out.println("出异常");
}
}
System.out.println("文件是否存在:"+file.exists());
System.out.println("文件?"+file.isFile()+"\n"+"目录?"+file.isDirectory());
System.out.println("文件名:"+file.getName()+"\n"+"路径名:"+file.getPath()+"\n"+"绝对路径名字符串:"+file.getAbsolutePath()+"文件长度:"+file.length());
//定义一个文件,获取其路径为D盘
File directory=new File("D:/");
//由于D盘已经存在,所以没有创建指定的目录,因此,下面判断已创建该目录时返回false
System.out.println(directory.mkdirs());
File dir=new File("D:/myJava");
//将文件目录放到一个String数组中,用于存放文件下的文件
String str[]=dir.list();
//循环输出D盘myJava文件下的子文件名
for(int i=0;i<str.length;i++) {
System.out.println(str[i]);
}
System.out.println("-----------------");
//创建一个存放文件的数组
File[] fs=dir.listFiles();
//循环遍历文件数组,输出文件名称,
for(int i=0;i<fs.length;i++) {
//输出文件路径,创建的File数组,存放的是文件的路径
System.out.println(fs[i]);
//输出文件名称
System.out.println(fs[i].getName());
//输出文件的最后一次修改的时间
System.out.println(new Date(fs[i].lastModified())+"\t");
//判断是文件还是路径,如果是文件,文件++,如果是路径,路径++
if(fs[i].isDirectory()) {//是路径
dirNum++;
System.out.println("<DIR>\t");
}else {//是文件
fileNum++;
System.out.println(fs[i].length()+"\t");
}
}
System.out.println(dirNum);
System.out.println(fileNum);
file.delete();//最后将所建的空文件删除
}
}
在这个地方会很对人会把目录和路径搞混,觉得这两个不是差不多吗,其实不是,这两个差距还是很大的,对于目录通俗的了解就是文件夹,里面有文件的文件夹,可以是多个文件夹呈现包含关系,这就是目录;
而路径就是一个文件的路径,就好比是你建立了一个文件,是在很多的文件夹下面建立的这个文件,文件一般是有后缀名的那种,你要找到这个文件所经历的所有文件夹的总和就是路径【我个人的理解,有不对的地方请随时指正】
输入、输出流
输入流是程序获取外部设备的数据,输出流是程序中的设备输出到外部的设备上;
字节流和字符流:文件储存是字节的储存,因此字节流是最基本的流,读写二进制数据时需要使用字节流。但实际很多数据是文本,因此引入字符流。字符流处理2个字节的Unicode字符,操作对象是字符、字符数组或字符串。
字节流
字节输入流InputStream
字节输入流的抽象父类InputStream类,定义从输入流中读取字节数据到程序里的基本方法,子类有FileInputStream、BufferedInputStream、DataInputStream;
InputStream常用的成员方法:
1、read():从输入流的当前位置读取流的一个字节,返回读入的字节数据;如果已经读取到输入流的末端返回-1;
2、read(byte b[]):将输入流读到字节数组中,返回读入的字节数;
3、read(byte b[],int off,int len):从输入流中读取最多len个字节数据,并从字节数组b的第off个位置开始存放这些数据,返回读入的字节数;如果(off+len)大于b.length,或者off和len中有一个是负数,则会抛异常;
4、close():关闭输入流,释放资源,一般在结束都要关闭流;
5、available():返回流中尚未读取的字节数量;
6、flush():刷空流,把缓存中的所有字节强制输出到流中;
字节输出流OutputStream
字节输出流的抽象父类是OutputStream类,定义程序往文件中写数据的基本方法,子类有:FileOutputStream、BufferedOnputStream、DataOutputStream
OutputStream常用的成员方法:
1、write(int b):往输入流中写一个字节b;
2、write(byte b[]):往输入流中写一个字节数组;
3、close():关闭流;
FileInputStream可以读取磁盘文件的数据,FileOutputStream可以把程序中的数据写入磁盘中
文件字节流FileInputStream和FileOutputStream
FileInputStream
1、FileInputStream对象可以建立程序和文件之间的字节流传输通道,将文件中的数据读取到程序中:FileInputStream fi=new FileInputStream(pathname);//抛出异常
import java.io.*;
public class FileInputStreamDemo {
//用输入流读入D盘中的data文件到控制台上
public static void main(String[] args) throws Exception {
// TODO Auto-generated method stub
InputStream fi=null;//创建文件对象,栈内存中开辟空间
try {
fi=new FileInputStream("D:/date.txt");//给对象在堆内存中开辟空间
while(fi.available()>0) {//循环读取,条件是文件读取的字节是大于0的,
System.out.print((char)fi.read());//循环读取数据
}
}catch(Exception e) {//若有异常,打印异常信息
System.out.println(e.getMessage());
}finally {//最终处理
if(fi!=null) {//如果文件不是空文件
try {
fi.close();//关闭流
}catch(Exception e) {
e.printStackTrace();
}
fi=null;//即使close关不掉,也让垃圾回收器回收
}
}
}
}
//输入流输出流一般都是这个处理方法
FileOutputStream
2、FileOutputStream将程序中的数据读入文件中
FileOutputStream fo=new FileOutputStream(文件路径)
import java.io.*;
public class FileOutputStreamDemo {
//从一个文件读出数据读到另一个文件,思路是,先将前一个文件读入到程序中,后从程序中读到新建的文件中
public static void main(String[] args) throws Exception {
// TODO Auto-generated method stub
File file=new File("D:/data.txt");
InputStream is=new FileInputStream(file);
OutputStream os=new FileOutputStream(new File("D:/date1.txt"));
int num=0;
if(!file.exists()) {
System.out.println("源文件不存在");
}else {
while((num=is.read())!=-1) {//循环读入数据
os.write(num);
}
os.flush();//刷空输出流,把缓存中的所有字节强制输出到流中
is.close();
os.close();
}
}
}
字节缓冲BufferedInputStream和BufferedOutputStream
该类是实现字节缓冲功能的字节输入流和字节输出流,不允许直接生成新流,只是对现有的流提供缓冲功能,读写效率高。
BufferedInputStream
1、BufferedInputStream类是一个增加内部缓存的高级处理流,可以与其他的流配合使用,当一个简单的读请求产生后,数据并不马上写到所连接的输入流和文件中,而是写入高速缓存,当缓存读满后或关闭流后,随后读取请求直接从缓存中读取而不是从文件中读取。这样子可以减少磁盘I/O请求的次数,提高读取数据的效率;
2、BufferedInputStream类的成员变量字节数组buf是用于储存数据的内部缓冲区。读取数据源是,BufferedInputStream会尽量将buf填满,使用read()方法实际上是先读取buf中的数据,而不是直接读取数据源,当buf中数据不足时,再从指定的文件中读取数据。
创建BufferedInputStream对象一般是基于InputStream(若从文件读取数据则一般是FileInputStream);
import java.io.*;
public class BufferedInputStreamDemo {
public static void main(String[] args) throws Exception {
// TODO Auto-generated method stub
InputStream is=new FileInputStream("D:/date.txt");//引入文件
BufferedInputStream bis=null;//创建缓冲区域
bis=new BufferedInputStream(is);
int num;
while((num=bis.read())!=-1) {//循环读入
System.out.println((char)num);
}
bis.close();
is.close();
}
}
BufferedOutputStream
import java.io.*;
public class BufferedOuputStreamDemo {
public static void main(String[] args) throws Exception {
// TODO Auto-generated method stub
InputStream is=new FileInputStream("D:/date.txt");//引入要复制的文件,将其写入程序中
BufferedInputStream bis=new BufferedInputStream(is);//将文件放到缓冲区
OutputStream os=new FileOutputStream("D:/1.txt");//建立将要写出的文件
BufferedOutputStream bos=new BufferedOutputStream(os);//将复制文件写入缓冲区
int num=0;
while((num=bis.read())!=-1) {//循环读取要复制的文件
bos.write(num);//读取复制文件中的内容
}
//刷空流,将缓存区的字节全部输出到流中
bos.flush();
//关闭流
bos.close();
is.close();
bis.close();
os.close();
System.out.println("复制完成");
}
}
基本数据类型操作流DataInputStream类和DataOutputStream类
DataOutputStream类
1、DataOuputStream类是用于Java基本数据类型数据写入底层输出流的对象;
2、方法:public final void writeBoolean(boolean v):将boolean型数据写入输出流对象;
public final void writeInt(int a):将char类型数据写入输出流对象,在java中char和int可以相互转换;
public final void writeInt(int a):将int型数据写入输出流对象;//以此类推其他类型
public final void write(byte[] b,int off,int len):将字节数组从off开始读入len个字节
DataOutputStream类
方法:public final int read(byte[] b):从输入流对象中读取字节数据存储到字节数组b中;
public final int readInt():从输入流中读取int型数据;
import java.io.*;
public class DataInputStreamDemo {
public static void main(String[] args) throws Exception {
// TODO Auto-generated method stub
File f=new File("D:/order.txt");//获取这个文件
DataInputStream dis=new DataInputStream(new FileInputStream(f));//读取文件中的内容到控制台上
String name=null;
int number=0;
float price=0;
char temp[]=null;
int length=0;
char c=0;
try {
while(true) {//无限循环读入到文件中数据
temp=new char[1024];
length=0;
while((c=dis.readChar())!='\t') {//读取文件中的字符串,将其赋值给字符类型的num上
temp[length]=c;//length表示下标,用来依次获取对应位置的字符
length++;
}
name=new String(temp,0,length);//将temp中的字符转换为字符串赋值给name,获得名字
price=dis.readFloat();
dis.readChar();//即读取制表符
number=dis.readInt();
dis.readChar();
System.out.println("名称:"+name+"价格:"+price+"数量"+number);
}
}catch(EOFException e) {
System.out.println("\n读取结束");
}catch(Exception e) {
System.out.println("\nerror"+e.getMessage());
}
if(dis!=null) dis.close();
}
}
对象操作流ObjectInputStream和ObjectOutputStream
ObjectOutputStream类
如果在文件中直接存储对象,需要该对象所属的类实现java.io.Serializable接口,从而变成可序列化的类。ObjectOutputStream类可以将已经序列化的对象写入文件,实现对象的持久存储。
ObjectInputStream类
ObjectInputStream读取ObjectOutputStream对象写入基本类型数据和对象;
字符流
字符输入流Reader类
构造方法:1、read():从输入流读取一个字符/数组;
2、ready():判断是否做好流读取准备;
3、skip(long n):跳过输入流中的n个字符,返回实际跳过的字符;
字符输出流Writer类
构造方法:1、write():将整型值写入程序中;
2、append():将字符追加到输出流对象;
FileReader类
import java.io.FileNotFoundException;
import java.io.FileReader;
public class FileReaderDemo {
public static void main(String[] args) throws Exception {
// TODO Auto-generated method stub
FileReader fr=null;
fr=new FileReader("D:/poem.txt");
char[] cbuf=new char[1024];//创建放置从输入流中读入数据的字符数组
int hasRead=0;
while((hasRead=fr.read(cbuf))>0) {
//将字符数组转化为字符串输出
System.out.println(new String(cbuf,0,hasRead));
}
fr.close();
}
}
FileWriter类
import java.io.FileWriter;
import java.io.IOException;
public class FileWriterDemo {
public static void main(String[] args) throws Exception {
// TODO Auto-generated method stub
FileWriter fw=null;
fw=new FileWriter("D:/vocabulary.txt");
fw.write("hello world\r\n");
fw.write("hello world\r\n");
fw.write("hello world\r\n");
fw.write("hello world\r\n");
fw.close();
}
}
BufferedReader类
方法:readLine():该方法读取一行文本。 '\n'换行,'\r'回车,'\r''\n',返回包含行内容的字符串,并不包含任何终止符,当已读到流的末尾时返回空。
package test05.file;
import java.io.*;
public class BufferedReaderDemo {
//从键盘中对入数据并在控制台上显示
public static void readLineFromFile() throws Exception {
File file=new File("D:/data.txt");//给定文件
if(!file.exists()) {
System.out.println("文件不存在");
return;
}
BufferedReader br=new BufferedReader(new FileReader(file));//从文件中读取字符
String str=null;
while((str=br.readLine())!=null) {
System.out.println(str);
}
br.close();
}
public static void readFromKeyBoard() throws Exception {
//从键盘读入数据
//InputStreamReader流对象读取字节并将其转换为字节
BufferedReader bfreader=new BufferedReader(new InputStreamReader(System.in));
String s=null;
do {
System.out.println("please write:(type\"exit\"to exit the program)");
s=bfreader.readLine();
System.out.println(s);
}while(!s.equals("exit"));
System.out.println("program terminated normally by typing\"exit\".");
}
public static void main(String[] args) throws Exception {
// TODO Auto-generated method stub
System.out.println("测试从文件中读取的字符");
readLineFromFile();
System.out.println("测试从键盘读取数据");
readFromKeyBoard();
}
}
BufferedWriter类
方法:newLine():添加换行符,即写入行分隔符;
InputStreamReader类
读取字节数据并将其转换为指定字符编码的字符,调用read()方法,从字节输入流中读取一个或多个字节
InputStreamReaer通常和BufferedReader封装到一起
InputStreamReader stdin=new InputStreamReader(System.in); BufferedReader bufin=new BufferedReader(stdin);//或者
BufferedReader bufin=new BufferedReader(InputStreamReader(System.in));
OutputStreamWriter类
OutputStreamWriter类可以使用指定的字符集将要写入流中的字符编码写成字节