1.1引言
IO流用来处理设备之间的数据传输
java对数据的操作是通过流的方式
java 用于操作流的对象都在IO包中
流按操作数据分为两种，字节流与字符流，
流按流向分为：输入流， 输出流
将外设中的数据读取到内存中：输入。
将内存的数写入到外设中：输出。
1.2 IO流常用基类
字节流的抽象基类：InputStream，OutputStream。
字符流的抽象基类：Reader，Writer。
由这四个类派生出来的子类名称都是以其父类名作为子类名的后缀。
如：InputStream的子类FileInputStream。
如：Reader的子类FileReader。
字符流的抽象基类：Reader，Writer。
由这四个类派生出来的子类名称都是以其父类名作为子类名的后缀。
如：InputStream的子类FileInputStream。
如：Reader的子类FileReader。
1.3 例子：
import java.io.FileWriter;
import java.io.IOException;
public class FiledWriterDemo {
public static void main(String[] args) {
//创建一个可以往文件中定稿字符数据的字符输出流对象
//在创建对象的时候，必须明确文件，
//如果不存在，则会自动创建，如果文件存在，则会被覆盖
try
{
FileWriter file = new FileWriter("E:\\myjava\\2015-6-12\\filedemos.txt");
//调用writer对象中的write方法，写入数据，这个数据写入到的是缓冲区中
file.write("is my like writer");
//需要进行刷新，将数据直接写入到目的地中
file.flush();
//关闭流
file.close();
System.out.println("文件创建");
} catch (IOException e)
{
e.printStackTrace();
}
}
}运行程序：
注意：close方法只可以调用一次，
如果在构造函数中输入true，那么可以实现文件的续写
import java.io.FileWriter;
import java.io.IOException;
public class FiledWriterDemo {
public static void main(String[] args) {
try
{
FileWriter file = new FileWriter("E:\\myjava\\2015-6-12\\filedemos.txte26quot;，true);
file.write("is my like writer");
file.flush();
file.close();
System.out.println("文件创建");
} catch (IOException e)
{
e.printStackTrace();
}
}
}
1.4 IO流的异常处理方式：
为防止代码异常导致流无法关闭，因此在finally中对流进行关闭。
import java.io.FileWriter;
public class FiledWriterDemo1 {
public static void main(String[] args) {
FileWriter file = null;
try
{
file = new FileWriter("E:\\myjava\\2015-6-12\\filedemos.txt",true);
file.write("go to write");
file.flush();
}
catch(Exception e)
{
System.out.println(e.toString());
}
finally
{
try
{
file.close();
}
catch(Exception e)
{
System.out.println(e.toString());
}
}
}
}1.5读取一个文件的内容，并输出到控制台上
1.5.1 第一种方式
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
public class FileReadDemo {
public static void main(String[] args)
{
// 读取一个文件并输出到控制台上
FileReader fil = null;
try {
fil = new FileReader("E:\\myjava\\2015-6-12\\filedemos.txt");
//使用read方法来读取
int ch = 0;
try {
while((ch=fil.read())!=-1)
{
System.out.println((char)ch);
}
}
catch (IOException e)
{
e.printStackTrace();
}
}
catch (FileNotFoundException e)
{
e.printStackTrace();
}
finally
{
try
{
fil.close();
} catch (IOException e)
{
e.printStackTrace();
}
}
}
}
1.5.2第二种方式
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
public class FiledReadDemoChar
{
public static void main(String[] args)
{
// 使用数组的方式来读取文件的内容
FileReader file = null;
try
{
file = new FileReader("E:\\myjava\\2015-6-12\\filedemos.txt");
//定义一个数组
}
catch (FileNotFoundException e)
{
e.printStackTrace();
}
char[] c = new char[1024];
int len = 0;
try
{
while((len=file.read(c))!=-1)
{
System.out.println(new String(c,0,len));
}
}
catch (IOException e)
{
e.printStackTrace();
}
}
}
1.6复制一个文件到相关目录下
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
public class FileCopyDemo
{
public static void main(String[] args)
{
FileReader readfil =null;
FileWriter wrietfil = null;
try {
// 读取一个文件内容
readfil = new FileReader("E:\\myjava\\2015-6-12\\filedemos.txt");
//创建一个复制文件的目的地
wrietfil = new FileWriter("E:\\myjava\\2015-6-12\\filedemosCopy.txt");
char[] c = new char[1024];
int len=0;
while((len=readfil.read(c))!=-1)
{
wrietfil.write(c);
}
} catch (Exception e) {
//`TODO Auto-generated catch block
e.printStackTrace();
}
finally
{
try {
readfil.close();
} catch (IOException e) {
e.printStackTrace();
}
try {
wrietfil.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}2 字符流的缓冲区 缓冲区的出现提高了对数据的读写效率。
对应类：
BufferedWriter
BufferedReader
缓冲区要结合流才可以使用。
在流的基础上对流的功能进行了增强。
2.1使用流来复制一个文件到指定的目录下
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
public class FileBufferDemo {
public static void main(String[] args)
{
//为了提高效率，引入流
FileReader readfil =null;
BufferedReader bufr = null ;
FileWriter wrietfil = null;
BufferedWriter bufw = null;
try {
// 读取一个文件内容
readfil = new FileReader("E:\\myjava\\2015-6-12\\filedemos.txt");
//将读取的数据定写入到流中
bufr = new BufferedReader(readfil);
//创建一个复制文件的目的地
wrietfil = new FileWriter("E:\\myjava\\2015-6-12\\filedemosCopy.txt");
bufw = new BufferedWriter(wrietfil);
char[] c = new char[1024];
int len=0;
while((len=readfil.read(c))!=-1)
{
wrietfil.write(c);
}
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
finally
{
try {
bufr.close();
} catch (IOException e) {
e.printStackTrace();
}
try {
bufw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
2.2缓冲区中的newLine
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
public class FileBufferNewLineDemo {
public static void main(String[] args) {
//为了提高效率，引入流
FileReader readfil =null;
BufferedReader bufr = null ;
FileWriter wrietfil = null;
BufferedWriter bufw = null;
try {
// 读取一个文件内容
readfil = new FileReader("E:\\myjava\\2015-6-12\\MyBufferwriter .java");
//将读取的数据定写入到流中
bufr = new BufferedReader(readfil);
//创建一个复制文件的目的地
wrietfil = new FileWriter("E:\\myjava\\2015-6-12\\filedemosCopy1.txt");
bufw = new BufferedWriter(wrietfil);
String len = null;
while((len=bufr.readLine())!=null)
{
bufw.write(len);
//调用readLine方法换行
bufw.newLine();
bufw.flush();
}
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
finally
{
try {
bufr.close();
} catch (IOException e) {
e.printStackTrace();
}
try {
bufw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
2.3 LineNumberReader
跟踪行号的缓冲字符输入流。此类定义了方法 setLineNumber(int) 和 getLineNumber()，它们可分别用于设置和获取当前行号。import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.LineNumberReader;
public class FileLineNumberDemo {
public static void main(String[] args) {
FileReader readfil =null;
LineNumberReader bufr = null ;
FileWriter wrietfil = null;
BufferedWriter bufw = null;
try {
// 读取一个文件内容
readfil = new FileReader("E:\\myjava\\2015-6-12\\MyBufferwriter .java");
//将读取的数据定写入到流中
bufr = new LineNumberReader(readfil);
//创建一个复制文件的目的地
wrietfil = new FileWriter("E:\\myjava\\2015-6-12\\filedemosCopy22.txt");
bufw = new BufferedWriter(wrietfil);
String len = null;
bufr.setLineNumber(10);
while((len=bufr.readLine())!=null)
{
wrietfil.write(bufr.getLineNumber()+" "+len);
bufw.newLine();
bufw.flush();
}
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
finally
{
try {
bufr.close();
} catch (IOException e) {
e.printStackTrace();
}
try {
bufw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
对原有的类进行了功能的改变，增强。
class Persons
{
void chifan()
{
System.out.println("persons吃饭");
}
}
//采用装饰的方式增强Persons 类%tAclass NewPersons
{
private Persons p;
NewPersons(Persons p)
{
this.p=p;
}
public void chifan()
{
System.out.println("new persons chiran");
p.chifan();
System.out.println("new persons drunk");
}
}
//采用继承的方式增强Persons类
class NewPersons2 extends Persons
{
public0void chifan()
{
System.out.println("new persons2 eat");
super.chifan();
System.out.println("new persons2 drunk");
}
}
//建立测试类
public class Person {
public static void main(String[] args) {
//
Persons p = new Persons();
NewPersons newp = new NewPersons(p);
newp.chifan();
System.out.println("\\\\\\\\\\\\\\\\\\\\\\\\"); NewPersons2 p2 = new NewPersons2();
p2.chifan();
}
}
装饰设计模式与继承都可以实现功能的扩展
区别：装饰比继承灵活。
特点：装饰类和被装饰类都必须所属同一个接口或者父类。
4 IO流 --- 字节流
特点：装饰类和被装饰类都必须所属同一个接口或者父类。
与字符流的操作方式一至，只不过是它不仅可以操作字符，还可以操作其他媒体文件
4.1使用字节流读取一个文件内容，到控制台上输出
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
public class OutputStreamDemo {
public static void main(String[] args) {
// 使用字节流读取一个文件输出到控制台上
//创建一个读取流对象
FileInputStream file=null;
try {
//初始化读取流对象
file = new FileInputStream("E:\\myjava\\2015-6-12\\filedemosCopy.txt");
byte[] c = new byte[1024];
int len = 0;
try {
while((len=file.read(c))!=-1)
{
System.out.println(new String(c,0,len));
}
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStacktrace();
}<pre name="code" class="java"> finally
{
try {
file.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
} }
}
4.2使用字节流复制一个文本文档到指定目录下
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class OutputStreamCopyDemo {
public static void main(String[] args) {
// 使用字节流复制一个文件到指定目录下
//读取一个文本文件
FileInputStream fis=null;
//建立写入文本的路径
FileOutputStream fos = null;
try {
fis = new FileInputStream("E:\\myjava\\2015-6-12\\filedemosCopy.txt");
fos = new FileOutputStream("E:\\myjava\\2015-6-12\\FileStreamCopy.txt");
byte[] b = new byte[1024];
int len = 0;
try {
while((len=fis.read(b))!=-1)
{
fos.write(b);
}
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
4.3 使用字节流结合缓冲区复制一个文本文档到指定目录下
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundExweption;
import java.io.FileOutputStream;
import java.io.IOException;
public class CopyBufferStreamDemo {
public static void main(String[] args) {
// 加入缓冲技术
// 使用字节流复制一个文�%g6到指定目录下
//读取一个文本文件
FileInputStream fis=null;
BufferedInputStream bis = null;
//建立写入文本的路径
FileOutputStream fos = null;
BufferedOutputStream bos = null;
try {
fis = new FileInputStream("E:\\myjava\\2015-6-12\\filedemosCopy.txt");
bis = new BufferedInputStream(fis);
fos = new FileOutputStream("E:\\myjava\\2015-6-12\\FileStreamCopy.txt");
bos = new BufferedOutputStream(fos);
byte[] b = new byte[1024];
int len = 0;
try {
while((len=bis.read(b))!=-1)
{
bos.write(b);
bos.flush();
}
} catch (IOException e)
{
e.printStackTrace();
}
} catch (FileNotFoundException e)
{
// TODO Auto-generated catch block
e.printStackTrace();
}
finally
{
try {
bis.close();
} catch (IOException e) {
e.printStackTrace();
}
try {
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
4.4 使用字节流复制一个图片到指定目录下
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class CopyPicuterDeno {
public static void main(String[] args) {
FileInputStream fis=null;
BufferedInputStream bis = null;
//建立写入文本的路径
FileOutputStream fos = null;
BufferedOutputStream bos = null;
try {
fis = new FileInputStream("E:\\我的图片\\体育风采\\000.jpg");
bis = new BufferedInputStream(fis);
fos = new FileOutputStream("E:\\myjava\\2015-6-12\\FileStreamCopy.jpg");
bos = new BufferedOutputStream(fos);
byte[] b = new byte[1024];
int len = 0;
try {
while((len=bis.read(b))!=-1)
{
bos.write(b);
bos.flush();
}
}
catch (IOException e)
{
e.printStackTrace();
}
}
catch (FileNotFoundException e)
{
// TODO Auto-generated catch block
e.printStackTrace();
}
finally
{
try
{
bis.close();
}
%0= catch (IOException e)
{
e.printStackTrace();
}
try
{
fos.close();
}
catch (IOException e)
{
e.printStackTrace();
}
}
}
}
4.5读取键盘输入数据，并输出在控制台上
Import java.io.*;
public class KeyReadDemo
{
public static void main(String[] args)
{
InputStream in = System.in;
try {
int s = in.read();
System.out.println((char)s);
int s1 = in.read();
System.out.println(s1);
int s2 = in.read();
System.out.println(s2);
int s3 = in.read();
System.out.println(s3);
} catch (IOException e)
{
e.printStackTrace();
}
finally
{
try
{
in.close();
} catch (IOException e)
{
e.printStackTrace();
}
}
}
}4.6将用户输入的数据转换成大写，并输出在控制台上
获取用户键盘录入的数据并将数据变成大写显示在控制台上，如果用户输入的是over，结束键盘录入
import java.io.*;
public class KeyReadDemo
{
public static void main(String[] args)
{
//获取键盘输入数据
InputStream in = System.in;
//创建一个储存数据的容器
StringBuilder sbd = new StringBuilder();
int ch = 0;
try {
while((ch=in.read())!=-1)
{
if(ch=='\r')
continue;
if(ch=='\n')
{
String s = sbd.toString();
if("over".equals(s))
break;
System.out.println(s.toUpperCase());
sbd.delete(0, sbd.length());
}
else
{
sbd.append((char)ch);
}
}
} catch (IOException e) {
e.printStackTrace();
}
finally
{
try {
in.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
public static void med1()
{
InputStream in = System.in;
try {
int s = in.read();
System.out.println((char)s);
int s1 = in.read();
System.out.println(s1);
int s2 = in.read();
System.out.println(s2);
int s3 = in.read();
System.out.println(s3);
} catch (IOException e)
{
e.printStackTrace();
}
finally
{
try
{
in.close();
} catch (IOException e)
{
e.printStackTrace();
}
}
}
}
4.7 转换流
%3G <1>字符流与字节流之间的桥梁
<2>方便了字符流与字节流之间的操作
<3>字节流中的数据都是字符时，转成字符流操作更高效
<4>
InputStreamReader：字节到字符的桥梁，解码。
OutputStreamWriter：字符到字节的桥梁，编码。
InputStreamReader是字节流通向字符流的桥梁。
import java.io.*;
public class StreamReader {
public static void main(String[] args)
{
BufferedReader brd =
new BufferedReader(new InputStreamReader(System.in));
String s = null;
try {
while((s=brd.readLine())!=null)
{
System.out.println(s.toUpperCase());
if("over".equals(s))
break;
}
} catch (IOException e) {
e.printStackTrace();
}
}
}import java.io.*;
public class StreamReader {
public static void main(String[] args)
{
BufferedReader brd =
new BufferedReader(new InputStreamReader(System.in));
BufferedWriter bdw =
new BufferedWriter(new OutputStreamWriter(System.out));
String len = null;
try {
while((len=brd.readLine())!=null)
{
bdw.write(len.toUpperCase());
bdw.newLine();
bdw.flush();
}
}
catch (IOException e)
{
e.printStackTrace();
}
finally
{
try {
brd.close();
} catch (IOException e) {
e.printStackTrace();
}
try {
bdw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}4.7.1 将键盘录入的数据写入到一个文件中去
将键盘录入的数据写入到一个文件中去
import java.io.*;
public class StreamReader {
public static void main(String[] args)
{
System.out.print("程序启动");
BufferedReader brd =
new BufferedReader(new InputStreamReader(System.in));
try {
BufferedWriter bfw=
new BufferedWriter(new OutputStreamWriter(new FileOutputStream("E:\\myjava\\2015-6-12\\OutputStreamWriter.txt")));
String len = null;
while((len=brd.readLine())!=null)
{
bfw.write(len);
bfw.newLine();
bfw.flush();
}
} catch (Exception e)
{
e.printStackTrace();
}
finally
{
try {
brd.close();
} catch (IOException e) {
e.printStackTrace();
}
}
4.7.2 将一个文本内容显示在控制台上
将一个文本内容显示在控制台上
import java.io.*;
public class StreamReader {
public static void main(String[] args)
{
System.out.print("程序启动");
BufferedReader brd= null;
BufferedWriter bfw = null;
try {
brd = new BufferedReader(new InputStreamReader(new FileInputStream("E:\\myjava\\2015-6-12\\MyBufferwriter .java")));
bfw = new BufferedWriter(new OutputStreamWriter(System.out));
String len =null;
while((len=brd.readLine())!=null)
{
bfw.write(len);
bfw.newLine();
bfw.flush();
}
} catch (Exception e)
{
e.printStackTrace();
}
finally
{
try
{
brd.close();
} catch (IOException e)
{
e.printStackTrace();
}
try {
bfw.close();
} catch (IOException e)
{
e.printStackTrace();
}
}
}4.7.3将一个文件中的内容复制到另一个文件中去
把一个文件中的内容复制到另一个文件中去
import java.io.*;
public class StreamReader {
public static void main(String[] args)
{
System.out.print("程序启动");
BufferedReader brd= null;
BufferedWriter bfw = null;
try {
brd = new BufferedReader(new InputStreamReader(new FileInputStream("E:\\myjava\\2015-6-12\\MyBufferwriter .java")));
bfw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("E:\\myjava\\2015-6-12\\MyBufferwriterCopy .java")));
String len =null;
while((len=brd.readLine())!=null)
{
bfw.write(len);
bfw.newLine();
bfw.flush();
}
} catch (Exception e)
{
e.printStackTrace();
}
finally
{
try
{
brd.close();
} catch (IOException e)
{
e.printStackTrace();
}
try {
bfw.close();
} catch (IOException e)
{
e.printStackTrace();
}
}
FileWriter是用来写入字符文件的便捷类，此类的构造方法假定默认字符编码和默认字节缓冲区大小都是可接受的。
任何Java识别的字符数据使用的都是Unicode码表，但是FileWriter写入本地文件使用的是本地编码，也就是GBK码表。
而OutputStreamWriter可使用指定的编码将要写入流中的字符编码成字节。
import java.io.FileWriter;
import java.io.IOException;
public class FileWriterDemo {
public static void main(String[] args) {
FileWriter f = null;
try {
f = new FileWriter("E:\\myjava\\2015-6-12\\FileWriter.txt");
f.write("helles ");
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
finally
{
try
{
f.close();
} catch (IOException e)
{
e.printStackTrace();
}
}
}
}
6 File类 File类用来将文件或者文件夹封装成对象，方便对文件与文件夹的属性信息进行操作。
File对象可以作为参数传递给流的构造函数。
import java.io.File;
public class FileDemos {
public static void main(String[] args) {
// TODO Auto-generated method stub
//可以将一个已存在的，或者不存在的文件或者目录封装成file对象
//方式一
File f1 = new File("E:\\myjava\\2015-6-12\\44.txt" );
//方式二
File f2 = new File("E:\\myjava\\2015-6-12\\" ,"44.txt" );
//方式三
File fs = new File("E:\\myjava\\2015-6-12\\" );
File f3 = new File(fs,"44.txt" );
//考虑到Windows和Linux系统通用
File f4 = new File("d:" + File.separator + "demo" + File.separator + "a.txt" );
}
}
6.1 File对象的常用方法：
6.1. 1、获取
获取文件名称获取文件路径
获取文件大小
获取文件修改时间
import java.io.File;
public class FileDemos {
public static void main(String[] args) {
// TODO Auto-generated method stub
File f1= new File("file.txt");
File f2 = new File("E:\g5Cmyjava\\2015-6-12\\44.txt" );
String getNames = f1.getName();
String getPaths1 = f1.getPath();
String getPaths2 = f2.getPath();
String getPaths3 = f1.getAbsolutePath();
String getPaths4 = f2.getAbsolutePath();
//如果此目录没有指定父目录，则返回null
String getPaths5 = f1.getParent();
sop(getPaths1);
sop(getPaths2);
sop(getPaths3);
sop(getPaths4);
sop(getPaths5);
sop(getNames);
}
public static void sop(Object obj)
{
System.out.println(obj);
}6.1.2创建和删除功能
import java.io.File;
import java.io.IOException;
public class FileDemos {
public static void main(String[] args) {
File f2 = new File("E:\\myjava\\2015-6-12\\filesDemos.txt" );
//调用方法创建该文件
try {
//如果文件存在了，则不创建，不会覆盖原有的文件
boolean b = f2.createNewFile();
if(b == true)
System.out.println("文件创建成功");
if(b ==false)
System.out.println("文件未创建成功");
//调用方法删除该文件
boolean b1 = f2.delete();
if(b1 == true)
System.out.println("文件删除成功");
if(b1 ==false)
System.out.println("文件未删除成功");
//调用方法创建多级目录
File f3 = new File("E:\\myjava\\2015-6-12\\aa\\bb\\cc");
boolean b2 = f3.mkdirs();
if(b1 == true)
System.out.println("文件夹创建成功");
if(b1 ==false)
System.out.println("文件夹未创建成功");
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}6.1.3判断功能
import java.io.File;
import java.io.IOException;
public class FileDemos {
public static void main(String[] args) {
File f2 = new File("E:\\myjava\\2015-6-12\\filesDemos.txt" );
//�'A4断文件是否存在，如果不存在则创建一个
if(!f2.exists())
{
try {
f2.createNewFile();
System.out.println("文件创建");
} catch (IOException e) {
e.printStackTrace();
}
}
}6.1.4 系统根目录的获取
import java.io.File;
import java.io.IOException;
public class FileDemos {
public static void main(String[] args) {
File[] f = File.listRoots();
for(File fi:f)
{
System.out.println(fi);
}
}6.1.5获取指定目录下的子文件
import java.io.File;
import java.io.IOException;
public class FileDemos {
public static void main(String[] args)
{
File f = new File("E:\\");
File[] fi = f.listFiles();
for(File fis:fi)
{
System.out.println(fis);
}
String[] s = f.list();
for(String t:s)
{
System.out.println(t);
}
}
就是函数自身调用自身，这种表现形式。
限定条件：
《1》要注意递归的次数，尽量避免内存的溢出
private static void med11() {
File f = new File("E:\\");
show(f);
}
public static void show(File dir)
{
int count = 0;
System.out.println(dir);
File[] files = dir.listFiles();
for(int i = 0;i<files.length;i++)
{
if(files[i].isDirectory())
{
show(files[i]);
}
else
{
System.out.println(" "+files[i]);
}
}
}
《2》删除一个带内容的目录
删除原理： 在window中，删除目录从里面往外删除，需要使用到递归
例如除下面的文件夹与内容
import java.io.File;
import java.io.FilenameFilter;
public class FileDemos
{
public static void main(String[] args)throws Exception
{
med13();
}
}
private static void med13()
{
// TODO Auto-generated method stub
File f = new File("E:\\下载文档 - 副本");
med12(f);
}
private static void med12(File dir)
{
// TODO Auto-generated method stub
File[] files = dir.listFiles();
for(int x =0;x<files.length;x++)
{
if(files[x].isDirectory())
{
med12(files[x]);
}
else
{
System.out.println(files[x].toString()+" "+files[x].delete());
}
}
System.out.println(dir + " "+dir.delete());
}
下图是显示删除过程中的步骤：
练习：将一个指定目录下的java文件的绝对路径，存储到一个文本文件中去
建立一个java文件列表文件
写作思路：
《1》 对指定的目录进行递归
《2》 获取递归过程中所有的java文件的路径
《3》 将这些路径存储到集合中去
《4》 将集合中的数据写入到一个文件中去
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.FilenameFilter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
public class FileDemos
{
public static void main(String[] args)throws Exception
{
med14();
}
//创建一个读取文件目录的对象
private static void med14() throws IOException {
File dir = new File("E:\\myjava");
//新建一个储存路径的集合
List<File> list = new ArrayList<File>();
//调用自定义方法将读取的目录路径数据存储
fileToList(dir,list);
System.out.println(list.size());
//调用自定义方法，将目录路径数据存储在指定的文本文档中
writeToFile(list);
}
//自定义方法将读取的目录路径数据存储
public static void writeToFile(List<File> list) throws IOException
{
BufferedWriter bfw =
new BufferedWriter(new FileWriter("E:\\javalistbos.txt"));
for(File f:list)
{
String path = f.getAbsolutePath();
bfw.write(path);
bfw.newLine();
bfw.flush();
% }
bfw.close();
}
//自定义方法，将目录路径数据存储在指定的文本文档中
public static void fileToList(File dir,List<File> list)
{
File[] files = dir.listFiles();
for(File f:files)
{
if(f.isDirectory())
{
fileToList(f,list);
}
else
{
if(f.getName().endsWith(".java"))
list.add(f);
}
}
} Map
|--Hashtable
|--Properties
特点：
1. 该集合中的键和值都是字符串类型。
2. 集合中的数据可以保存到流中，或者从流中获取。
3. 通常该集合用于操作以键值对形式存在的配置文件。
8.1 Properties集合的存和取。
import java.util.Properties;
import java.util.Set;
public class ProperterDemos {
public static void main(String[] args) {
// 创建一个properties集合
Properties p = new Properties();
//存储元素
p.setProperty("wo", "22");
p.setProperty("is", "24");
p.setProperty("am", "11");
p.setProperty("you", "00");
//修改元素
p.setProperty("you", "10");
Set<String> name = p.stringPropertyNames();
for(String s:name)
{
String ss = p.getProperty(s);
System.out.println(s+" +"+ss);
}
}
}
8.2演示Properties集合和流对象相结合的功能
import java.util.Properties;
import java.util.Set;
public class ProperterDemos {
public static void main(String[] args) {
//演示Properties集合和流对象相结合的功能
// 创建一个properties集合
Properties p = new Properties();
//存储元素
p.setProperty("wo", "22");
p.setProperty(6quot;is", "24");
p.setProperty("am", "11");
p.setProperty("you", "00");
p.list(System.out);
}8.3将集合中的元素存储到一个指定目录下的文件中去
import java.util.Properties;
import java.util.Set;
public class ProperterDemos {
public static void main(String[] args) throws Exception {
//演示Properties集合和流对象相结合的功能
// 创建一个properties集合
Properties p = new Properties();
//存储元素
p.setProperty("wo", "22");
p.setProperty("is", "24");
p.setProperty("am", "11");
p.setProperty("you", "00");
p.list(System.out);
//将这些信息存储到一个指定目录下的文件中去
FileOutputStream fos = new FileOutputStream("E:\%5�myjava\\2015-6-12\\Properdemos.txt");
//将集合中数据存储到文件中去
p.store(fos, "name +age");
fos.close();
}8.4 读取一个文件 输出到控制台上
</pre><pre name="code" class="java">读取一个文件 输出到控制台上
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.util.Properties;
import java.util.Set;
public class ProperterDemos {
public static void main(String[] args) throws Exception
{
Properties p = new Properties();
//读取一个文件，要求文件内容必须是键值对的形式
FileInputStream fis = new FileInputStream("E:\\myjava\\2015-6-12\\Properdemos.txt");
p.load(fis);
p.list(System.out);
fis.close();
}g3C/pre><br /><h1> 9 获取指定目录下的指定文件格式的文件</h1></div><div><br /></div><div><pre name="code" class="java">import java.io.*;
public class FileSercherDeme {
public static void main(String[] args) {
// 查出指定目录下的mp3文件
File file = new File("E:\\myjava\\2015-6-14\\abc");
String[] s = file.list();
for(String ss :s)
{
String sname = ss;
if(sname.toLowerCase().endsWith(".mp3"))
%:0 System.out.println(sname);
}
System.out.println("------------------------------");
medth(file);
System.out.println("------------------------------");
String[] name = file.list(new Spilt1(".mp3"));
for(String ss :name)
{
System.out.println(ss);
}
}
public static void medth(File file)
{
File[] files = file.listFiles(new Spilt());
for(File f:files)
{
if(f.isDirectory())
medth(f);
System.out.println(f);
}
}
}
class Spilt1 implements FilenameFilter
{
private String suffix;
Spilt1(String suffix)
{
this.suffix=suffix;
}
public boolean accept(File dir,String name)
{
return name.toLowerCase().endsWith(suffix);
}
}
//实现FilenameFilter接口,可用于过滤器文件名
//本方法实现的是筛选指定格式结尾的文件
class Spilt implements FilenameFilter
{
//重写accept方法,测试指定文件是否应该包含在某一文件列表中
public boolean accept(File dir, String name) {
// 创建返回值
boolean flag = true;
// 定义筛选条件
//endWith(String str);判断是否是以指定格式结尾的
if (name.toLowerCase().endsWith(".mp3"))
{
return flag;
}
else
{
flag = false;
}
'20// 返回定义的返回值
//当返回true时,表示传入的文件满足条件
return flag;
}
}
