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

不倒的青春

于 2013-06-21 17:43:04 发布

阅读量1k

点赞数

本文链接：https://blog.csdn.net/u010710575/article/details/9147187

版权

---------------------- 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培训、期待与您交流！ ----------------------