目标
java.io包简介
则必须显式地声明如下语句:
import java.io.*;
文件
文件可以认为是相关记录或存放在一起的数据的集合;
File类
File类的构造方法
构 造 方 法 | 说 明 |
File(String pathname) | 指定文件(或目录)名和路径创建文件对象 |
实例:
//在当前目录下创建一个与aaa.txt文件名相关联的文件对象
File f1 = new File("aaa.txt");
//指明详细的路径以及文件名,请注意双斜线
File f2 = new File("D:\\Java\\Hello.java");
File类中的常用方法
方 法 原 型 | 说 明 |
boolean exists() | 判断文件是否存在,存在返回true,否则返回false |
boolean isFile() | 判断是否为文件,是文件返回true,否则返回false |
boolean isDirectory() | 判断是否为目录,是目录返回true,否则返回false |
String getName() | 获得文件的名称 |
String getAbsolutePath() | 获得文件的绝对路径 |
long length() | 获得文件的长度(字节数) |
boolean createNewFile() throws IOException | 创建新文件,创建成功返回true,否则返回false,有可能抛出IOException异常,必须捕捉 |
boolean delete() | 删除文件,删除成功返回true,否则返回false |
File[] listFiles() | 返回文件夹内的子文件与子文件夹的数组 |
File类示例
public class FileDemo
{
public static void main(String[] args)
{
//创建一个文件对象,使之与一个文件关联
File file = new File("test.txt");
//显示与文件有关的属性信息
System.out.println("文件或目录是否存在:" + file.exists());
System.out.println("是文件吗:" + file.isFile());
System.out.println("是目录吗:" + file.isDirectory());
System.out.println("名称:" + file.getName());
System.out.println("绝对路径:" + file.getAbsolutePath());
System.out.println("文件大小:" + file.length());
}
}
关于如何创建目录和文件.
请大家自行参阅相关API:createNewFile() mkDir() mkDirs() isExists()
stream(流)
流的类型
对于字节流进行操作的类大部分继承于InputStream(输入字节流)类和OutputStream(输出字节流)类;
非常适合处理字符串和文本,对于字符流进行操作的类大部分继承于Reader(读取流)类和Writer(写入流)类
InputStream抽象类介绍
稍后带来
使用FileInputStream类读文件
FileInputStream类的构造方法
构 造 方 法 | 说 明 |
FileInputStream(File file) throws FileNotFoundException | 使用File对象创建文件输入流对象,如果文件打开失败,将抛出异常 |
FileInputStream(String name) throws FileNotFoundException | 使用文件名或路径创建文件输入流对象,如果文件打开失败,将抛出异常 |
FileInputStream类的常用方法
方 法 原 型 | 说 明 |
int read() throws IOException | 读取文件中的数据,一次读取一个字节,读取的数据作为返回值返回,如果读到文件末尾则返回-1,有可能抛异常,必须捕捉 |
int read(byte[] b) throws IOException | 读取文件中的数据,将读到的数据存放到byte型数组中,并返回读取的字节的数量,未读到数据返回-1,有可能抛异常,必须捕捉 |
void close() throws IOException | 关闭流对象,有可能抛异常,必须捕捉 |
FileInputStream对象读文件示例1:
public class FileInputStreamDemo1 {
public static void main(String[] args) {
try {
File file = new File("test.txt"); //创建文件对象
//使用文件对象创建文件输入流对象,相当于打开文件
FileInputStream fis = new FileInputStream(file);
for (int i = 0; i < file.length(); i++) {
char ch = (char)(fis.read()); //循环读取字符
System.out.print(ch);
}
System.out.println();
fis.close(); //关闭流
} catch (FileNotFoundException fnfe) {
System.out.println("文件打开失败。");
} catch (IOException ioe) {
ioe.printStackTrace();
}
}
}
FileInputStream对象读文件示例2:
public class FileInputStreamDemo2 {
public static void main(String[] args) {
try {
File file = new File("test.txt"); //创建文件对象
FileInputStream fis = new FileInputStream(file);
//根据文件的字节长度创建字节数组
byte[] buf = new byte[(int)(file.length())];
fis.read(buf); //读取文件中的数据存放到字节数组中
String str = new String(buf); //利用字节数组创建字符串
System.out.println(str); //打印字符串
fis.close(); //关闭流
} catch (FileNotFoundException fnfe) {
System.out.println("文件打开失败。");
} catch (IOException ioe) {
ioe.printStackTrace();
}
}
}
案例
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
/**
* 复制数据
*/
public class Test3 {
public static void main(String[] args) throws IOException {
File f=new File("r:\\io\\DSC_4539.JPG");
File of=new File("r:\\io\\b.JPG");
if(!of.exists()){
of.createNewFile();
}
if(f.exists()){
InputStream fis=new FileInputStream(f);
OutputStream fos=new FileOutputStream(of,true);
byte[] temp=new byte[1024];
int flag=-1;
while((flag=fis.read(temp))!=-1){
fos.write(temp);
}
fis.close();
fos.close();
}
}
}
OutputStream抽象类介绍
稍后带来
使用FileOutputStream类写文件
FileOutputStream类的构造方法
构 造 方 法 | 说 明 |
FileOutputStream(File file) throws FileNotFoundException | 使用File对象创建文件输出流对象,如果文件打开失败,将抛出异常 |
FileOutputStream(File file, boolean append) throws FileNotFoundException | 使用File对象创建文件输出流对象,并由参数append指定是否追加文件内容,true为追加,false为不追加,异常情况同上 |
FileOutputStream(String name) throws FileNotFoundException | 直接使用文件名或路径创建文件输出流对象,异常情况同上 |
FileOutputStream(String name, boolean append) throws FileNotFoundException | 直接使用文件名或路径创建文件输出流对象,并由参数append指定是否追加,异常情况同上 |
FileOutputStream类的常用方法
方 法 原 型 | 说 明 |
void write(int b) throws IOException | 往文件中写数据,一次写一个字节,有可能抛异常,必须捕捉 |
void write(byte[] b) throws IOException | 往文件中写数据,将byte数组中的数据全部写入到文件中,有可能抛异常,必须捕捉 |
void close() throws IOException | 关闭流对象,有可能抛异常,必须捕捉 |
FileOutputStream对象写文件示例1:
public class FileOutputStreamDemo1
{
//在函数内部不进行异常处理,将异常抛出函数外部
public static void main(String[] args) throws IOException
{
String str = "Hello world!";
File file = new File("test.txt"); //创建文件对象
//通过文件对象创建文件输出流对象
//附加第二个参数true,指定进行文件追加,默认为不追加
FileOutputStream fos = new FileOutputStream(file, true);
//逐个将字符写入到文件中
for (int i = 0; i < str.length(); i++)
{
fos.write(str.charAt(i));
}
fos.close(); //关闭流
}
}
FileOutputStream对象写文件示例2:
public class FileOutputStreamDemo2
{
//在函数内部不进行异常处理,将异常抛出函数外部
public static void main(String[] args) throws Exception
{
String str = "I Love Java";
//通过文件名创建文件输出流对象
FileOutputStream fos = new FileOutputStream("test.txt");
//将字符串转化为字节数组
byte[] buffer = str.getBytes();
//将字节数组中包含的数据一次性写入到文件中
fos.write(buffer);
//关闭流
fos.close();
}
}
FileInputStream/FileOutputStream小结
复制文件示例
public class CopyFileDemo {
public static void main(String[] args) throws IOException {
File srcFile = new File("src.dat"); //源文件对象
File destFile = new File("dest.dat"); //目标文件对象
if (!(destFile.exists())) { //判断目标文件是否存在
destFile.createNewFile(); //如果不存在则创建新文件
}
//使用源文件对象创建文件输入流对象
FileInputStream fis = new FileInputStream(srcFile);
//使用目标文件对象创建文件输出流对象
FileOutputStream fos = new FileOutputStream(destFile);
byte[] buf = new byte[1024]; //创建字节数组,作为临时缓冲
System.out.println("开始复制文件...");
while (fis.read(buf) != -1) { //循环从文件输入流中读取数据
fos.write(buf); //写入到文件输出流中
}
System.out.println("文件复制成功!");
fis.close(); //关闭流
fos.close();
}
}
字符流
FileReader类
以下是常用的几种:
构 造 方 法 | 说 明 |
FileReader(File file) throws FileNotFoundException | 使用File对象创建文件读取流对象,如果文件打开失败,将抛出异常 |
FileReader(String name) throws FileNotFoundException | 使用文件名或路径创建文件读取流对象,如果文件打开失败,将抛出异常 |
BufferedReader类
构 造 方 法 | 说 明 |
BufferedReader(Reader in) | 将字符读取流对象包装成缓冲读取流对象 |
方 法 原 型 | 说 明 |
String readLine() throws IOException | 从缓冲读取流中读取一行字符,以字符串的形式返回,有可能抛异常,必须捕捉 |
void close() throws IOException | 关闭流对象,有可能抛异常,必须捕捉 |
FileReader配合BufferedReader读文件示例
public class RraderDemo
{
public static void main(String[] args) throws IOException
{
File file = new File("test.txt");
//通过文件对象创建文件读取流对象
FileReader fr = new FileReader(file);
//将文件读取流包装成缓冲读取流
BufferedReader br = new BufferedReader(fr);
String str;
while ((str = br.readLine()) != null) //逐行读取数据
{
System.out.println(str);
}
br.close(); //关闭流
fr.close(); //关闭流
}
}
FileWriter类
以下是常用的几种:
构 造 方 法 | 说 明 |
FileWriter(File file) throws IOException | 使用File对象创建文件写入流对象,如果文件打开失败,将抛出异常,必须捕捉 |
FileWriter(File file, boolean append) throws IOException | 使用File对象创建文件写入流对象,并由参数append指定是否追加,异常情况同上 |
FileWriter(String name) throws IOException | 直接使用文件名或路径创建文件写入流对象,异常情况同上 |
FileWriter(String name, boolean append) throws IOException | 直接使用文件名或路径创建文件写入流对象,并由参数append指定是否追加,异常情况同上 |
BufferedWriter类
以下是常用的几种:
构 造 方 法 | 说 明 |
BufferedWriter(Writer out) | 将字符写入流对象包装成缓冲写入流对象 |
方 法 原 型 | 说 明 |
void write(String str) throws IOException | 将一行字符串写入到缓冲写入流中,有可能抛异常,必须捕捉 |
void newLine() throws IOException | 将一个回车换行符写入到文件中,从而达到换行的效果,有可能抛异常,必须捕捉 |
FileWriter配合BufferedWriter写文件示例
public class WriterDemo
{
public static void main(String[] args) throws IOException
{
File file = new File("test.txt");
//通过文件对象创建文件输出字符流对象
FileWriter fw = new FileWriter(file);
//将文件输出字符流包装成缓冲流
BufferedWriter bw = new BufferedWriter(fw);
bw.write("大家好!");
bw.write("我正在学习Java。");
bw.newLine(); //换个新行
bw.write("请多多指教。");
bw.newLine(); //换新行
bw.write("Luckybug@21cn.com");
bw.close(); //关闭流
fw.close(); //关闭流
}
}
案例:
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
public class Test11 {
public static void main(String[] args) throws IOException {
String s="abcd中国家@#$%"+System.getProperty("line.separator")+"asdfsdf顺右面";
Test11 t=new Test11();
t.writeFile(s);
t.readFile();
}
public void readFile() throws IOException{
File f=new File("r:\\io\\reader.doc");
FileReader fr=new FileReader(f);
BufferedReader br=new BufferedReader(fr);
String ss=null;
while((ss=br.readLine())!=null){
System.out.println(ss);
}
br.close();
fr.close();
}
public void writeFile(String s) throws IOException{
File f=new File("r:\\io\\reader.doc");
FileWriter fr=new FileWriter(f);
BufferedWriter br=new BufferedWriter(fr);
br.write(s);
br.close();
fr.close();
}
}
过渡流
从控制台接受输入
转换和包装System.in
构 造 方 法 | 说 明 |
InputStreamReader(InputStream in) | 将InputStream对象转换成Reader对象 |
InputStreamReader isr = new InputStreamReader(System.in);
BufferedReader br = new BufferedReader(isr);
从控制台接受输入示例
public class ConsoleInputDemo
{
public static void main(String[] args) throws IOException
{
//将System.in转化成字符流对象
InputStreamReader isr = new InputStreamReader(System.in);
//用缓冲流进行包装
BufferedReader br = new BufferedReader(isr);
System.out.println("请输入您的姓名:");
String name = br.readLine(); //接受输入
System.out.println("请输入您的年龄:");
int age = Integer.parseInt(br.readLine()); //接受输入
System.out.println("您的姓名:" + name);
System.out.println("您的年龄:" + age);
br.close(); //关闭流
isr.close(); //关闭流
}
}
从控制台输入并写入到文件示例
/*本例从控制台接受输入,然后写入到文件中,直到用户输入"!!!"为止*/
File file = new File("input.txt"); //创建文件对象
if (!file.exists()) //判断该文件是否存在,如果不存在则创建新文件
{
file.createNewFile();
}
FileWriter fr = new FileWriter(file); //针对文件对象创建文件写入流对象
BufferedWriter bw = new BufferedWriter(fr); //为文件写入流建立缓冲流
//将控制台输入对象转化成字符流,并建立缓冲流
BufferedReader bin = new BufferedReader(new InputStreamReader(System.in));
String str = bin.readLine(); //接受从控制台输入的一行字符串
while (!(str.equals("!!!"))) //如果输入"!!!"则代表输入结束
{
bw.write(str); //将从控制台输入的字符串写入到文件中
bw.newLine(); //换新行
str = bin.readLine(); //再从控制台接受输入
}
//关闭所有已经打开的流
bw.close();
fr.close();
bin.close();
基本数据类型的读/写
DataInputStream类和DataOutputStream类可以满足需要。
DataInputStream类
构 造 方 法 | 说 明 |
DataInputStream(InputStream in) | 利用其它的字节输入流创建数据输入流对象 |
示例:
//将文件输入流包装成数据输入流,以便从文件中读取各种类型的数据
FileInputStream fis = new FileInputStream("data.dat");
DataInputStream dis = new DataInputStream(fis);
DataInputStream类的常用方法
方 法 原 型 | 说 明 |
final boolean readBoolean() throws IOException | 从数据输入流中读取一个boolean型数据 |
final char readChar() throws IOException | 从数据输入流中读取一个char型数据 |
final int readInt() throws IOException | 从数据输入流中读取一个int型数据 |
final long readLong() throws IOException | 从数据输入流中读取一个long型数据 |
final float readFloat() throws IOException | 从数据输入流中读取一个float型数据 |
final double readDouble() throws IOException | 从数据输入流中读取一个double型数据 |
DataOutputStream类
构 造 方 法 | 说 明 |
DataOutputStream(OutputStream out) | 利用其它的字节输出流创建数据输出流对象 |
示例:
//将文件输出流包装成数据输出流,以便往文件中写入各种类型的数据
FileOutputStream fos = new FileOutputStream("data.dat");
DataOutputStream dos = new DataOutputStream(fos);
DataOutputStream类的常用方法
方 法 原 型 | 说 明 |
final void writeBoolean(boolean v) throws IOException | 往数据输出流中写入一个boolean型数据 |
final void writeChar(char v) throws IOException | 往数据输出流中写入一个char型数据 |
final void writeInt(int v) throws IOException | 往数据输出流中写入一个int型数据 |
final void writeLong(long v) throws IOException | 往数据输出流中写入一个long型数据 |
final void writeFloat(float v) throws IOException | 往数据输出流中写入一个float型数据 |
final void writeDouble(double v) throws IOException | 往数据输出流中写入一个double型数据 |
中间处理流
作用: 用来处理java的基本数据类型的.
注意点: 怎么写入数据的顺序,就怎么读出来.
示例:
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
public class Test8 {
public static void main(String[] args) throws Exception {
File f = new File("r:\\io\\dat.dat");
FileOutputStream fos = new FileOutputStream(f);
DataOutputStream dos = new DataOutputStream(fos);
dos.write(22);
dos.writeBoolean(true);
dos.writeChar('a');
dos.writeUTF("abc中国家####");
dos.close();
fos.close();
FileInputStream fis=new FileInputStream(f);
DataInputStream dis=new DataInputStream(fis);
System.out.println( dis.read());
System.out.println( dis.readBoolean());
}
}
作用:用来处理Object对象的流, 能将原来只能存在于VM中的对象存入到我们要求的存储介质中去了. 可以用来做数据缓存.
注意点:1. 处理的对象都必须实现Serializable接口. 2. transiant关键字来修饰无需序列化的属性
示例:
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
public class Test9 {
public static void main(String[] args) throws Exception {
File f = new File("r:\\io\\dat2.dat");
FileOutputStream fos = new FileOutputStream(f);
ObjectOutputStream dos = new ObjectOutputStream(fos);
Person p=new Person("zy",22);
dos.writeObject(p);
dos.close();
fos.close();
FileInputStream fis=new FileInputStream(f);
ObjectInputStream ois=new ObjectInputStream(fis);
Person ps=(Person)ois.readObject();
System.out.println(ps.getName()+"\t"+ps.getId());
}
}
class Person implements Serializable{
private String name;
private transient int id;
public Person() {
super();
}
public Person(String name, int id) {
super();
this.name = name;
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
}
使用场景:支持对随机访问文件的读取和写入.
特点: 1. 类中既有存的方法也有读的方法
2. 须指定访问文件模式
3. seek()和skip()
示例:操作日志import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.text.SimpleDateFormat;
import java.util.Date;
public class Test10 {
public static void main(String[] args) throws IOException {
BankAccount ba=new BankAccount(1000);
for(int i=0;i<10;i++){
ba.withDrawal(100);
}
}
}
class BankAccount{
private int money;
public BankAccount(int money){
this.money=money;
}
public void withDrawal(int money) throws IOException{
this.money=this.money-money;
log("您取了"+money+",账户余额:"+this.money);
}
private void log(String string) throws IOException {
File f=new File("r:\\io\\log.txt");
RandomAccessFile raf=new RandomAccessFile(f,"rwd");
SimpleDateFormat sdf=new SimpleDateFormat("yyyy年MM月dd日");
Date d=new Date();
String dd=sdf.format(d);
raf.seek(raf.length());
String s="\r\n"+dd+"\t"+string;
raf.write(s.getBytes("gbk"));
raf.close();
}
}
总结
补充
构 造 方 法 | 说 明 |
Properties() | 创建一个Properties对象 |
Properties类的常用方法
方 法 原 型 | 说 明 |
void load(Reader reader) | 通过字符流加载一个文件 |
void load(InputStream in) | 通过字节流加载一个文件 |
String getProperty(String key) | 通过键获得文件中对应的值 |
Object setProperty(String key,String value) | 存入一对键值对 |
void store(OutputStream out, String comments) | 以适合使用 load 方法加载到 Properties 表中的格式,将此 Properties 表中的属性列表(键和元素对)写入输出流。 |
案例:
提示: Properties类与流的结合使用
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Iterator;
import java.util.Properties;
import java.util.Set;
public class Test7 {
public static void main(String[] args) throws IOException {
OutputStream fos=new FileOutputStream("r:\\io\\p.properties");
Properties p=SystemInfoUtil1.getInfo();
p.store(fos, "");
InputStream fis=new FileInputStream("r:\\io\\p.properties");
Properties p2=new Properties();
p2.load(fis);
System.out.println(p2.toString());
}
}
class SystemInfoUtil1{
public static Properties getInfo(){
//解决记事本中换行符的问题
String lineSeparator=System.getProperty("line.separator");
StringBuffer result=new StringBuffer();
Properties p=System.getProperties();
return p;
}
}
扩展知识
publicFile[] listFiles(FilenameFilter filter): 返回此目录中满足指定过滤器的文件和目录。
扩展阅读
•密码学知识
http://download.csdn.net/detail/nisior/3981671
扩展案例
需求: 要求用户输入账号和金额。如果当前该账号不存在则创建。
将钱存入该账号,然后用户可以选择择继续或退出。
当程序再次运行时,银行数据被存储并重新加载.
作业
1.
2.
3.
•删除目录或文件,如果参数file代表目录,会删除当前目录及以下的所有内容