关闭

java基础之 IO系统

标签: java对象技术博客黑马程序员
306人阅读 评论(0) 收藏 举报
分类:


第一讲、IO流概述基本知识
IO流:
用来处理设备之间数据传输,java中对数据的操作是通过流进行的,java用于操作流的对象都在IO包中,
流按操作可以分为两种:字节流和字符流。按流向分:输入流和输出流。
IO流常用基类:
字节流抽象基类: InputSteam  OutputStream
字符流抽象基类: Reader Writer
这四个类派生的子类的名字都是以其父类名字为子类的后缀。例如:
InputStream的子类:FileInputStream   Reader的子类:FileReader
字符流:
以一个文本文件操作为例,通过API查找,找到了用于操作文件的Writer子类对象FileWriter.
创建一个FileWriter对象,该对象一被初始化就必须要明确被操作的文件,而且该文件会被创建在制动目录下。
如果已有同名文件将被覆盖。
flush和close的区别:flush刷新后流还可以继续使用,但是close刷新以后就关闭了流。

实例代码:

import java.io.*;
class FileWriterDemo 
{
	public static void main(String[] args) throws IOException
	{
		//创建对象。
		FileWriter fw=new FileWriter("demo.txt");
		//调用write方法,将字符串写入到流中
		fw.write("asdfasfds");
		//刷新流对象中的缓冲数据。
		//将数据刷到目的地中
		//fw.flush();
		//关闭此数据流但是先要刷新一次
		fw.close();
	}
}
IO异常的处理方式:
因为IO要操作的是磁盘的文件,所以一定会产生异常,需要try——catch语句。
FileWriter fw = null;语句在外面建立引用,在try内初始化,这样fw就可以作用
整个函数。关闭资源要写在finally语句中,但是如果不加try语句,则会抛出IOException
异常,如果指定的文件路径不存在,fw对象就不会创建,此时fw=null;在调用close
方法时就会报空指针异常。

import java.io.*;
/*IO的异常处理方式*/
class FileWriterDemo2 {
	public static void main(String[] args) {
		//外部创建引用,fw可以作用于整个函数
		FileWriter fw=null;
		try{
			fw=new FileWriter("demo.txt");
			fw.write("asdfasgghadfsd");
		}
		catch (IOException e){
			System.out.println(e.toString());
		}
		finally{
			try{//解决空指针异常
				if(fw!=null)
				fw.close();
			}
			catch (IOException e){
				System.out.println(e.toString());
			}			
		}
	}
}
对已有文件数据进行续写:
在API中找到FileWriter(String fileName, boolean append) 方法,根据给定的文件名
以及指示是否附加写入数据的 boolean 值来构造 FileWriter 对象。
如果为 true,则将数据写入文件末尾处,而不是写入文件开始处。 
抛出异常IOException:
如果指定文件存在,但它是一个目录,而不是一个常规文件;或者该文件不存在,但无法创建它;
抑或因为其他某些原因而无法打开它 
实例代码:

import java.io.*;
//对已有文件的数据续写,
class FileWriterDemo3{
	public static void main(String[] args) {
		//外部创建引用
		FileWriter fw=null;
		try{
			//传递一个true参数,代表不覆盖已有文件并
			//在以有文件末尾处进行续写			
			fw=new FileWriter("demo.txt",true);
			//换行,
			fw.write("\r\n45454545");
		}
		catch (IOException e){
			System.out.println(e.toString());
		}
		finally{
			try{
				if(fw!=null)
				fw.close();
			}
			catch (IOException e){
				System.out.println(e.toString());
			}			
		}
	}
}
字符文件读取:FileReader,需要先关联一个已经存在的文件,如果不存在发生异常,FileNotFoundException
FileReader下面也有close方法,但是该方法不刷新,此外还有读一个和读数组的方法read,该方法可以自动往下读,
读到末尾就返回-1,因此可以用-1作为循环读取结束的标志。此外read方法还可以以数组方式读取,
实例代码:
1.单个字符读取

import java.io.*;
class  FileReaderDemo{
	public static void main(String[] args) {
		//外部创建引用,可以作用于整个函数
		FileReader fr=null;
		try{//创建一个文件读取流对象,和指定名称文件关联保证该文件是存在的,如果不存在发生异常,
			fr=new FileReader("demo.txt");			
			int ch=0;
			//读到最后如果没有则返回-1
			while((ch=fr.read())!=-1){
				System.out.println((char)ch);
			}
		}
		catch (IOException e){
			System.out.println(e.toString());
		}
		finally{
			try{
				fr.close();
			}
			catch (IOException e){
				System.out.println(e.toString());
			}			
		}
	}
}
2.以数组方式读取:

/*第二种读取方式:通过字符数组进行读取。
read(char[] cbuf, int offset, int length) 
将字符读入数组中的某一部分。*/
import java.io.*;
class  FileReaderDemo2{
	public static void main(String[] args) {
		FileReader fr=null;
		//定义一个数组,用于存储读取到的字符。
		//该read(char[])返回的是读到字符个数。
		char[] buf=new char[6];		
		try{
			if(fr!=null)
			System.out.println(new String(buf));
		}
		catch (FileNotFoundException e){
			System.out.println(e.toString());
		}
		finally{
			try{
				if(fr!=null)
				fr.close();
			}
			catch (IOException e){
				System.out.println(e.toString());
			}
		}
	}
}
复制文件:其实就是将C盘下的文件数据存储到D盘的一个文件中 
步骤:
1.在D盘创建一个文件用于存储C盘文件中的数据。
2.定义读取流和C盘文件关联。
3.通过不断的读写完成数据存储。
4.关闭资源。
代码实例:

package IOSystem;
import java.io.*;
public class CopyTextDemo {
	public static void main(String[] args) {
		Copy();
	}
private static void Copy() {
	FileReader fr = null;
	FileWriter fw = null;
	try {
		//源和目的
		fr = new FileReader("SystemDemo.txt");
		fw = new FileWriter("F:\\C#Data\\come.txt");
		//缓冲区
		char[] buf = new char[1024];
		int len = 0;
		//循环读写,直到返回—1
		while((len = fr.read(buf))!=-1){
			fw.write(buf,0,len);
		}
	} catch (Exception e) {
		// TODO: handle exception
		throw new RuntimeException("读写失败");
	}
	finally{
		if(fr!=null)
		try {
				fr.close();
		} catch (Exception e2) {
			System.out.print(e2.toString());
		}
		if(fw!=null)
			try {
				fw.close();
			} catch (Exception e2) {
				System.out.print(e2.toString());
			}
		}
	}
}
第二讲 缓冲区读写及其他
字符流缓冲区:提高了对数据的读写效率,对应类BufferedReader和BufferedWriter,缓冲区
要结合流才可以使用,在流的基础上对流的功能进行了增强。
注意:只要用到缓冲技术就要对缓冲区进行刷新操作。关闭缓冲区就是关闭缓冲区流对象。
缓冲区提供了一个跨平台换行方法:newLine();
下面通过缓冲区技术演示字符流和字节流读写的两个综合实例。
字符流缓冲区读写实例代码:

/*通过缓冲区复制一个。Java文件*/
import java.io.*;
class  CpTextBuf{
	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("BufferedTextCp.txt"));
			String line=null;
			//整行读取,直到返回null则读到末尾
			while((line=bufr.readLine())!=null){
				bufw.write(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("写关闭失败");
			}
		}
	}
}
字节流缓冲区读取:使用字节流操作对象的FilterInputStream的子类BufferedInputStream和
FilterOutputStream的子类BufferedOutputStream
下面以复制一个磁盘的MP3文件为例
代码:

import java.io.*;
class  CopyMp3{
	public static void main(String[] args) throws IOException{
		//统计代码运行时间
		long start=System.currentTimeMillis();
		copy_1();
		long end=System.currentTimeMillis();
		System.out.println((end-start)+"毫秒");
	}
	//通过字节流的缓冲区完成复制
	public static void copy_1()throws IOException{
		//关联源和目的
		BufferedInputStream bufis=new BufferedInputStream(new FileInputStream("f:\\1.mp3"));
		BufferedOutputStream bufos=new BufferedOutputStream(new FileOutputStream("e:\\紫金花园.mp3"));
		int by=0;
		//-1为结束循环标志
		while((by=bufis.read())!=-1){
			bufos.write(by);
		}
		bufos.close();
	}
}
readLine原理:无论读一行还是读多个,最终都是从磁盘中一个一个的读取,也就是read方法,只不过是把
回车符号前面读到的数据临时存储一下,所以效率稍高。
装饰设计模式:
当想要对已有的对象进行功能增强时,可以定义一个类将已有对象传入,基于已有对象的功能
并提供加强功能,那么自定义的该类就称为装饰类。
装饰类通常会通过构造方法接收被装饰的对象,并基于被装饰的对象提供更强大功能。
装饰类避免了继承体系的臃肿,与被装饰类属于同一个体系中,
例如BufferedReader和readLine,代码实例:

package IOSystem;
public class ZhuangShiLeiDemo {
	public static void main(String[] args) {
		SuperPerson sp = new SuperPerson();
		sp.Superchifan();
	}
}
class Person{
	public void chifan(){
		System.out.println("吃饭");
	}
}
//装饰类
class SuperPerson{
	private Person p;
	//装饰吃饭这个功能
	SuperPerson(){
		this.p=p;
	}
	public void Superchifan(){
		System.out.println("开胃酒");
		System.out.println("吃饭");
		System.out.println("甜点");
		System.out.println("散步");
	}
}
使用LineNumberReader方法读取一个文本文件打印在控制台,并带行号。

代码:

package IOSystem;
import java.io.*;
public class LineNumberReaderDemo {
/*
 * 获取一个文件中的内容并打印在控制台带行号。
 * */
	public static void main(String[] args) {
		FileReader fr = null;
		LineNumberReader lnr = null;
		try {
			//关联文件
			fr = new FileReader("D:\\java0217\\day19\\CopyPic.java");
			lnr = new LineNumberReader(fr);
			String line = null;
			//设置行号从100开始
			lnr.setLineNumber(100);
			while((line = lnr.readLine())!= null){
				System.out.println(lnr.getLineNumber()+": "+line);
			}
		} catch (Exception e) {
			// TODO: handle exception
			throw new RuntimeException("读写失败");
		}
		finally{
			if(fr != null)
				try {
					lnr.close();					
				} catch (Exception e2) {
					// TODO: handle exception
					throw new RuntimeException("关闭失败");
				}
		}
	}

}
实例演示写文本文件和三种读文件方法,其中定义缓存数组的方法有byte[]buf=new byte[fis.available()];
同时字节流中有一个特有的方法,byte[]buf=new byte[fis.available()];创建一个刚刚好的数组,不用循环
但是操作的数据大小受限,所以一般还是使用1024整数倍创建数组。
代码:

import java.io.*;
class  FileStream{
	public static void main(String[] args) throws IOException{
		readFile_3();
		//readFile_2();
		//readFile_1();
		//writeFile();
	}	
	public static void readFile_3()throws IOException{
		FileInputStream fis=new FileInputStream("fos.txt");
		//定义一个刚刚好的缓冲区,但是数据过大可能会出现溢出
		//字节流特有方法。
		byte[]buf=new byte[fis.available()];
		//直接装入到数组,不循环。
		fis.read(buf);
		System.out.println(new String(buf));
		fis.close();
	}
	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",true);
		//写字符到已关联的文件对象(以默认编码方式)
		fos.write("abcde".getBytes());
		fos.close();
	}
}
通过键盘录入一行数据并大写类似于读一行数据原理也就是
readLine方法
readLine方法是字符流BufferedReader类中的方法
而键盘录入的read方法时字节流InputStream的方法
能不能将字节流转换成字符流再使用字符缓冲区的readLine
方法呢?
此时我们可以用InputStreamReaer将字节流转换成字符流并使用readLine方法录入,
同时使用OutputStreamWriter将输出字节流转成字符流进行行输出,下面通过实例
来体现。
代码:整行读取一个文本文件内容,并进行大写转换后在控制台输出。

import java.io.*;
class  TransStreamDemo2{
	public static void main(String[] args) throws IOException{
		/*//获取键盘录入对象
		InputStream in=System.in;
		//将字节流对象转换成字符流对象,使用InputStreamReader
		InputStreamReader isr=new InputStreamReader(in);
 
		//为了提高效率,将字符串进行缓冲区技术高效操作使用
		//BufferedReader
		BufferedReader bufr=new BufferedReader(isr);*/		
		//键盘录入一行,最常见写法
		BufferedReader bufr=
			new BufferedReader(new InputStreamReader(new FileInputStream("out.txt")));	
		/*OutputStream out=System.out;
		OutputStreamWriter osw=new OutputStreamWriter(out);
		BufferedWriter bufw=new BufferedWriter(osw);*/
		//键盘输出一行,最常见写法
		BufferedWriter bufw=
			new BufferedWriter(new OutputStreamWriter(System.out));
		String line=null;
		while((line=bufr.readLine())!=null){
			if("over".equals(line))
				break;
			bufw.write(line.toUpperCase());
			bufw.newLine();//换行,跨平台性。
			bufw.flush();
		}
		bufr.close();
	}
}
IO流操作规律总结:
流操作基本规律:
两个明确:
1.源和目的。
源:输入流。InputStream Reader
目的:输出流.OutputStream Writer
2.操作的数据是否是纯文本。
是:字符流 Reader Writer
不是:字节流 InputStream OutputStream
3.当体系明确后再明确要使用那个具体的对象。
通过设备来进行区分:
源设备:内存,硬盘,键盘
目的设备:内存,硬盘,控制台
例如.将一个文本文件内容存储到另一个文件  复制
源:因为是源所以选用读取流 。InputStream Reader
是不是操作文本文件
是:选择Reader
接下来明确要使用体系中那个对象。
明确设备:硬盘文件。
Reader体系中可以操作文件的对象时FileReader
是否需要提高效率:是:加入Reader体系中缓冲区BufferedReader.
FileReader fr=new FileReader("a.txt");
BufferedReader bufr=new BufferedReader(fr);
目的:OutputStream Writer
是否纯文本。
是:Writer
设备:硬盘文件。
Writer体系中可以操作文件的对象FileWriter
如果提高效率则加入缓冲区;BufferedWriter
扩展:想要把录入的数据按照指定的编码表(utf-8),将数据存入到文件中。
目的:OuputStream Writer
是否是纯文本:是 Writer
设备:硬盘,一个文件。使用FileWriter
但是FileWriter使用的是默认的GBK编码。
但是存储时要指定(utf-8)编码,而只有转换流才可以指定编码表。
所以要使用的对象是OutputStreamWriter。
而该转换流对象要接收一个字节输出流,而且还是可以操作文件输出字节数出流 :FileOutputStream
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("c:\\hello.java"),"UTF-8");
//需要缓冲的话:
BufferedWriter bufw = new BufferedWriter(osw);
/*转换流什么时候用:字节和字符之间的桥梁,当需要字符编码转换时,需要用到转换流*/
下面代码实例:

class  TransStreamDemo2{
	public static void main(String[] args) throws IOException{		
		//键盘录入一行,最常见写法
		BufferedReader bufr=
			new BufferedReader(new InputStreamReader(System.in));		
		//键盘输出一行,最常见写法
		BufferedWriter bufw=
			new BufferedWriter(new OutputStreamWriter(new FileOutputStream("out.txt"),"UTF-8"));
		//BufferedWriter bufw=
			//new BufferedWriter(new OutputStreamWriter(new FileOutputStream("out.txt"),"GBK"));
		String line=null;
		while((line=bufr.readLine())!=null){
			if("over".equals(line))
				break;
			bufw.write(line.toUpperCase());
			bufw.newLine();
			bufw.flush();
		}
		bufr.close();
	}
}
日志文件:用于在程序运行时,将程序产生的异常信息保存到一个异常信息文件中,以便于开发者日后查看
解决问题。
示例代码:

import java.io.*;
import java.util.*;
import java.text.*;
class  ExceptionInfo{
	public static void main(String[] args) throws IOException{
		try{
			//自己搞一个角标越界
			int [] arr=new int[2];
			System.out.println(arr[3]);
		}
		catch (Exception e){
			try{
				Date d=new Date();
				//定义时间格式
				SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");			
				String s=sdf.format(d);
				//创建日志文件
				PrintStream ps=new PrintStream("exception.log");
				//现将日期信息写入到日志文件。
				ps.println(s);
				//设置标准输出改为文件对象,
				System.setOut(ps);			
			}
			catch (IOException ex){
				throw new RuntimeException("日志文件创建失败");
			}//如果日志文件创建成功就将异常信息输出到标准输出,(已改为文件对象)
			e.printStackTrace(System.out);
		}
	}
}
第三讲、File类
File类:用来将文件或者文件夹封装成对象。
方便对文件或者文件夹的属性信息进行操作。
File对象可以作为参数传递给流的构造函数。
创建对象方法
File f1=new File("a.txt");
File f2=new File("e:\\abc","b.txt");
File d=new File("e:\\ABD");
File f3=new File(d,"c.txt");
File f4=new File("c:"+File.separator+"abc"+File.separator+"zzz"+File.separator+"d.txt");
separator方法表示用来跨平台的分隔符。
下面介绍了File类的常用方法:
File f1=new File("e:"+File.separator+"a.txt");
//创建文件
sop("creat: "+f1.createNewFile());
//删除文件成功为true,否则false
sop("delete:"+"e:\\a.txt"+f1.delete());
//JVM退出时删除文件,一般用于删除临时性的文件。
f1.deleteOnExit();
//判断文件是否存在
boolean f1.exists() 
          测试此抽象路径名表示的文件或目录是否存在。 存在返回true
//创建文件夹当且仅当已创建目录时,返回 true;否则返回 false 
File dir = new File("e:\\javaData");
sop("mkdir:"+dir.mkdir());
//创建多级目录mkdirs,用法与mkdir类似
isDirectory();isFile()在判断之前必须判断该文件对象是否存在,通过exists()
获取信息:getPath() getName(); lastModified(); 
getParent();该方法返回的是绝对路径中的父目录。如果获取的是相对路径返回null
如果存在上一层目录,则返回该目录。
list();方法。public String[] list()返回一个字符串数组,这些字符串指定此抽象路径名
表示的目录中的文件和目录。指定的文件对象必须是一个目录,而且该目录还必须存在。 
list public String[] list(FilenameFilter filter),文件过滤。
文件过滤代码实例:

import java.io.*;
class FileDemo02 {
	public static void main(String[] args) {
		listDemo_2();
	}
	public static void listDemo_2(){
		//指定一个目录
		File dir=new File("d:\\java0217\\day18");
		//文件过滤器使用   记住喽!!!
		String [] arr=dir.list(new FilenameFilter()
			{
			public boolean accept(File dir,String name)
				{
					return name.endsWith(".bak");
				}
			});
		System.out.println("len:"+arr.length);
		for(String name:arr){//打印.bak文件名
			System.out.println(name);
		}
	}
}
列出指定目录下的所有文件以及文件夹名称。
递归调用要注意:1.限定条件。 2.注意次数,尽量避免内存溢出
示例代码:

package IOSystem;
import java.io.*;
public class FileListDemo {
/*列出制定目录下文件或者文件夹。包含子目录中内容
也就是流出指定目录下所有内容*/
	public static void main(String[] args) {
		File dir = new File("d:\\java0217");
		showDir(dir,0);
	}
	private 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 String getLevel(int level)
	{
		StringBuilder sb = new StringBuilder();
		for(int x=0;x<level;x++)
		{
			sb.append("  ");
		}
		return sb.toString();
	}
}
列出一个指定路径下的所有的.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:\\java0217");
		//定义一个File类型的list集合
		List<File> list=new ArrayList<File>();
		//将指定目录下的文件名存入到集合中
		fileToList(dir,list);
		//指定一个文件。目的
		File file=new File(dir,"javalist.txt");
		//将集合中的文件名信息写入到指定的文件
		writeToFile(list,file.toString());
		//打印该集合的长度
		System.out.println(list.size());
	}
	public static void fileToList(File dir,List<File> list)
		{//需要传入目录和集合,因为要递归所以最好是在外部建立集合传入
		//获取路径下的所有文件对象,存入到File类型的数组中
		File[] files = dir.listFiles();
		//遍历数组
		for(File file : files)
		{//如果是目录就递归
			if(file.isDirectory())
				fileToList(file,list);
			else
			{//如果不是目录则获取以.java为扩展名的文件并存入到list集合
				if(file.getName().endsWith(".java"))
					list.add(file);
			}
		}
	}
	public static void writeToFile(List<File>list,String javaListFile)throws IOException
	{//该方法需要传入一个File类型的集合和一个文件目的
		BufferedWriter bufw=null;
		try
		{//关联传入的文件目的
			bufw=new BufferedWriter(new FileWriter(javaListFile));
			for(File f:list)//遍历这个File类型的集合
			{//获取每个.java为扩展名的文件的绝对路径
				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类:主要用于读取Java的配置文件,它是用来在一个文件中存储键-值对的,
它提供了几个主要的方法:
1. getProperty ( String key),用指定的键在此属性列表中搜索属性。也就是通过参数 key ,得到 key 所对应的 value。
2. load ( InputStream inStream),从输入流中读取属性列表(键和元素对)。通过对指定的文件(比如说上面的
test.properties 文件)进行装载来获取该文件中的所有键 - 值对。以供 getProperty ( String key) 来搜索。
3. setProperty ( String key, String value) ,调用 Hashtable 的方法 put 。他通过调用基类的put方法来设置
键 - 值对。
4. store ( OutputStream out, String comments),以适合使用 load 方法加载到 Properties 表中的格式,
将此 Properties 表中的属性列表(键和元素对)写入输出流。与 load 方法相反,该方法将键 - 值对写
入到指定的文件中去。
5. clear (),清除所有装载的 键 - 值对。该方法在基类中提供。
代码实例:

import java.io.*;
import java.util.*;
class  PropertiesDemo{
	public static void main(String[] args) throws IOException{
		loadDemo();
	}
	public static void loadDemo()throws IOException
	{//创建一个Properties类对象
		Properties prop=new Properties();
		//将配置文件关联输入流
		FileInputStream fis=new FileInputStream("info.txt");
		//将流中数据加载进集合
		prop.load(fis);
		//设置键值对
		prop.setProperty("wangwu",60+"");
		//将配置文件关联输出流
		FileOutputStream fos=new FileOutputStream("info.txt");
		//存储修改后的信息
		prop.store(fos,"repair wangwu age");
		//在控制台输出引用其list方法。
		prop.list(System.out);
		fos.close();
		fis.close();
	}
}
配置文件创建使用实例。限定程序运行次数。
代码:

package IOSystem;
//建立一个配置文件,用于记录该软件使用次数,
//这样便于阅读暑促并操作数据
import java.io.*;
import java.util.*;
public 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 ;
			}
		}//如果运行次数不大于或等于5,就将键值对存入到配置文件
		count++;
		prop.setProperty("time",count+"");
		FileOutputStream fos = new FileOutputStream(file);
		prop.store(fos,"");
		fos.close();
		fis.close();
	}
}
第四讲、其他流

打印流:
该流提供了打印方法。可以将各种数据类型的数据都原样打印。
字节打印流:
PrintStream
构造函数可以接受的参数类型:
1.file对象。File(可以直接操作文件)
2.字符串路径,String
3.字节输出流。OutputStream
字符打印流:
PrintWriter
1.file对象。File
2.字符串路径,String
3.字节输出流。OutputStream
4.字符输出流。Writer.
PrintWriter代码例子:

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(流,true);
		//将键盘录入字符自动刷新到文件中
		PrintWriter out=new PrintWriter(new FileWriter("abc.txt"),true);
		String line=null;
		while((line=bufr.readLine())!=null){
			if("over".equals(line))
				break;
			out.println(line.toUpperCase());
		}
		out.close();
		bufr.close();
	}
}
合并流:SequenceInputStream将多个流合并成一个流
切割流:SplitFile
下面是切割和合并实例:

import java.io.*;
import java.util.*;
class SplitFile {
	public static void main(String[] args) throws IOException{
		merge();
	}
	//合并************************//
	public static void merge()throws IOException{
		//创建流对象并导入源文件
		ArrayList<FileInputStream> al=new ArrayList<FileInputStream>();
		for(int x=1;x<=4;x++){
			al.add(new FileInputStream("e:\\SplitFiles\\"+x+".part"));
		}
		//对返回的局部变量进行final修饰
		final Iterator<FileInputStream> it = al.iterator();
		//匿名内部类 对返回的局部变量进行final修饰
		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("e:\\zijinhuayuan.mp3");
		byte[] buf=new byte[1024*1024*5];
		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("e:\\紫金花园.mp3");
		FileOutputStream fos=null;
		byte[] buf=new byte[1024*1024*3];
		int len=0;
		int count=1;
		while((len=fis.read(buf))!=-1){//指定路径和名字
			fos=new FileOutputStream("e:\\SplitFiles\\"+(count++)+".part");
			fos.write(buf,0,len);
			fos.close();
		}
		fis.close();
	}
}
管道流:PipeInputStream  PipedOutputStream下面的例子演示了管道流读取的方法。

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);//返回的是字节数组的长度
			String s=new String(buf,0,len);
			System.out.println(s);
			System.out.println("读到数据,阻塞结束******");
			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 comming".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();
	}
}
RandomAccessFile随即访问文件类
该类不是io体系中的子类
而是直接继承的Object。
但是他是io包成员,因为具有读写功能。
内部封装了一个数组,而且通过指针对数组元素进行操作,
可以通过getFilePointer获取指针位置,
同时可以通过seek改变指针位置,
其实完成读写的原理是:内部封装了字节输入和输出流。
通过构造函数可以看出,该类只能操作文件。
该类中常用方法有:
getFilePointer() 返回此文件中的当前偏移量。 
length() 返回此文件的长度。 
int read() 读取一个数据字节和读取一个字节数组。
char readChar() 从此文件读取一个字符。 
int readInt() 读取int型数据         
String readLine() 读取一行
void writeInt(int v) 写入int型数据。
代码演示:

import java.io.*;
class  RandomAccessFileDemo{
	public static void main(String[] args) throws IOException{
		//writeFile();
		readFile();
	}
	public static void readFile()throws IOException{
		//关联随机读取文件,指定为只读。
		RandomAccessFile raf=new RandomAccessFile("ran.txt","r");
		raf.skipBytes(8);//跳过八个字节
		byte[] buf=new byte[4];
		raf.read(buf);//先读到缓存中
		String name=new String(buf);
		int age=raf.readInt();	
		System.out.println("name="+name);
		System.out.println("age="+age);
		raf.close();
	}//将信息写入一个文件中,
	public static void writeFile()throws IOException{
		RandomAccessFile raf=new RandomAccessFile("ran.txt","rw");
		raf.write("李四".getBytes());
		raf.writeInt(97);
		raf.write("王五".getBytes());
		raf.writeInt(96);
		raf.close();
	}
}
字符编码:
编码:字符串变成字符数组。 
解码:字符数组变成字符串。
代码实现编码和解码的过程:

import java.util.*;
class  EncodeDemo{
	public static void main(String[] args)throws Exception {
		String s="你好";
		//用GBK编码
		byte[] b1=s.getBytes("GBK");
		System.out.println(Arrays.toString(b1));
		//这里演示使用ISO8859-1解码,出现乱码
		String s1=new String(b1,"ISO8859-1");
		System.out.println("s1="+s1);
		//再次进行ISO8859-1编码并输出编码结果
		byte[] b2=s1.getBytes("ISO8859-1");
		System.out.println(Arrays.toString(b2));
		//通过GBK解码
		String s2=new String(b2,"GBK");
		System.out.println("s2="+s2);
	}
}


0
0

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