黑马程序员_IO流(一)

最新推荐文章于 2015-09-19 21:16:06 发布

精神病人精神好

最新推荐文章于 2015-09-19 21:16:06 发布

阅读量339

点赞数

本文链接：https://blog.csdn.net/kiss072403/article/details/21514327

版权

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

IO流(概述)

字节流抽象基类：InputStream OutputStream

字符流抽象基类：Reader Writer

IO流(FileWriter)

FileWriter：操作文件，写入。后缀名：父类名，前缀名：功能

public class FileWriterDemo {

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

		//创建一个FileWriter对象，该对象一被初始化就必须要明确被操作的文件
		//该文件会被创建到指定目录下，如果该目录下已有同名文件，将被覆盖
		//该步就是在明确数据要存放的目的地
		FileWriter fw = new FileWriter("demo.txt");
		
		//调用writer方法，将字符串写到流中
		fw.write("gg");
		
		//刷新流对象中缓存中的数据，将数据刷新到目的地中
		fw.flush();
		
		//关闭流资源，关闭前会刷新一次，刷新后流会关闭，不能继续使用。
		fw.close();
	}
}

IO流(IO异常处理方式)

public class FileWriterDemo2 {

	public static void main(String[] args) {

		FileWriter fw = null;
		try
		{
			fw = new FileWriter("demo.txt");
			fw.write("abcde");
		}
		catch(IOException e)
		{
			System.out.println(e.toString());
		}
		finally
		{
			try
			{
				if(fw!=null)
					fw.close();
			}
			catch(IOException e)
			{
				System.out.println(e.toString());
			}
		}
	}
}

IO流(文件的续写)

public class FileWriterDemo3 {

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

		//传递一个true参数，代表不覆盖已有的文件，并在文件末尾出续写
		FileWriter fw = new FileWriter("Demo.txt",true);
		
		fw.write("hello\r\nhi");
		
		fw.close();
	}
}

IO流(文本文件读取方式一)

public class FileReaderDemo {

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

		//创建一个文件读取流对象，和指定名称的文件相关联
		//要保证该文件是已经存在的，如果不存在，会发生异常 FileNotFoundException
		FileReader fr = new FileReader("Demo.txt");
		
		//调用读取流对象的read方法
		//read() ： 一次读一个字符，而且自动往下读。
		
		int ch = 0;
		while((ch=fr.read())!=-1)
		{
			System.out.print((char)ch);
		}
		/*
		while(true)
		{
			int ch = fr.read();
			if(ch==-1)
				break;
			System.out.print((char)ch);
		}
		*/
	}
}

IO流(文本文件读取方式二)

public class FileReaderDemo2 {

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

		FileReader fr = new FileReader("Demo.txt");
		
		//定义一个字符数组，用于存储读到的字符
		//该read(char[])返回的是读到的字符个数
		char[] buf = new char[1024];
		int num = 0;
		while((num=fr.read(buf))!=-1)
		{
			System.out.println(new String(buf,0,num));
		}
		fr.close();
	}
}

IO流(文本文件读取练习)

//读取一个.java文件并打印

public class FileReaderTest {

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

		FileReader fr = new FileReader("Test.java");
			
		char[] buf = new char[1024];
		int num = 0;
			
		while((num=fr.read(buf))!=-1)
		{
			System.out.print(new String(buf,0,num));
		}
		
		fr.close();
	}
}

IO流(拷贝文本文件)

/*
复制一个文本文件

复制原理：
就是将一个文件数据存储到另一个文件中

步骤：
1.创建一个文件，用于存储另一个文件中的数据
2.定义读取流和文件文件关联
3.通过不断读写完成数据存储
4.关闭资源
*/

public class CopyText {

	public static void copy()
	{
		FileReader fr = null;
		FileWriter fw = null;
		try
		{
			fr = new FileReader("Hello.txt");
			fw = new FileWriter("Hello_Copy.txt");
			
			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)
				{
				}
		}
	}
	/*
	public static void copy2() throws IOException
	{
		FileReader fr = new FileReader("Hi.txt");
		FileWriter fw = new FileWriter("Hi_Copy.txt");
		
		int ch = 0;
		
		while((ch=fr.read())!=-1)
		{
			fw.write(ch);
		}
		fr.close();
		fw.close();
	}
	*/
	public static void main(String[] args) //throws IOException 
	{
		copy();
		//copy2();
	}
}

BufferedWriter

字符流缓冲区

缓冲区是为了提高流的效率，创建缓冲区，必须先有流对象

缓冲区中提供了跨平台的换行符 newLine();

public class BufferedWriterDemo {

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

		//创建一个字符写入流对象
		FileWriter fw = new FileWriter("buf.txt");
		
		//加入缓冲技术，只需将流对象作为参数传递给缓冲区的构造函数
		BufferedWriter bufw = new BufferedWriter(fw);
		
		for(int x=0; x<5; x++)
		{
			bufw.write("gg"+x);
			bufw.newLine();
			bufw.flush();
		}
		bufw.close();
	}
}

BufferedReader

该缓冲区提供一个一次读一行的方法 readLine();

返回null时，表示读到文件末尾

public class BufferedReaderDemo {

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

		//创建读取流对象和文件关联
		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();
	}
}

通过缓冲区复制文本文件

public class CopyTextByBuf {

	public static void main(String[] args) {

		BufferedReader bufr = null;
		BufferedWriter bufw = null;
		
		try
		{
			bufr = new BufferedReader(new FileReader("buf.txt"));
			bufw = new BufferedWriter(new FileWriter("buf_copy.txt"));
			
			String line = 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("写入关闭失败");
			}
		}
	}
}

readLine的原理图例

最终使用的是read方法，一次读一个

class MyBufferedReader
{
	private FileReader r;
	MyBufferedReader(FileReader 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')
				continue;
			if(ch=='\n')
				return sb.toString();
			else
				sb.append((char)ch);
		}
		if(sb.length()!=0)
			return sb.toString();
		return null;
	}
	public void myClose() throws IOException
	{
		r.close();
	}
}
public class MyBufferedReaderDemo {

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

		FileReader fr = new FileReader("buf.txt");
		MyBufferedReader myBuf = new MyBufferedReader(fr);
		String line = null;
		while((line=myBuf.myReadLine())!=null)
		{
			System.out.println(line);
		}
		myBuf.myClose();
	}
}

装饰设计模式

装饰设计模式：当想要对已有的对象进行功能增强时，可以定义类，将已有对象传入，基于已有的功能，并提供加强功能，那么自定义的类称为装饰类。

装饰类通常会通过构造方法接收被装饰的对象，并基于被装饰的对象的功能，提供更强的功能。

//装饰设计模式

class Person
{
	public void chifan()
	{
		System.out.println("吃饭");
	}
}
class SuperPerson
{
	private Person p;
	SuperPerson(Person p)
	{
		this.p = p;
	}
	public void superChifan()
	{
		System.out.println("开胃酒");
		p.chifan();
		System.out.println("甜点");
	}
}
public class PersonDemo {

	public static void main(String[] args) {

		Person p = new Person();
		//p.chifan();
		SuperPerson sp = new SuperPerson(p);
		sp.superChifan();
	}
}

装饰和继承的区别

装饰模式比继承灵活，避免了继承体系的臃肿，而且降低了类与类之间的关系。

装饰类因为是增强已有对象，具备的功能和已有对象是相同的，所以装饰类和被装饰类通常都是属于一个体系。

自定义装饰类

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')
				continue;
			if(ch=='\n')
				return sb.toString();
			else
				sb.append((char)ch);
		}
		if(sb.length()!=0)
			return sb.toString();
		return null;
	}
	/*
	覆盖Reader类中的抽象方法
	*/
	public int read(char[] cbuf, int off, int len) throws IOException
	{
		return r.read(cbuf,off,len);
	}
	public void close() throws IOException
	{
		r.close();
	}
	public void myClose() throws IOException
	{
		r.close();
	}
}
public class MyBufferedReaderDemo {

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

		FileReader fr = new FileReader("buf.txt");
		MyBufferedReader myBuf = new MyBufferedReader(fr);
		String line = null;
		while((line=myBuf.myReadLine())!=null)
		{
			System.out.println(line);
		}
		myBuf.myClose();
	}
}

LineNumberReader

public class LineNumberReaderDemo {

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

		FileReader fr = new FileReader("buf.txt");
		
		LineNumberReader lnr = new LineNumberReader(fr);
		
		String line = null;
		lnr.setLineNumber(100);
		while((line=lnr.readLine())!=null)
		{
			System.out.println(lnr.getLineNumber()+":"+line);
		}
		lnr.close();
	}
}

MyLineNumberReader

class MyLineNumberReader
{
	private Reader r;
	private int lineNumber;
	MyLineNumberReader(Reader r)
	{
		this.r = r;
	}
	public String myReadLine() throws IOException
	{
		lineNumber++;
		StringBuilder sb = new StringBuilder();
		int ch = 0;
		while((ch=r.read())!=-1)
		{
			if(ch=='\r')
				continue;
			if(ch=='\n')
				return sb.toString();
			else
				sb.append((char)ch);
		}
		if(sb.length()!=0)
			return sb.toString();
		return null;
	}
	public void setLineNumber(int lineNumber)
	{
		this.lineNumber = lineNumber;
	}
	public int getLineNumber()
	{
		return lineNumber;
	}
	public void myClose() throws IOException
	{
		r.close();
	}
}
public class MyLineNumberReaderDemo {

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

		FileReader fr = new FileReader("buf.txt");
		MyLineNumberReader mylnr = new MyLineNumberReader(fr);
		
		mylnr.setLineNumber(5);
		String line = null;
		while((line=mylnr.myReadLine())!=null)
		{
			System.out.println(mylnr.getLineNumber()+":"+line);
		}
		mylnr.myClose();
	}
}

字节流File读写操作

public class FileStream {

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

		writeFile();
		readFile_1();
		readFile_2();
		readFile_3();
	}
	
	public static void writeFile() throws IOException
	{
		FileOutputStream fos = new FileOutputStream("fos.txt");
		
		fos.write("abcde".getBytes());
		fos.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 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_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();
	}
}

拷贝图片

/*
复制一个图片
思路：
1.用字节读取流对象和图片关联
2.用字节写入流对象创建一个图片文件，用于存储获取到的图片数据
3.通过循环读写，完成数据的存储
4.关闭资源
*/

public class CopyPic {

	public static void main(String[] args) {

		FileInputStream fis = null;
		FileOutputStream fos = null;
		try
		{
			fis = new FileInputStream("Ruler.jpg");
			fos = new FileOutputStream("Ruler_copy.jpg");
			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 RuntimeException("写入文件失败");
			}
		}
	}
}

字节流的缓冲区自定义字节流的缓冲区-read和write的特点

CopyMp3

public 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)+"毫秒");
		long start2 = System.currentTimeMillis();
		copy_2();
		long end2 = System.currentTimeMillis();
		System.out.println((end2-start2)+"毫秒");
	}
	
	public static void copy_1() throws IOException
	{
		BufferedInputStream bufis = new BufferedInputStream(new FileInputStream("V3.mp3"));
		BufferedOutputStream bufos = new BufferedOutputStream(new FileOutputStream("V3_copy.mp3"));
		
		int by = 0;
		while((by=bufis.read())!=-1)
		{
			bufos.write(by);
		}
		bufis.close();
		bufos.close();
	}
	public static void copy_2() throws IOException
	{
		MyBufferedInputStream bufis = new MyBufferedInputStream(new FileInputStream("V3.mp3"));
		BufferedOutputStream bufos = new BufferedOutputStream(new FileOutputStream("V3_copy2.mp3"));
		
		int by = 0;
		while((by=bufis.myRead())!=-1)
		{
			bufos.write(by);
		}
		bufis.myClose();
		bufos.close();
	}
}

MyBufferedInputStream

public class MyBufferedInputStream {

	private InputStream in;
	private byte[] buf = new byte[1024];
	private int pos = 0, count = 0;
	
	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;
		}
		else if(count>0)
		{
			byte b = buf[pos];
			count--;
			pos++;
			return b&255;
		}
		return -1;
	}
	public void myClose() throws IOException
	{
		in.close();
	}
}

读取键盘录入

/*
通过键盘录入数据
当录入一行数据后，就将改行数据进行打印
当录入over，就停止录入
*/

public 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());
			}
			else
				sb.append((char)ch);
		}
	}
}

读取转换流写入转换流

/*
用readLine方法完成键盘录入的一行数据的读取
readLine方法是字符流BufferedReader类中的方法
而键盘录入的read方法是字节流InputStream的方法
通过读取转换流将字节流转换成字符流再使用字符流缓冲区的readLine方法
*/

public class TransStreamDemo {

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

		//获取键盘录入对象
		//InputStream in = System.in;
		//将字节流转换成字符流对象
		//InputStreamReader isr = new InputStreamReader(in);
		//为了提高效率，将字符串进行缓冲区技术高效操作。使用BufferedReader
		//BufferedReader bufr = new BufferedReader(isr);
		
		//键盘录入最常见写法
		BufferedReader bufr =
				new BufferedReader(new InputStreamReader(System.in));
		
		//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();
	}
}

流操作规律-1 流操作规律-2

流操作的基本规律

1.明确源和目的

源：输入流。InputStream Reader

目的：输出流。OutputStream Writer

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

是：字符流

不是：字节流

3.当体系明确后，再明确要使用哪个具体对象

通过设备来进行区分

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

目的设备：内存、硬盘、控制台

public class TransStreamDemo2 {

	public static void main(String[] args) throws IOException {
		
		//键盘录入最常见写法
		//源：键盘。目的：控制台
		BufferedReader bufr =
				new BufferedReader(new InputStreamReader(System.in));
		
		BufferedWriter bufw =
				new BufferedWriter(new OutputStreamWriter(System.out));
		
		//源：键盘。目的：文件
		//BufferedReader bufr =
				//new BufferedReader(new InputStreamReader(System.in));
		
		//BufferedWriter bufw =
				//new BufferedWriter(new OutputStreamWriter(new FileOutputStream(out.txt)));
		
		//源：文件。目的：控制台
		//BufferedReader bufr =
				//new BufferedReader(new InputStreamReader(new FileInputStream(in.txt)));

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

异常的日志信息

public class ExceptionInfo {

	public static void main(String[] args) {

		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(d.toString());
				System.setOut(ps);
			}
			catch(IOException ex)
			{
				throw new RuntimeException("日志文件创建失败");
			}
			e.printStackTrace(System.out);
		}
	}
}

系统信息

public class SystemInfo {

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

		Properties prop = System.getProperties();
		prop.list(new PrintStream("sysinfo.txt"));
	}
}

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

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

精神病人精神好

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
黑马程序员_IO流(一)

IO流(概述) 字节流抽象基类：InputStream OutputStream 字符流抽象基类：Reader WriterIO流(FileWriter) FileWriter：操作文件，写入。后缀名：父类名，前缀名：功能public class FileWriterDemo { public static void mai
复制链接

扫一扫