黑马程序员 java基础<五>--IO流(3)

-------android培训、java培训、java学习型技术博客、期待与您交流！
----------

知识点六 File类

一、概述：

1、File类：文件和目录路径的抽象表现形式

2、特点：

1）用来将文件或文件夹封装成对象

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

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

二、创建File对象：

方式一：File f1 = new File("a.txt");

---> 将a.txt封装成对象，可将已有的和未出现的文件或文件夹封装成对象

方式二：File f2 = new File("c:\\abc","b.txt");

---> 分别指定文件夹和文件。好处：降低了两者的关联程度，

方式三：File d = new File("c:\\abc"); File f3 = new File(d,"c.txt");

---> 可以传入父目录和文件名。

目录分隔符：调用File.separator，相当于是反斜杠 \

三、File类的常见方法

1.创建

boolean createNewFile();在指定位置创建文件，如果该文件已经存在，则不创建，返回false。

和输出流不一样，输出流对象一创建就创建文件。而且文件已经存在，则覆盖。

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

boolean mkdirs():创建多级文件夹，可以创建多级目录

2.删除

boolean delete();删除失败，返回false；

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

3.判断。

boolean exists():文件是否存在

booleanisFile():是否是文件

boolean isDirectory():是否是文件目录

boolean isHidden():文件是否隐藏

boolean isAbsolute():是否是绝对路径

4.获取信息。

String getName(); 获取文件名

String getPath(); 获取文件的相对路径（即创建的对象传入的参数是什么就获取到什么）

[b]String getParent();获取父目录，该方法返回绝对路径中的父目录，获取相对路径，返回null， 如果相对路径中有上一级目录，则返回的即为该目
录

String getAbsolutePath();获取绝对路径

long lastModified();最后一次修改的时候

long length():文件的大小

static File[] listRoots() ;获取文件的系统根，即各个盘符[/b]

String[]
list() ;列出当前目录所有文件，包含隐藏文件。注：调用了list方法的file对象，必须是封装了一个目录，且该目录必须存在。

boolean
renameTo(File dest);对文件重命名为dest

5.换名字： renameTo();方法用于更换文件的名字

6. 列出及过滤文件：

String[] list(); 列出当前目录所有文件，包含隐藏文件，调用list方法的file对象，必须是封装了一个目录，且该目录必须存在。

File[] list(FilenameFilter filter); FilenameFilter：文件名过滤器，是一个接口，其中包含一个方法，accept(File dir,String name)，返回 的是boolean型，对不符合条件的文件过滤掉。

File[] listFiles(); 获取当前文件夹下的文件和文件夹，返回类型为File数组

ListFiles(FilenameFilter filter);同list，是对获取的 当前文件夹下的文件和文件夹的 文件名过滤器。

***关于覆盖：覆盖的原理是先删除，然后再创建 ***

示例：

import java.io.*;

class FileDemo
{
public static void main(String[] args) throws IOException
{
//  consMethod();
method_5();
}
//创建File对象
public static void consMethod()
{
//将a.txt封装成file对象。可以将已有的和未出现的文件或则文件夹封装成对象。
File f1=new File("a.txt");

//abc指的是父目录，b.txt指的是目录中的文件名
File f2=new File("C:/abc","b.txt");

//将目录封装成对象
File d=new File("C:/abc");
File f3=new File(d,"c.txt");

sop("f1:"+f1);
sop("f2:"+f2);
sop("f3:"+f3);

//separator是与系统有关的默认的名称分割符，这样就可以实现跨平台
File f4=new File("c:"+File.separator+"abc"+File.separator+"ggg"+File.separator+"a.txt");
}

public static void sop(Object obj)
{
System.out.println(obj);
}
//方法一
public static void method_1() throws IOException
{
File f=new File("file.txt");
f.deleteOnExit();
//	  sop("create:"+f.createNewFile());

sop("delete:"+f.delete());
}
//方法二
public static void method_2() throws IOException
{
File f=new File("file.txt");

//文件是否能被执行
// sop("execute:"+f.canExecute());
//判断文件是否存在
//sop("exists:"+f.exists());
//创建文件夹
//mkdir()方法用于创建目录,只能创建一级目录，不能创建多级目录
//File dir=new File("abc\\aaa");
//mkdir()方法用于创建一级目录
//sop("mkdir:"+dir.mkdir());

//mkdirs()方法用于创建多级目录
File dir=new File("abc\\aaa\\ccc\\nnggg");
//mkdir()方法用于创建多级目录
sop("mkdir:"+dir.mkdirs());
}
//方法三
public static void method_3() throws IOException
{
File f=new File ("file.txt");
//记住在判断文件对象是否是文件对象或者目录时，必须要先判断该文件对象封装的内容是否存在
//通过exists判断。

//f.createNewFile();

f.mkdir();

//isDirectory()判断是否是目录，isFile判断是否是文件
sop("dir:"+f.isDirectory());
sop("dir:"+f.isFile());

//判断文件是否是绝对路径
sop(f.isAbsolute());
}
//方法四
public static void method_4() throws IOException
{
File f=new File("file.txt");

sop("path:"+f.getPath());

sop("abspath:"+f.getAbsolutePath());
//该方法返回的是绝对路径中的父目录
//如果获取的是相对路径，返回null空
//如果相对路径中有上一层目录，那么该目录就是返回结果
sop("parent:"+f.getParent());

}

//方法五
public static void method_5() throws IOException
{
//这样相当于移动（剪贴）和重命名
File f1=new File("C:/Test.java");

File f2=new File("d:/Sword.java");

//renameTo()方法用于更换文件的名字
sop(f1.renameTo(f2));

}

}

/*
list用于打印指定目录下文件或则文件夹的名称的

listRoots()列出机器中有效的盘符
*/

import java.io.*;

class FileDemo2
{
public static void main(String[] args) throws IOException
{
File dir=new File("C:\\");

File[] files=dir.listFiles();

for(File f: files)
{
System.out.println(f.getName()+"::"+f.length());
}

}
public static void  listDemo_2()
{
// listRootsDemo();

//listDemo();
File dir=new File("C:\\Users\\Administrator\\Desktop\\冲刺黑马之路\\代码");

//FilenameFilter()为匿名内部类
String[] arr=dir.list(new  FilenameFilter()
{
public boolean accept(File dir,String name)
{
// System.out.println("dir:"+dir+"...name"+name);
/*
if(name.endsWith(".java"))
{
return true;
}
*/
return name.endsWith(".java");
}
});

System.out.println("len:"+arr.length);

for(String name:arr)
{
System.out.println(name);
}
}

public static void  listDemo()
{
File f=new File("C:\\");
//list()用于打印指定目录下文件或则文件夹的名称的
//调用list方法的file对象必须是封装了一个目录，该目录还必须存在。
String[] names=f.list();
for(String name:names)
{
System.out.println(name);
}
}

public static void listRootsDemo()
{
//列出机器中有效的盘符
File[] files=File.listRoots();

//高级for循环，也就是for增强
for(File f:files)
{
System.out.println(f);
}
}
}

四、递归：

对于每次循环都是用同一个功能的函数，即函数自身调用自身，这种表现形式或手法，称为递归。

注意：

1、限定条件，是作为结束循环用的，否则是死循环

2、注意递归的次数，尽量避免内存溢出。因为每次调用自身的时候都会先执行下一次调用自己的发那个发，所以会不断在栈内存中开辟新空间，次数过多，会导致内存溢出。

例一：

列出指定目录下文件或者文件夹，包含子目录中的内容，也就是列出指定目录下所有内容。用递归的方式层级显示

分析，因为目录中还有目录，只有使用同一个列出目录功能的函数完成即可，在列出过程中出现的还是目录的话，还可以再调用本功能，这就是利用递归原理。

import java.io.*;

class FileDemo3
{
public static void main(String[] args)
{
File dir = new File("d:\\testdir");
//showDir(dir,0);

//toBin(6);
//int n = getSum(8000);
//System.out.println("n="+n);

System.out.println(dir.delete());
}
//对目录进行分级
public static String getLevel(int level)
{
StringBuilder sb = new StringBuilder();
sb.append("|--");
for(int x=0; x<level; x++)
{
//sb.append("|--");
sb.insert(0,"|  ");

}
return sb.toString();
}
public static void showDir(File dir,int level)
{

System.out.println(getLevel(level)+dir.getName());

level++;
File[] files = dir.listFiles();
for(int x=0; x<files.length; x++)
{
if(files[x].isDirectory())
showDir(files[x],level);
else
System.out.println(getLevel(level)+files[x]);
}
}

public static int getSum(int n)
{
if(n==1)
return 1;
return n+getSum(n-1);
}

public static void toBin(int num)
{
if(num>0)
{
toBin(num/2);
System.out.println(num%2);
}
}
public static void method()
{
method();
}
}

例二：

删除一个带内容的目录：

删除原理：在window中，删除目录是从里往外删除的，同样使用递归

import java.io.*;

class  RemoveDir
{
public static void main(String[] args)
{

File dir = new File("d:\\testdir");
removeDir(dir);
}

public static void removeDir(File dir)
{
File[] files = dir.listFiles();

for(int x=0; x<files.length; x++)
{
//if(!files[x].isHidden()&&files[x].isDirectory())判断文件是否隐藏

if(files[x].isDirectory())
removeDir(files[x]);
else
System.out.println(files[x].toString()+":-file-:"+files[x].delete());
}

System.out.println(dir+"::dir::"+dir.delete());
}

}

例三：

将一个指定目录下的java文件的绝对路径，存储到一个文本文件中。

建立一个java文件列表文件。

思路：

1，对指定的目录进行递归。

2，获取递归过程所有的java文件的路径。

3，将这些路径存储到集合中。

4，将集合中的数据写入到一个文件中。

补充一点：

数据的持久化：把数据存硬盘里就是持久化存储

import java.io.*;
import java.util.*;
class  JavaFileList
{
public static void main(String[] args) throws IOException
{

File dir = new File("d:\\java1223");

List<File> list = new ArrayList<File>();

fileToList(dir,list);

// System.out.println(list.size());

//dir是父目录，"javalist.txt"是文件名
File file = new File(dir,"javalist.txt");

//file.toString()将路径强转成字符串
writeToFile(list,file.toString());

}
public static void fileToList(File dir,List<File> list)
{
File[] files = dir.listFiles();

for(File file : files)
{
if(file.isDirectory())
fileToList(file,list);
else
{
if(file.getName().endsWith(".java"))
list.add(file);
}
}
}

public static void writeToFile(List<File> list,String javaListFile)throws IOException
{
BufferedWriter bufw =  null;
try
{
bufw = new BufferedWriter(new FileWriter(javaListFile));

for(File f : list)
{

//获取每个文件的绝对路径
String path = f.getAbsolutePath();
bufw.write(path);
bufw.newLine();
bufw.flush();
}

}
catch (IOException e)
{
throw e;
}
finally
{
try
{
if(bufw!=null)
bufw.close();
}
catch (IOException e)
{
throw e;
}
}
}
}

知识点七 Properties类

一、概述：

1、Properties是hashtable的子类。也就是说它具备map集合的特点。而且它里面存储的键值对都是字符串，不需要泛型定义。

Properties是不仅可以操作键值对信息，而且可以硬盘上的键值对信息。是集合中和IO技术相结合的集合容器。

2、特点：

1）可用于键值对形式的配置文件

2）在加载时，需要数据有固定的格式，常用的是：键=值

二、常用方法：

1、设置和获取元素：

Object setProperty(String key,String value);调用Hashtable的方法put

String getProperty(String key); 指定key搜索value

Set<String> stringPropertyName();返回属性列表的键集，存入Set集合

void load(InputStream ism) ;从输入字符流中读取属性列表

void load(Reader reader); 从输入字符流中读取属性列表
示例：

import java.io.*;
import java.util.*;

class PropertiesDemo
{
public static void main(String[] args) throws IOException
{
//method_1();
loadDemo();
}

public static void loadDemo()throws IOException
{
Properties prop = new Properties();
FileInputStream fis = new FileInputStream("info.txt");

//将流中的数据加载进集合。
prop.load(fis);

//setProperty改变的是内存的结果
prop.setProperty("wangwu","39");

FileOutputStream fos = new FileOutputStream("info.txt");
　　　　　　　　
　　　　//haha是注入信息，注释，#代表注释信息，不会被Properties所加载，Properties所加载的信息必须是键值对
//那么在加载数据时，需要数据有固定的格式，键=值
prop.store(fos,"haha");

//	System.out.println(prop);
prop.list(System.out);

fos.close();
fis.close();

}

//演示，如何将流中的数据存储到集合中。
//想要将info.txt中键值数据存到集合中进行操作。
/*
1,用一个流和info.txt文件关联。
2，读取一行数据，将该行数据用"="进行切割。
3，等号左边作为键，右边作为值。存入到Properties集合中即可。

*/
public static void method_1()throws IOException
{
BufferedReader bufr = new BufferedReader(new FileReader("info.txt"));

String line = null;
Properties prop = new Properties();

while((line=bufr.readLine())!=null)
{
//split是切割
String[] arr = line.split("=");
///System.out.println(arr[0]+"...."+arr[1]);
prop.setProperty(arr[0],arr[1]);
}

bufr.close();

System.out.println(prop);
}
//设置和获取元素。set和get方法
public static void setAndGet()
{
Properties prop = new Properties();

//setProperty设置键值对
prop.setProperty("zhangsan","30");
prop.setProperty("lisi","39");

//		System.out.println(prop);
String value = prop.getProperty("lisi");
//System.out.println(value);

//89+""转化成字符型
prop.setProperty("lisi",89+"");

Set<String> names = prop.stringPropertyNames();
for(String s : names)
{
System.out.println(s+":"+prop.getProperty(s));
}
}

}

练习：限制程序运行次数。当运行次数到达5次时，给出，请您注册的提示。并不再让该程序执行。

1）很容易想到的是:计数器。

可是该计数器定义在程序中，随着程序的运行而在内存中存在，并进行自增。

可是随着该应用程序的退出，该计数器也在内存中消失了。

2）下一次在启动该程序，又重新开始从0计数。

这样不是我们想要的。

3）程序即使结束，该计数器的值也存在。

下次程序启动在会先加载该计数器的值并加1后在重新存储起来。

4）所以要建立一个配置文件。用于记录该软件的使用次数。

5）该配置文件使用键值对的形式。这样便于阅读数据，并操作数据。

6）键值对数据是map集合。数据是以文件形式存储，使用io技术。那么map+io -->properties.

补充知识点：

配置文件可以实现应用程序数据的共享。

现在要用的配置文件有两种：键值对的和xml文件
dom4j: dom for java解析xml文件
示例：

import java.io.*;
import java.util.*;
class  RunCount
{
public static void main(String[] args) throws IOException
{
Properties prop = new Properties();

File file = new File("count.ini");
if(!file.exists())
file.createNewFile();

FileInputStream fis = new FileInputStream(file);

//将流中的数据加载到集合当中
prop.load(fis);

int count = 0;
String value = prop.getProperty("time");

if(value!=null)
{
count = Integer.parseInt(value);
if(count>=5)
{
System.out.println("您好，使用次数已到，拿钱!");
return ;
}

}

count++;

prop.setProperty("time",count+"");

FileOutputStream fos = new FileOutputStream(file);

//注入信息没写
prop.store(fos,"");

fos.close();
fis.close();

}
}

/*
name=zhangsan
age=20

<persons>
<person id="001">
<name>zhagnsan</name>
<age>30</age>
<address>bj</address>
</person>
<person>
<name>...
</person>
</persons>
*/

知识点八 打印流

一、概述：

1、打印流包括：PrintStream和PrintWriter

2、该流提供了打印方法，可以将各种数据类型的数据都原样打印。

二、字节打印流：PrintStream

构造方法中可接收的参数类型：

1、file对象。File

2、字符串路径：String

3、字符输出流：OutputStream

三、字符串打印流：PrintWriter

构造方法中可接受的参数类型

1、file对象：File

2、字符串路径：String

3、字节输出流：OutputStream

4、字符输出流：Writer

补充知识点：在dos命令控制台下，输入cls可以清空dos控制台，按下ctrl+c关闭输入

示例：

import java.io.*;

class  PrintStreamDemo
{
public static void main(String[] args) throws IOException
{
//读取键盘录入，这句话非常的重要，一定要背下来
BufferedReader bufr =
new BufferedReader(new InputStreamReader(System.in));

//把文件封装到流里面，可以实现字符刷新
PrintWriter out = new PrintWriter(new FileWriter("a.txt"),true);

String line = null;

while((line=bufr.readLine())!=null)
{
if("over".equals(line))
break;
out.println(line.toUpperCase());
//out.flush();
}

out.close();
bufr.close();

}
}

知识点九 序列流

一、概述：

1.序列流SequenceInputStream没有直接对应OutputStream，表示其它输入流的逻辑串联

2、SequenceInputStream可以将多个流连接成一个源

3、构造函数：

SequenceInputStream(Enumeration<? extends FileInputStream> e)

二、如何合并多个文件：

1、创建集合，并将流对象添加进集合

2、创建Enumeration对象，将集合元素加入。

3、创建SequenceInputStream对象，合并流对象

4、创建写入流对象，FileOutputStream，将数据写入流资源

5、定义数组，将读取流数据存入数组，并将数组中元素写入文件中。
示例：

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

Vector<FileInputStream> v = new Vector<FileInputStream>();

v.add(new FileInputStream("c:\\1.txt"));
v.add(new FileInputStream("c:\\2.txt"));
v.add(new FileInputStream("c:\\3.txt"));

//Enumeration是个接口不是类（列举）为了实现遍历枚举也用于将输入流指定到 SequenceInputStream 中。

//注：此接口的功能与 Iterator 接口的功能是重复的。此外，Iterator 接口添加了一个可选的移除操作，并使用较短的方法名。

//新的实现应该优先考虑使用 Iterator 接口而不是 Enumeration 接口。
Enumeration<FileInputStream> en = v.elements();

SequenceInputStream sis = new SequenceInputStream(en);

FileOutputStream fos = new FileOutputStream("c:\\4.txt");

//创建缓冲区
byte[] buf = new byte[1024];

int len =0;
while((len=sis.read(buf))!=-1)
{
fos.write(buf,0,len);
}

fos.close();
sis.close();
}
}

三、切割流资源：

1、先关联文件FileInputStream

2、定义写入流变量：FileOutputStream

3、创建数组，并定义切割所需的大小|

4、循环读写数据，并每次创建一个新写入流，创建完后并写入文件中

5、关闭流资源

示例：

import java.io.*;
import java.util.*;

class SplitFile
{
public static void main(String[] args) throws IOException
{
//splitFile();
merge();
}

public static void merge()throws IOException
{
ArrayList<FileInputStream> al = new ArrayList<FileInputStream>();

for(int x=1; x<=3; x++)
{
al.add(new FileInputStream("c:\\splitfiles\\"+x+".part"));
}

final Iterator<FileInputStream> it = al.iterator();

Enumeration<FileInputStream> en = new Enumeration<FileInputStream>()
{
public boolean hasMoreElements()
{
return it.hasNext();
}
public FileInputStream nextElement()
{
return it.next();
}
};

SequenceInputStream sis = new SequenceInputStream(en);

FileOutputStream fos = new FileOutputStream("c:\\splitfiles\\0.bmp");

byte[] buf = new byte[1024];

int len = 0;

while((len=sis.read(buf))!=-1)
{
fos.write(buf,0,len);
}

fos.close();
sis.close();
}

public static void splitFile()throws IOException
{
FileInputStream fis =  new FileInputStream("c:\\1.bmp");

FileOutputStream fos = null;

byte[] buf = new byte[1024*1024];

int len = 0;
int count = 1;
while((len=fis.read(buf))!=-1)
{
fos = new FileOutputStream("c:\\splitfiles\\"+(count++)+".part");
fos.write(buf,0,len);
fos.close();
}

fis.close();

}
}

最新最全的的java学习视频教程：http://pro.net.itcast.cn/View-22-1458.aspx

-------android培训、java培训、java学习型技术博客、期待与您交流！
----------

详细请查看：http://edu.csdn.net/heima