标准文件类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类可以使用指定的字符集将要写入流中的字符编码写成字节
扫一扫
2733
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
