黑马程序员_毕向东JAVA基础_IO流（二）

---------------------- ASP.Net+Android+IO开发S、.Net培训、期待与您交流！ ----------------------

一、File类

用来将文件或者文件夹封装成对象。

方便对文件与文件夹进行操作。

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

了解File类中的常用方法。

注意：sepatator 跨平台的分隔符表现形式 “c:”+File.sepatator+”a.txt”

File 类的常见方法：

1． 创建

a) boolean createNewFile();在指定位置创建玩家，如果该文件已经存在，则不创建，返回false。和输出流不一样，输出流对象一旦建立创建文件，而且文件已经存在，会覆盖。

b) boolean mkdir（）：创建一级文件夹

c) boolean mkdirs（）：创建多级文件夹

2． 删除

a) boolean delete():删除失败，返回false。

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

3． 判断

a) boolean exists（）；文件是否存在。

b) isFile():

c) isDirectory():

d) isHidden();

e) isAbsolute(): 是否是绝对路径。

4． 获取信息。

a) get Name（）；

b) getPath（）；获取路径

c) getAbsolutePath（）；获取绝对路径。

d) lastModified（）；

e) length（）；

代码（一）

/*输出文件的路径*/
import java.io.*;
class  FileDemo
{
public static void main(String[] args)
{
consMethod();
}

public static void consMethod()
{
//将a.txt封装成为file对象，可以将已有的和未出现的文件或者文件夹封装成对象。
File f1 = new File("d:\\java0515\\a.txt");

File f2 = new File("d:\\java0515","b.txt");

File f3 = new File("c.txt");

File d = new File("d:\\java0515");
File f4 = new File(d,"d.txt");
//输出的是路径。
sop("f1="+f1);
sop("f2="+f2);
sop("f3="+f3);
sop("f4="+f4);

}
public static void sop(Object obj)
{
System.out.println(obj);
}
}

（二）创建文件

import java.io.*;
class FileDemo1
{
public static void main(String[] args) throws IOException
{
method_1();
method_2();
}

public static void method_1()throws IOException
{

File f = new File("a.txt");
sop("create:"+f.createNewFile());//创建。
//sop("delete:"+f.delete());//删除，返回true ，删除成功

//创建文件夹
File dir = new File("abc");//在当前目录下，创建abc文件夹。
sop("mkdir:"+dir.mkdir())//mkdir只能创建一级目录。

}

public static void method_2()
{
File f = new File("a.txt");
sop("exists:"+f.exists());
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}

（三）列出文件夹中的内容

/*
列出指定目录下文件或者文件夹，包含子目录中的内容。
也就是列出指定目录下所有内容。

因为目录中还有目录，只要使用同一个列出目录功能的函数完成即可。
在列出过程中出现的还是目录的话，还可以再次调用本功能。
也就是函数自身调用自身。递归。

递归要注意：
1.限定条件
2.要注意递归的次数，尽量避免内存溢出。
*/
import java.io.*;
class  FileDemo2
{
public static void main(String[] args)
{
File dir = new File("d:\\java0515");
showDir(dir);
}
public static void showDir(File dir)
{
System.out.println(dir);
File[] files = dir.listFiles();
for (int i = 0;i < files.length ; i++ )
{
if (files[i].isDirectory())
showDir(files[i]);
else
System.out.println(files[i]);
}
}
}

import java.io.*;
class  FileDemo3
{
public static void main(String[] args)
{
File dir = new File("d:\\java0515");

showDir(dir,0);
}

public static String getLevel(int level)
{
StringBuilder sb = new StringBuilder();
sb.append("|--");
for (int i = 0;i < level ;i++ )
{
sb.insert(0," ");
}
return sb.toString();
}

public static void showDir(File dir,int level)
{
System.out.println(dir);
File[] files = dir.listFiles();
level++;

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

（四）删除

/*
删除一个带内容的目录。

删除原理：
在windows中，删除目录从里面往外删。
这就要用到递归。
*/

import java.io.*;
class  RemoveDir
{
public static void main(String[] args)
{
File dir = new File("d:\\360Downloads");
removeDir(dir);
}

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

/*for(File s : files)
{
if(s.isDirectory())
removeDir(s);
else
System.out.println(s.toString()+"--File--"+s.delete());
}*/
for ( int i = 0; i < files.length ; i++ )
{
if(files[i].isDirectory())
removeDir(files[i]);
else
System.out.println(files[i].toString()+"--File--"+files[i].delete());

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

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

字节打印流：

PrintStream

构造函数可以接收的参数类型：

1，file对象。File

2，字符串路径。String

3，字节输出流。OutputStream

字符打印流：

PrintWriter

构造函数可以接收的参数类型：

1，file对象。File

2，字符串路径。String

3，字节输出流。OutputStream

4，字符输出流，Writer。

打印流有自己的PrintWriter.println();等方法。

把标准输入流写到文件中

/*
PrintStream
构造函数可以接受的参数类型：
1.file对象。file
2.字符串路径。String
3.字节输出流。OutputStream

字符打印流：
pringtWriter
构造函数可以接受的参数类型：
1.file对象。file
2.字符串路径。String
3.字节输出流。OutputStream
4.字符输出流 Writer
该流提供了打印方法，可以将各种数据
*/
import java.io.*;

class  PrintDemo
{
public static void main(String[] args) throws IOException
{
BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
PrintWriter out = new PrintWriter(new FileWriter("b.txt"),true);

String line = null;

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

}

三、Properties是hashtable的子类。

也就是说它具备map集合的特点。而且它里面存储的键值对都是字符串。

是集合中和IO技术相结合的集合容器。

该对象的特点：可以用于键值对形式的配置文件。

那么在加载数据时，需要数据有固定格式：键=值。

常用方法：

Object setProperty(String key,String value):

调用Hashtable的put方法，设置键值对

String getProperty(String key):

Set<String> stringPropertyNames:

获取集合中所有的键

void load(InputStream in):

从输入流中读取属性列表（键和元素对）。

void load(Reader reader):

按简单的面向行的格式从输入字符流中读取属性列表（键和元素对）。

void list(PrintStream out)

将属性列表输出到指定的输出流。

voidlist(PrintWriter out)

将属性列表输出到指定的输出流。

Store(OutputStream out,String comments):

Store(Writer writer,String comments)

Properties不仅可以操作键值对，而且可以操作硬盘上的键值对信息。而集合只能操作内存中的数据。

/*
Properties是hashtable的子类。
也就是说它具备map集合的特点。而且它里面存储的键值对都是字符串。
是集合中的IO技术相结合的集合容器。
该对象的特点：可以用于键值对形式的配置文件。
*/

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

class PropertiesDemo
{
public static void main(String[] args) throws IOException
{
//setAndGet();
method_1();
System.out.println("over");
}

//演示，如何将流中的数据存储到集合中。
// 想要将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)
{
System.out.println(line);
String[] arr = line.split("=");
System.out.println(arr[0]+"...."+arr[1]);
prop.setProperty(arr[0],arr[1]);

}
bufr.close();
System.out.println(prop);
}

//设置和获取元素
public static void setAndGet()
{
Properties prop = new Properties();

prop.setProperty("zhangsan","30");
prop.setProperty("lisi","40");

System.out.println(prop);

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

四、合并流
SequenceInputStream是能对多个流进行合并成一个读取流，它在构造时需要传入Enumeration，而这个只用Vector中有，所以这个多个读取流要加入Vector集合中。

注意：它只是对读取流进行合并。

它使用步骤：

1.创建Vector<InputStream>

2.将要合并的InputStream加入Vector

3.通过Vector获取Enumeration

4.创建SequenceInputStream，将Enumeration作为参数传入。

五、管道流

RandomAccessFile

随即访问文件，自身具备读写的方法。

通过skipBytes（int x），seek（int x）来达到随机访问。

管道流：

PipedInputStream和PipeOutputStream

RandowAccessFile

随机访问文件，自身具备读写的方法。

通过skipBytes(int x),seek(int x)来达到随机访问。

该类不算是IO体系中的子类。而是直接继承自Object。

但是他是IO包中成员。因为他具备读和写功能。

内部封装了一个数组，而是通过指针对数组的元素进行操作。

可以通过getFilePointer获取指针位置。

同时可以通过seek改变指针的位置。

其实完成读写的原理就是内部封装了字节输入流和输出流。

通过构造函数可以看出，该类只能操作文件。

而且操作文件还有模式：

import java.io.*;
class Read implements Runnable
{
//定义输入管道
private PipedInputStream in;
Read(PipedInputStream in)
{
this.in = in;
}
public void run()
{
try
{
byte[] buf = new byte[1024];//定义一个数组。
System.out.println("读取前没有数据.......堵塞");
int len = in.read(buf);//调用read方法。
System.out.println("读取数据.......堵塞结束");
String s = new String(buf,0,len);
System.out.println(s);
in.close();
}
catch (IOException e)
{
throw new RuntimeException("管道流读取失败");
}
}
}
class Write implements Runnable
{
//定义输出管道。
private PipedOutputStream out;
Write(PipedOutputStream out)
{
this.out = out;
}
public void run()
{
try
{
System.out.println("开始写入数据.......等待");
Thread.sleep(6000);
out.write("piped lai la".getBytes());
out.close();
}
catch (Exception e)
{
throw new RuntimeException("管道输出流失败");
}
}
}
class PipedStreamDemo
{
public static void main(String[] args) throws IOException
{
PipedInputStream in = new PipedInputStream();
PipedOutputStream out = new PipedOutputStream();
in.connect(out);//读取流和输入流连接

Read r = new Read(in);
Write w = new Write(out);
//创建线程。
new Thread(r).start();
new Thread(w).start();
}
}

练习：

/*
用于记录应用程序运行次数。
如果使用次数已到，那么给出注册提示。
很容易想到的是：计数器。
可是还计数器定义在程序中，随着程序的运行而在内存中存在。并进行自增。
可是随着该应用程序的退出。该计数器也在内存中消失了。

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

想要程序即使结束，该计数器的值也存在。
下次程序启动在会先加载该计数器的值并加1后再重新存储起来。

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

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

键值对数据是map集合。
数据是以文件形式存储，使用io技术。
那么map+io-->porperties。
配置文件可以实现应用程序数据的共享。
*/

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();

}
}

---------------------- ASP.Net+Android+IO开发S、.Net培训、期待与您交流！ ----------------------