关闭

Java IO流

标签: javaIO流
316人阅读 评论(0) 收藏 举报
分类:

Java IO

IO(Input Output)

IO流用来处理该设备之间的数据传输

Java对数据的操作是通过流的方式

Java用于操作流的对象都在IO包中

流按操作数据分为两种:字节流与字符流(字符流有编码表)

流按流向分为:输入流、输出流

 

IO流常用基类

         字节流的抽象基类:

                   InputStreamOutputStream

         字符流的抽象基类:

                   ReaderWriter

         注:由这四个类派生出来的子类名称都是以其父类名作为子类名的后缀.  

                  如:InputStream的子类FileInputStreamReader的子类FileReaders

eg:需求:在硬盘上创建一个文件并写入一些文字数据。

         找到一个专门用于操作文件的writer子类对象:FileWriter,后缀是父类名,前缀是该留对象的功能。

<span style="font-size:14px;">//创建一个FileWriter对象,该对象一初始化就必须要明确被操作的文件。
	//而且该对象会被创建到指定目录下,如果该目录下已有同名文件,将被覆盖。
	//其实该步就是在明确数据要存放的目的地。
	FileWriter fw=new FileWriter(“demo.txt”);		//得抛异常 throws IOException
	//调用writer方法,将字符串写入到流中(此时并没有写进文件)
	fw.writer(“abcde”);
	//刷新流对象中的缓冲中的数据。将数据刷到目的地中(到文件中了)
	fw.flush();
	//关闭流资源,但是关闭之前会刷新一次内部的缓冲中的数据
	//将数据刷到目的地中
	//和flush区别:flush刷新后,流可以继续使用,close刷新后,会将流关闭
	fw.close();
</span>

 

IO异常处理方式

eg:

<span style="font-size:14px;">import java.io.*;
class FileWriterDemo
{
	public static void main(String[] args)
	FileWriter fw=null;		//因为后面finally用到,要放到外面
	try
	{
		fw=new FileWriter(“demo.txt”);
		fw.writer(“abcdefg”);
}
catch(IOException e)
{
	System.out.println(“catch:”+e.toString());
}
finally
{
	try		//再try,因为这里可以有异常。注:有几个IO流,这里try几次(分别关)
	{
		if(fw!=null)
			fw.close();
}
catch(IOException e)
{
	System.out.println(e.toString());
}
}
}
</span>

对已有文件的续写

<span style="font-size:14px;">public static void main(String[] args)throws IOException
{
	//传递一个true参数,代表不覆盖已有的文件,并在已有文件的末尾处进行数据续写
	FileWriter fw=new FileWriter(“demo.txt”,true);	//编程时这里要try
	fw.writer(“mhao\r\nxiexie”);		//windows换行
	fw.close();
}
</span>


 

文本读取方式

1>     创建一个文件读取流对象,和指定名称的文件相关联

要保证该文件是已经存在的,如果不存在,会发生异常FileNotFoundException

FileReader fr=new FileReader(“demo.txt”);

调用读取流对象的read方法。read()方法:一次读一个字符,而且会自动往下读。

int ch=fr.read();                            //注:返回int

//读到末尾返回“-1

int ch=0

while((ch=fr.read())!=-1)

{

           System.out.println(“ch=”(char)chs);

}

2>     第二种方式:通过字符数组读取

<span style="font-size:14px;">FileReader fr=new FileReader(“demo.txt”);

//定义一个字符数组,用于存储读到字符

//该read(char[])返回得失读到字符个数。

char[] buf=new char[1024];//一般定义1024,如果小于会循环用。1个字符2字节,即2KB

int num=0;

while((num=fr.read(buf))!=-1)

{

           System.out.println(new String(buf,0,num));   //只打印取到的字符

}

fr.close();
</span>

 

拷贝文本文件

复制的原理:

           其实就是将C盘下的文件数据存储到D盘的一个文件中。

步骤:

1.       在D盘创建一个文件,用于存储C盘文件中的数据

2.       定义读取流和C盘文件关联

3.       通过不断地读写完成数据存储

4.       关闭资源

eg:

 

<span style="font-size:14px;">import java.io.*;
	class CopyText
	{
		public static void main(String[] args) throws IOException
		{
			copy();
}
public static void copy()
{
	FileWriter fw=null;
	FileReader fr=null;
	try
	{
		fw=new FileWriter(“SystemDemo_Copy.txt”);
		fr=new FileReader(“SystemDemo.java”);
		char[] buf=new char[1024];
		int len=0;
		while((len=fr.read(buf))!=-1)
		{
			fw.write(buf,0,len);
}
}
catch(IOException e)
{
	throw new RuntimeException(“读写失败”);
}
finally
{
	if(fr!=null)
		try
		{
			fr.close();
}
catch(IOException e)
{
	
}
					if(fw!=null)
						try
						{
							fw.close();
}
catch(IOException e)
{

}
}
}
}
</span>

字符流的缓冲区

         缓冲区的出现提高了对数据的读写效率

         对应类

                   BufferedWriter

                   BufferedReader

         缓冲区要结合流才可以使用

         在流的基础对流的功能进行了增强

BufferedWriter       (字符写入流缓冲区)

建立缓冲区之前,必须要先有流对象;该缓冲区提供了一个跨平台的换行符newLine().

                   eg

<span style="font-size:14px;">//创建一个字符写入流对象
			FileWriter fw=new FileWriter(“buf.txt”);
			//为了提高字符写入流效率,加入了缓冲技术
			//只要将需要被提高效率的流对象作为参数传递给缓冲区的构造函数
			BufferedWriter bufw=new BufferedWriter(fw);
			for(int x=1;x<5;x++)
			{
				bufw.write(“abcd”+x);
				bufw.newLine();
				bufw.flush();			//刷新,防止突然停电等
}
//记住,只要用到缓冲区,就要记得刷新。
//其实关闭缓冲区,就是在关闭缓冲区中的流对象。
bufw.close();			//不用再fw.close();
</span>

BufferedReader      (字符读取流缓冲区)

该缓冲区直接提供了一个歌词读一行的方法readLine(),方便于对文本数据的获取。当返回null时,表示读到文件末尾。

readLine方法返回的时候只返回回车符之前的数据内容,并不返回回车符。

 eg:

<span style="font-size:14px;">//创建一个读取流对象和文件关联
			FileReader fr=new FileReader(“buf.txt”);
//为了提高效率,加入缓冲技术,将字符读取流对象作为参数传递给缓冲区对//象构造函数.
BufferedReader bufr=new BufferedReader(fr);
String line=null;
while((line=bufr.readLine))!=null)
{
	System.out.println(line);
}
bufr.close;
</span>


eg:通过缓冲区复制一个.java文件

<span style="font-size:14px;">import java.io.*;
		class CopyTextByBuf
		{
			public static void main(String[] args)
			{
				BufferedReader bufr=null;
				BufferedWriter bufw=null;
				try
				{
					bufr=new BufferedReader(new FileReader(“BufferedWriterDemo.java”));
					bufw=new BufferedWriter(new FileWriter(“BufferedWriter_Copy.java”));
					String line=null;
					while((line=bufr.readLine())!=null)
					{
						bufw.writer(line);
						bufw.newLine();
						bufw.flush();
}
}
catch(IOException e)
				{
					throw new RuntimeException(“读写失败”);
}
finally
{
		try
		{
			if(bufr!=null)
				bufr.close();
}
catch(IOException e)
{
	throw new RuntimeException(“读取关闭失败”);
}
						try
						{
							if(bufw!=null)
								bufw.close();
}
catch(IOException e)
{
	throw new RuntimeException(“写入关闭失败”);
}
}
}
}
</span>

readLine()原理:    【用到了装饰】
代码:

<span style="font-size:14px;">import java.io.*;
class MyBufferedReader extends Reader
{
	private Reader r;
	MyBufferedReader(Reader r)
	{
		this.r=r;
}
//可以一次读一行数据的方法
public String myReadLine() throws IOException
{
	//定义一个临时容器。原BufferedReader封装的是字符数组
//为了方便。定义一个StringBuilder容器。因为最终还要将数据变成字符//串
StringBuilder sb=new StringBuilder();
int ch=0;
while((ch=r.read())!=-1)
{
	if(ch==’\r’)			//\r\n代表换行(Windows中)
		continue;
	if(ch==’/n’)
		return sb.toString();
	else
		sb.append((char)ch);
}
if(sb.length()!=0)
{
	return sb.toString();	//如果有数据却没有换行
}
return null;
}
@Override
public int read(char[] cbuf,int off,int len)throws IOException
{
	return r.read(cbuf,off,len);
}
@Override
public void close()throws IOException
{
	r.close();
}
public void myClose() throws IOException
{
	r.close();
}
}
</span>

装饰设计模式

         当想要对已有的对象进行功能增强时

         可以定义类,将已有对象传入,基于已有功能,并提供加强功能。

         那么自定义的该类称为装饰类

                   BufferedReader即是

         装饰类通常会通过构造方法接收被装饰的对象

         并给予被装饰的对象的功能,提供更强的功能

eg:

<span style="font-size:14px;">class Person
{
	public void chiFan()
	{
		System.out.println(“吃饭”);
}
}
class SuperPerson
{
	private Person p;
	Super Person(Person p)
	{
		this.p=p;
}
public void superChiFan()
{
	System.out.println(“开胃酒”);
	p.chiFan();
	System.out.println(“甜点”);
}
}
</span>

装饰和继承的区别

装饰模式比继承要灵活。避免了继承体系臃肿。

而且降低了类与类之间的关系。

装饰类因为增强了已有对象,具备的功能和已有的是相同的,只不过提供了更强功能。所以装饰类和被装饰类通常都是属于一个体系的。

eg:

继承:

         MyReader

                   |---MyTextReader

                            |---MyBufferTextReader

                   |---MyMediaReader

                            |---MyBufferMediaReader

                   |---MyDateReader

                            |---MyBufferDataReader

找到共同点,用多态形式

<span style="font-size:14px;">class MyBufferReader extends MyReader
{
	private MyReader r;
	MyBufferReader(MyReader r)
	{
}
}
</span>

 

即:MyReader

                   |---MyTextReader

                   |---MyMediaReader

                   |---MyDataReader

                   |---MyBufferReader

LineNumberReader

         LineNumberReaderBufferedReader的子类(和其用处基本一样)

         有两个特殊方法:setLineNumber(int LineNumber)[设置当前行号]

         getLineNumber()[获取当前行号]【默认从0开始,一行结束+1,没有没有一行则是1

注:setLineNumber(int )不会实际更改流中的当前位置,它是更改将由getLineNumber()返回的值。

字节流File读写操作

InputStream    【读】   OutPutStream【写】

字符流底层也是用字节流,一个字符占两字节,不能单个操作,所以先存起来后刷新

eg:

需求:想要操作图片数据,这时就要用到字节流。

复制一个图片

<span style="font-size:14px;">import java.io.*;
class FileStream
{
	public static void main(String[] args)throws IOException
	{
		writeFile();
		readFile_3();
}
//方法三,如果文件太大,内存会溢出
public static void readFile_3()throws IOException
{
	FileInputStream fis=new FileInputStream(“fos.txt”);
	//int num=fis.available();	//fis文件的大小
	byte[] buf=new byte[fis.available()];	//定义了一个大小刚好的缓冲区,不
									//用再循环了
	fis.read(buf);
	System.out.println(new String(buf));
	fis.close();
}
			//方法二,定义了一个1024大小的字节数组
public static void readfile_2() throws IOException
{
	FileInputStream fis=new FileInputStream(“fos.txt”);
	byte[] buf=new byte[1024];
	int len=0;
	while((len=fis.read(buf))!=-1)
	{
		System.out.println(new String(buf,0,len));
}
fis.close();
}
//一个一个读
public static void readFile_1() throws IOException
{
	FileInputStream fis=new FileInputStream(“fos.txt”);
	int ch=0;
	while((ch=fis.read())!=-1)
	{
		System.out.println((char)ch);
}
fis.close();
}
public static void writeFile() throws IOException
{
	FileOutputStream fos=new FileOutputStream(“fos.txt”);
	fos.write(“abcde”.getBytes());		//将此String转为byte数组
	fos.close();
}
}
</span>



 

<span style="font-size:14px;">/*复制一个图片
思路:
1.	用字节读取流对象和图片关联
2.	用字节写入流对象创建一个图文件。用于存储获取到的图片数据
3.	通过循环读写,完成数据的存储
4.	关闭资源
*/
import java.io.*;
class CopyPic
{
	public static void main(String[] args)
	{
		FileOutputStream fos=null;
		FileInputStream fis=null;
		try
		{
			fos=new FileOutputSream(“c:\\2.bmp”);
			fis=new FileInputStream(“c:\\1.bmp”);
			byte[] buf=new byte[1024];
			int len=0;
			while((len=fis.read(buf))!=-1)
			{
				fos.write(buf.0.len);
}
}
catch(IOException e)
{
	throw new RuntimeException(“复制文件失败”);
}
finally
{
	try
	{
		if(fis!=null)
			fis.close();
}
catch(IOException e)
{
	throw new RuntimeException(“读取关闭失败”);
}
try	
{
	if(fos!=null)
		fos.close();
}
catch(IOException e)
{
	throw new Runtime(“写入关闭失败”);
}
}
} 
}
</span>



字节流的缓冲区:

         BufferedOutputStream

         BufferedInputStream

<span style="font-size:14px;">/* BufferedInputStream 的原理+复制一首mp3 */
import java.io.*;
class MyBufferedInputStream
{
	private InputStream in;
	private byte[] buf=new byte[1024*4];
	private int pos=0,count=0;	//pos取数据的指针;count计数器,记录byte[]中还
//有多少数据
	MyBufferedInputStream(InputStream in)
	{
		this.in=in;
}
//一次读一个字节,从缓冲区(字节数组)获取。
public int myRead() throws IOException
{
	//通过in对象读取硬盘上数据,并存储buf中
	if(count==0)
	{
		count=in.read(buf);
		if(count<0)
			return -1;
		pos=0;
		byte b=buf[pos];
		count--;
		pos++;
return b&255;       //因为byte转int类型,为了保持数据不变,

}
else if(count>0)
{
	byte b=buf[pos];
	count--;
	pos++;
	return b&0xff;		//255
}
return -1;
}
public void myClose() throws IOException
{
	in.close();
}
}
</span>



 

<span style="font-size:14px;">//下面是通过缓冲区,复制mp3的代码(如果用BufferedInputStream,只需替换
//MybufferedInputStream即可
class CopyMp3
{
	public static void main(String[] args) throws IOException
	{
		long start=System.currentTimeMillis();
		copy_2();		//方法2
		long end=System.currentTimeMillis();
		System.out.println((end-start)+”毫秒”);	//获取程序运行时间
}
//调用字节流的缓冲区原理那个方法
public static void copy_2() throws IOException
{
	MyBufferedInputStream bufis=
new MyBuffertedInputStream(new FileInputStream(“c:\\3.mp3”));
				BufferedOutputStream bufos=
					new BufferedOutputStream(new FileOutputStream(“c://2.mp3”));
				int by=0;
				while((bu=bufis.myRead())!=-1)
				{
					bufos.write(by);
}
bufos.close();
bufis.myClose();
}
//调用系统自己的方法
public static void copy_1() throws IOException
{
	BufferedInputStream bufis=
new BufferedInputStream(new FileInputStream(“c:\\0.mp3”));
				BufferedOutputStream bufos=
						new BufferedOutputStream(new FileOutputStream(“c:\\1.mp3));
				int by=0;
				while((by=bufis.read())!=-1)
				{
					bufis.write(by);
}
bufos.close();
bufis.close();
}
}
</span>


 

读取键盘录入

System.out:对应的是标准输出设备,控制台;

System.in    对应的是标准输入设备:键盘。

eg:需求:通过键盘录入数据。

                  当录入一行数据后,就将该行数据进行打印。

                  如果录入的数据时over,那么停止录入。

 

<span style="font-size:14px;">import java.io.*;
class ReadIn
{
	public static void main(String[] args)throws IOException
	{
		InputStream in=System.in;
		StringBuilder sb=new StringBuilder();
		while(true)
		{
			int ch=in.read();
			if(ch==’\r’)
				continue;
			if(ch==’\n’)
			{
				String s=sb.toString();
				if(“over”.equals(s))
					break;
				System.out.println(s.toUpperCase());
				sb.delete(0,sb.length());		//清空sb
}
else
	sb.append((char)ch);
}
}
}
</span>

读取转换流

         字符流:FileReader,FileWriter;

                            BufferedReader,BufferedWriter.

         字节流:FileInputStream,FileOutputStream

                            BufferedInputStream,BufferedOutputStream

         readLine方法是字符流BufferedReader类中的方法。

         而键盘录入的read方法是字节流InputStream的方法。

         将字节流转换成字符流再使用readLine方法。

代码:

<span style="font-size:14px;">import java.io.*;
	class TransStreamDemo
	{
		public static void main(Sring[] args)throws IOException
		{
			//获取键盘录入对象
			InputStream in=System.in;
			//将字节流对象转成字符流对象,使用转换流。
			InputStreamReader isr=new InputStreamReader(in);
			//为了提高效率,将字符串进行缓冲区技术高效操作,使用
//BufferedReader
BufferedReader bufr=new BufferedReader(isr);
String line=null;
while((line=bufr.readLine())!=null)
{
	if(“over”.equals(line))
		break;
	System.out.println(line.toUpperCase());
}
bufr.close();
}
}
</span>

写入转换流

         OutputStreamWriter

代码:

<span style="font-size:14px;">import java.io.*;
class TransStreamDemo
{
	public static void main(String[] args)throws IOException
	{
		//键盘的最常见写法
		BufferedReader bufr=
new BufferedReader(new InputStreamReader(System.in));
					//以下是写入转换流(输出)
					OutputStream out=System.out;
					OutputStreamWriter osw=new OutputStreamWriter(out);
					BufferedWriter bufw=new BufferedWriter(osw);	//为了用newLine()
					String line=null;
					while((line=bufr.readLine())!=null)
					{
						if(“over”.equals(line))
							break;
						bufw.writer(line.toUpperCase());
						bufr.newLine();
						bufr.flush();	//刷新,字符流要刷新
}
bufr.close();
}
}
</span>


 

流操作规律:

InputStreamReader/ OutputStreamWriter:是字节流通向字符流的桥梁。

1.       源:键盘录入;目的:控制台

BufferedReader bufr=

new BufferedReader(new InputStreamReader(System.in));

BufferedWriter bufw=

new BufferedWriter(new OutputStreamWriter(System.out));

2.       需求:想把键盘录入的数据存储到一个文件中。

源:键盘;目的:文件。

BufferedReader bufr=

new BufferedReader(new InputStreamReader(System.in));

BufferedWriter bufw=

new BufferedWriter(new OutputStreamWriter(new FileOutputStream(“out.txt)));

3.       需求:想要将一个文件的数据打印在控制台上。

源:文件;目的:控制台

BufferedReader bufr=

new BufferedReader(new InputStreamReader(“copypic.java”));

BufferedWriter bufw=

new BufferedWriter(new OutputStreamWriter(System.out));

 

                           流操作的基本规律:最痛苦的就是流对象很多,不知道该用哪一个。

                           通过三个明确来完成:

1>     明确源和目的

源:输入流:InputStreamReader

目的:输出流:OutputStreamWriter

2>     操作的数据是否纯文本

是:字符流

不是:字节流

3>     当体系明确后,再明确要使用那个具体的对象

通过设备来进行区分:

源设备:内存、硬盘、键盘

目的:内存、硬盘、控制台

   将一个文本文件中数据存储到另一个文件中,复制文件。

源:因为是源,所以使用读取流。InputStream Reader

是不是操作文本文件。

是!这时就可以选择Reader

这样体系就明确了。

 

接下来明确要使用体系中的哪个对象。

明确设备:硬盘上一个文件。

Reader体系中可以操作稳健的对象是:FileReader

是否需要提高效率:是!加入Reader体系中缓冲区BufferedReader

FileReader fr=new FileReader(“a.txt”);

BufferedReader bufr=new BufferedReader(tr);

                                    目的:

                                               OutputStream Writer

                                              是否是纯文本

                                              是!Writer

                                              设备:硬盘,一个文件。

                                               Writer体系中可以操作文件的对象FileWriter

                                              是否需要提高效率:是!加入Writer体系中缓冲区BufferedWriter

                                               FileWriter fw=new FileWirter(“b.txt”);

                                               BufferedWriter bufw=new BufferedWriter(“fw”);

   需求:将键盘录入的数据保存到一个文件中

这个需求中有源和目的都存在。

那么分别分析:源:InputStreamReader

                              是否是纯文本:是!Reader

设备:键盘。对应的对象是:System.in

不是选择Reader吗?System.in对应的不是字节流吗?

为了操作键盘的文本数据方便。转成字符流按照字符串操作是最方便的。所以既然明确了Reader,那么就将System.in转成Reader

用了Reader体系中的转换流,InputStreamReader

 

InputStreamReader isr=new InputStreamReader(System.in);

需要提高效率吗?需要!BufferedReader

BufferedReader bufr=new BufferedReader(isr);

 

目的:OutputStream Writer

是否是纯文本?是!Writer

设备:硬盘,一个文本,使用FileWirter

FileWriter fw=new FileWriter(“c.txt”);

需要提高效率吗?需要

BufferedWriter bufw=new BufferedWriter(fw);

 

扩展,想要把录入的数据按照指定的编码表(utf-8,将数据存到文件中。

目的:OutputStreamWriter

是否是纯文本?是!Writer

设备:硬盘,一个文件、使用FileWriter

但是FileWriter是使用的默认编码表、GBK

 

但是存储时,需要加入指定编码表utf-8,而指定的编码表只有转换流可以指定,所以要使用的对象是OutputStreamWiter

而该转换流对象要接受一个字节输出流,而且还可以操作的文件的字节输出流FileOutputStream

OutputStreamWriter osw=

new OutputStreamWirter(new FileOutputStream(“d.txt”),”utf-8”);

 

                                              需要高效吗?需要

BufferedWriter bufw=new BufferedWriter(osw);

所以,记住。转换流什么使用,字符流和子街之间的桥梁,通常涉及到字符编码转换时,需要用到转换流。

                           

改变标准输入输出设备

                                     System下的:SetInSetOut

                                    引用“写入转换流”的例子。

                                    代码:

                                     public static void main(String[] args)throws IOException

                                     {

                                               System.SetIn(new FileInputStream(“PersonDemo.java”));

                                               System.SetOut(new PrintStream(“222.txt”));

}

 

File概述

File类:用来将文件或者文件夹封装成对象

                  方便对文件与文件夹的属性信息进行操作

                   File对象可以作为参数传递给流的构造函数

                  了解File中常用方法

<span style="font-size:14px;">//创建File对象
public static void consMethod()
{
	//将a.txt封装成file对象,可以装已有的和未出现的文件或者文件夹封装
//成对象
File f1=new File(“a.txt);
//File(String parent,String child) ;parent代表路径名字符串,child为parent
//下的File实例
File f2=new File(“c:\\abc”,”b.txt”);	//方式1
File d=new File(“c:\\abc”);
File f3=new File(d,”c.txt”);
System.out.println(“f1:”+f1);	//打印的是文件的路径(相对路径就打相对,
//绝对就打绝对.
System.out.println(“f2:”+f2);
System.out.println(“f3:”+f3);
}
</span>


 

File对象功能-创建和删除、判断、获取

File类常见方法:

1.       创建

boolean createNewFile():在指定位置创建文件,如果该文件已经存在,则不创建,返回false。和输出流不一样,输出流对象一建立创建文件,而且文件已经存在的话,会覆盖。

boolean mkdir():创建文件夹(只能创建一级目录)

boolean mkdirs():创建多级文件夹。

File dir=new File(“abc\\kk\\cc”);      dir.mkdirs();

2.       删除

boolean delete():删除失败返回false,如果文件正在被使用,则删除不了返回false

void deleteOnExit():在程序退出时删除指定文件。

3.       判断(java有的文件用流无法访问,如:c:\\Systemde目录;java不管隐藏与否都拿)

boolean exists():文件是否存在

isFile():      是否是一个标准文件

isDirectory():此路径名表示的文件是否是一个目录。

isHidden():        是否是一个隐藏文件

isAbsolute():     测试此抽象路径是否为绝对路径名

4.       获取信息

getName():返回由此抽象路径名表示的文件或目录的名称。

getPath():将此抽象路径名转换为一个路径名字符串。

getParent():返回此抽象路径名父目录的路径名字符串,如没有指定父目录,返null

getAbsolutePath():返回此抽象路径名的绝对路径名字符串。

long lastModified():返回由此抽象路径名表示文件的长度。

long length():返回有此抽象路径名表示文件的长度。

renameTo(File dest):重命名此抽象路径明表示的文件。

 

File 对象功能——文件列表

(static File)listRoots()列出可用的文件系统根(返回一个File数组)

eg:

<span style="font-size:14px;">	File[] files=File.listRoots();
	for(File f:files)
	{
		System.out.println(f);
}
</span>


 

结果:(列出了及其中的盘符)

         C:\

         D:\

         E:\

         F:\

(String[] )List(),用来返回指定抽象路径下的文件和目录(包含隐藏文件)

eg:

<span style="font-size:14px;">File f=new File(“c:\\”);
	String[] name=f.list();
	for(String name:name)
	{
		System.out.println(name);
}
</span>


 

(String[] )List(FilenameFilter filter) 【文件名过滤,如只需要某目录下的.java

文件】

  eg:

<span style="font-size:14px;">		//取.bmp文件后缀的文件
					File dir=new File(“d:\\java12\\day18”);
					String[] arr=dir.list(new FilenameFilter()
					{
						public boolean accept(File dir,String name)
						{
							return name.endsWith(“.bmp”);
}
});
for(String name:arr)
{
	System.out.println(name);
}
</span>


 

IO包中的其他类

                           打印流

                                     PrintWriterPrintStrem

                                              可以直接操作输入流和文件

                           序列流

                                     SequenceInputStream

                                              对多个流进行合并

                           操作对象

                                     ObjectInputStreamObjectOutputStream

                                              被操作的对象需要实现Serializable(标记接口);

 IO包中的其他类

                           操作基本数据类型

                                     DataInputStreamDataOutputStream

                           操作字节数组

                                     ByteArrayInputStreamByteArrayOutStream

                           操作字符数组

                                     CharArrayReaderCharArrayWriter

                           操作字符串

                                     StringReaderStringWriter

 

1
0

查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
    个人资料
    • 访问:5572次
    • 积分:211
    • 等级:
    • 排名:千里之外
    • 原创:15篇
    • 转载:0篇
    • 译文:0篇
    • 评论:1条
    文章分类
    文章存档
    最新评论