Java基础_IO流（字符流缓冲区和字节流相关操作以及相关操作技巧）

最新推荐文章于 2022-05-23 15:02:41 发布

yangcheng91

最新推荐文章于 2022-05-23 15:02:41 发布

阅读量697

点赞数

分类专栏： Java基础特性文章标签： java string class null byte

本文链接：https://blog.csdn.net/yangcheng91/article/details/7882888

版权

Java基础特性专栏收录该内容

25 篇文章 0 订阅

订阅专栏

一、IO流(BufferedWriter)

字符流的缓冲区：

缓冲区提高了数据的读写效率，对应的类：

BufferedWriter

BufferedReader

缓冲区要结合流才可以使用，在流的基础上对流的功能进行了增强。

/*
缓冲区的出现是为了提高流的操作效率，所以在创建缓冲区之前必须先有流对象。
该缓冲区中提供了一个跨平台换行符：newLine();
*/
import java.io.*;
class BufferedWriterDemo 
{
	public static void main(String[] args)throws IOException
	{
		FileWriter fw=null;
		BufferedWriter bufw=null;
		try
		{
			//创建一个字符写入流对象。
			fw=new FileWriter("buf.txt");

			/*为了提高字符写入流的效率，加入了缓冲技术。只要将需要被提高效率的流对
			象作为参数传递给缓冲区的构造函数。*/
			bufw=new BufferedWriter(fw);
			for(int i=0;i<5;i++)
			{
				bufw.write("abcde"+i);
				bufw.newLine();//换行
				bufw.flush();//注意，只要用到缓冲区，就要记得刷新。
			}
		}
		catch (IOException e)
		{
			System.out.println(e.toString());
		}
		finally
		{
			try
			{
				if(fw!=null)
					bufw.close();//关闭缓冲区就是在关闭缓冲区中的流对象。
			}
			catch (IOException e)
			{
				System.out.println(e.toString());
			}
		}				
	}
}

二、IO流(BufferedReader)

/*
字符读取流缓冲区：
该缓冲区提供了一个一次读一行的方法readLine()方便对文本数据的获取。
当读取到文件末尾，返回null。
*/
import java.io.*;
class BufferedReaderDemo 
{
	public static void main(String[] args)throws IOException 
	{
		FileReader fr=null;
		BufferedReader bufr=null;
		try
		{
			//创建一个读取流对象和文件相关联
			fr=new FileReader("buf.txt");
			//为了提高效率加入缓冲技术，将字符读取流对象作为参数传递给缓冲对象的构造函数。
			bufr=new BufferedReader(fr);

			String line=null;
			while((line=bufr.readLine())!=null)
			{
				System.out.println(line);
			}
			
		}
		catch (IOException e)
		{
			System.out.println(e.toString());
		}
		finally
		{
			try
			{
				if(fr!=null)
					bufr.close();
			}
			catch (IOException e)
			{
				System.out.println(e.toString());
			}
		}
		
		
	}
}

三、IO流(通过缓冲区复制文本文件)

/*
通过缓冲区赋值一个*.java文件
*/
import java.io.*;
class CopyTextByBuf 
{
	public static void main(String[] args) 
	{
		BufferedReader bufr=null;
		BufferedWriter bufw=null;
		try
		{
			bufr=new BufferedReader(new FileReader("CopyTextByBuf.java"));
			bufw=new BufferedWriter(new FileWriter("CopyTextByBuf_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("写入关闭失败");
			}
		}
	}
}

四、IO流(readLine的原理图例)

五、IO流(MyBufferedReader)

/*
自定义一个类中包含一个功能和readLine一致的方法。
*/
import java.io.*;
class MyBufferedReader
{
	private FileReader r;
	MyBufferedReader(FileReader r)
	{
		this.r=r;
	}

	public String myReadLine()throws IOException//可以一次读一行的方法
	{
		/*定义一个临时容器。BufferReader封装的是字符数组，为了演示方便，定义一个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();
	}
}
class MyBufferedReaderDemo
{
	public static void main(String[] args)throws IOException
	{
		MyBufferedReader myBuf=null;
		try
		{
			myBuf=new MyBufferedReader(new FileReader("buf.txt"));
			String line=null;
			while((line=myBuf.myReadLine())!=null)
			{
				System.out.println(line);
			}
			
		}
		catch (IOException e)
		{
			throw new RuntimeException("读取失败");
		}
		finally
		{
			try
			{
				if(myBuf!=null)
					myBuf.myClose();				
			}
			catch (IOException e)
			{
				throw new RuntimeException("读取关闭失败");
			}
		}
	}
}

六、IO流(装饰设计模式)

装饰设计模式：

当想要对已有的对象进行功能增强时，可以定义类将已有对象传入，基于已有的功能并提供

加强功能，那么自定义的该类称为装饰类。

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

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

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

*/
class Person
{
	public void eat()
	{
		System.out.println("吃饭");
	}
}
class SuperPerson
{
	private Person p;
	SuperPerson(Person p)
	{
		this.p=p;
	}
	public void superEat()
	{
		System.out.println("开胃酒");
		p.eat();
		System.out.println("甜点");
		System.out.println("来一根");
	}
}
class PersonDemo1 
{
	public static void main(String[] args) 
	{
		Person p=new Person();
		p.eat();

		SuperPerson sp=new SuperPerson(p);
		sp.superEat();
	}
}

七、IO流(装饰和继承的区别)

优化前的体系：

MyReader :专门用于读取数据的类。

|--MyTextReader ：读取文本

|--MyBufferTextReader ：读取文本缓冲区

|--MyMediaReader ：读取媒体

|--MyBufferMediaReader ：读取媒体缓冲区

|--MyDataReader :读取数据

|--MyBufferDataReader :读取数据缓冲区

提取共性的内容(缓冲区):

class MyBufferReader
{
	private MyTextReader text;
	private MyMediaReader media;
	private MyDataReader data;
	MyBufferReader(MyTextReader text)
	{
		this.text=text;
	}
	MyBufferReader(MyMediaReader media)
	{
		this.media=media;
	}
	MyBufferReader(MyDataReader data)
	{
		this.data=data;
	}
}

上面这个类扩展性很差，找到其参数的共同类型，通过多态的形式可以提高扩展性。

class MyBufferReader extends MyReader
{
	private MyReader r;
	MyBufferReader(MyReader r)
	{
		this.r=r;
	}
	
}

优化后的体系：

MyReader :专门用于读取数据的类。

|--MyTextReader ：读取文本

|--MyMediaReader ：读取媒体

|--MyDataReader ：读取数据

|--MyBufferReader ：缓冲区

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

装饰类因为增强已有对象，具备的功能和已有的是相同的，只不过是提供了更强的功能。

所以装饰类和被装饰类通常都属于一个体系中。

八、IO流(自定义装饰类)

/*
自定义装饰类，继承Reader，实现read(char[] cbuf, int off, int len)和close()方法
*/
class MyBufferedReader extends Reader
{
	private Reader r;
	MyBufferedReader(Reader r)
	{
		this.r=r;
	}

	public String myReadLine()throws IOException//可以一次读一行的方法
	{
		/*定义一个临时容器。BufferReader封装的是字符数组，为了演示方便，定义一个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();
	}
}

九、IO流(LineNumberReader)

/*
LineNumberReader:
*/
import java.io.*;
class LineNumberReaderDemo
{
	public static void main(String[] args) 
	{
		LineNumberReader lnr=null;
		try
		{
			lnr=new LineNumberReader(new FileReader("LineNumberReaderDemo.java"));
			String line=null;
			//lnr.setLineNumber(1);//设置行号
			while((line=lnr.readLine())!=null)
			{
				System.out.println(lnr.getLineNumber()+":"+line);
			}			
		}
		catch (IOException e)
		{
			throw new RuntimeException("读取失败");
		}
		finally
		{
			try
			{
				if(lnr!=null)
					lnr.close();
			}
			catch (IOException e)
			{
				throw new RuntimeException("读取关闭失败");
			}
		}		
	}
}

十、IO流(MyLineNumberReader)

/*
MyLineNumberReader:
*/
import java.io.*;
class MyLineNumberReader extends MyBufferedReader
{
	private int lineNumber;
	MyLineNumberReader(Reader r)
	{
		super(r);
	}
	public String myReadLine()throws IOException
	{
		lineNumber++;
		return super.myReadLine();
	}

	public void setLineNumber(int lineNumber)
	{
		this.lineNumber=lineNumber;
	}
	public int getLineNumber()
	{
		return lineNumber;
	}
}
/*
class MyLineNumberReader
{
	private Reader r;
	private int lineNumber=0;
	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();
	}
}
*/
class MyLineNumberReaderDemo
{
	
	public static void main(String[] args)
	{
		MyLineNumberReader mylnr=null;
		try
		{
			mylnr=new MyLineNumberReader(new FileReader("MyLineNumberReaderDemo.java"));
			String line=null;
			//mylnr.setLineNumber(100);//设置默认行号从100开始
			while((line=mylnr.myReadLine())!=null)
			{
				System.out.println(mylnr.getLineNumber()+":"+line);
			}
			
		}
		catch (IOException e)
		{
			throw new RuntimeException("读取失败");
		}
		finally
		{
			try
			{
				if(mylnr!=null)
					mylnr.close();
			}
			catch (IOException e)
			{
				throw new RuntimeException("读取关闭失败");
			}
		}		
	}
}

十一、IO流(字节流File读写操作)

/*
字节流：
InputStream 
OutputStream

需求：想要操作图片数据，这时就要用到字节流。
*/
import java.io.*;
class  FileStream
{
	public static void main(String[] args)throws IOException 
	{
		writeFile();
		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.print((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();
	}
}

十二、IO流(拷贝图片)

/*
复制一个图片。
思路：
1.用字节读取流对象和图片关联。
2.用字节写入流对象创建一个图片文件，用于存储获取到的图片数据。
3.通过循环读写，完成数据的存储。
4.关闭资源。
*/
import java.io.*;
class CopyPic 
{
	public static void main(String[] args) 
	{
		FileOutputStream fos=null;
		FileInputStream fis=null;
		try
		{
			fos=new FileOutputStream("e:\\Desert_copy.jpg");
			fis=new FileInputStream("e:\\Desert.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("写入关闭失败");
			}
		}
	}
}

十三、IO流(字节流的缓冲区)

/*
演示mp3文件的复制，通过缓冲区。
BufferedOutputStream
BufferedInputStream

*/
import java.io.*;
class CopyMp3 
{
	public static void main(String[] args)
	{
		long start=System.currentTimeMillis();
		copy_1();
		long end=System.currentTimeMillis();
		System.out.println("拷贝完成，耗时："+(end-start)+"毫秒");

	}
	public static void copy_1()
	{
		BufferedInputStream bufis=null;
		BufferedOutputStream bufos=null;
		try
		{
			bufis=new BufferedInputStream(new FileInputStream("e:\\Kalimba.mp3"));
			bufos=new BufferedOutputStream(new FileOutputStream("e:\\Kalimba_copy.mp3"));

			int by=0;
			while((by=bufis.read())!=-1)
			{
				bufos.write(by);
			}
			
		}
		catch (IOException e)
		{
			throw new RuntimeException("复制文件失败");
		}
		finally
		{
			try
			{
				bufos.close();
			}
			catch (IOException e)
			{
				throw new RuntimeException("写入关闭失败");
			}

			try
			{
				bufis.close();
			}
			catch (IOException e)
			{
				throw new RuntimeException("读取关闭失败");
			}
		}		
	}
}

十四、IO流(自定义字节流的缓冲区-read和write的特点)

/*

MyBufferedInputStream.java

*/
import java.io.*;
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&0xff;
		}
		return -1;
	}
	public void myClose()throws IOException
	{
		in.close();
	}
}
/*
mp3文件：
开头局部有可能是这样的：
1111-1111-1100-0001-1001-0101-0011-1111-1010-0101

1111-1111转换成十进制是-1，所以会返回-1（有可能在程序判断时混淆结束位）

byte:-1  自动提升后 int: -1
提升前：1111-1111
提升后：1111-1111 1111-1111 1111-1111 1111-1111     （int 4个字节）
那么只要在1111-1111前面补3个字节的0即可保留原有数据不变，又可避免-1
的出现。

	1111-1111 1111-1111 1111-1111 1111-1111       -1
&	0000-0000 0000-0000 0000-0000 1111-1111       255
-------------------------------------------------------
	0000-0000 0000-0000 0000-0000 1111-1111       255


具体在方法中：
myRead:将一个字节数据提升为四个字节数据返回。
write：做强制转换，保留最后一个字节的有效数据（删除无效位的0）。
这样保证了原数据没有变化。


*/

/*
演示mp3文件的复制，通过缓冲区。
BufferedOutputStream
BufferedInputStream

*/
import java.io.*;
class CopyMp3 
{
	public static void main(String[] args)
	{
		long start=System.currentTimeMillis();
		copy_2();
		long end=System.currentTimeMillis();
		System.out.println("拷贝完成，耗时："+(end-start)+"毫秒");

	}
	public static void copy_2()
	{
		MyBufferedInputStream bufis=null;
		BufferedOutputStream bufos=null;
		try
		{
			bufis=new MyBufferedInputStream(new FileInputStream("e:\\Kalimba.mp3"));
			bufos=new BufferedOutputStream(new FileOutputStream("e:\\Kalimba_copy.mp3"));

			int by=0;
			while((by=bufis.myRead())!=-1)
			{
				bufos.write(by);
			}
			
		}
		catch (IOException e)
		{
			throw new RuntimeException("复制文件失败");
		}
		finally
		{
			try
			{
				if(bufos!=null)
					bufos.close();
			}
			catch (IOException e)
			{
				throw new RuntimeException("写入关闭失败");
			}

			try
			{
				if(bufis!=null)
					bufis.myClose();
			}
			catch (IOException e)
			{
				throw new RuntimeException("读取关闭失败");
			}
		}		
	}

	public static void copy_1()
	{
		BufferedInputStream bufis=null;
		BufferedOutputStream bufos=null;
		try
		{
			bufis=new BufferedInputStream(new FileInputStream("e:\\Kalimba.mp3"));
			bufos=new BufferedOutputStream(new FileOutputStream("e:\\Kalimba_copy.mp3"));

			int by=0;
			while((by=bufis.read())!=-1)
			{
				bufos.write(by);
			}
			
		}
		catch (IOException e)
		{
			throw new RuntimeException("复制文件失败");
		}
		finally
		{
			try
			{
				bufos.close();
			}
			catch (IOException e)
			{
				throw new RuntimeException("写入关闭失败");
			}

			try
			{
				bufis.close();
			}
			catch (IOException e)
			{
				throw new RuntimeException("读取关闭失败");
			}
		}		
	}
}

十五、IO流(读取键盘录入)

/*
读取键盘录入。
System.out: 对应的是标准输出设备控制台。
System.in:对应的是标准输入设备键盘。

需求：通过键盘录入数据，当录入一行数据后就将该行数据打印。
如果录入的数据是over停止录入。
*/
import java.io.*;
class ReadIn 
{
	public static void main(String[] args)
	{
		try
		{
			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);
					sb.delete(0,sb.length());
				}
				else
					sb.append((char)ch);
			}
		}
		catch (IOException e)
		{
			throw new RuntimeException("读取数据异常");
		}		
	}
}

十六、IO流(读取转换流)

/*
通过上一个程序的键盘录入一行数据并显示，发现其实就是读一行数据的原理，也就是
readLine()方法。那么能不能使用readLine()方法来完成键盘录入一行数据的读取呢？

readLine()方法是字符流BufferedReader类中的方法。而键盘如入的read方法是字节流
InputStream类中的方法。
那么能不能将字节流转成字符流再使用字符流缓冲区的readLine方法呢？
*/
import java.io.*;
class TransStreamDemo 
{
	public static void main(String[] args)
	{
		BufferedReader bufr=null;
		try
		{
			//获取键盘录入对象
			InputStream in=System.in;
			//将字节流对象转换成字符流对象，使用转换流InputStreamReader
			InputStreamReader isr=new InputStreamReader(in);
			//为了提高效率，将字符串进行缓冲区技术的高效操作，使用BufferedReader
			bufr=new BufferedReader(isr);
			String line=null;
			while((line=bufr.readLine())!=null)
			{
				if("over".equals(line))
					break;
				System.out.println(line);
			}
		}
		catch (IOException e)
		{
			throw new RuntimeException("读取失败");
		}
		finally
		{
			try
			{
				bufr.close();
			}
			catch (IOException e)
			{
				throw new RuntimeException("关闭读取流失败");
			}			
		}		
	}
}

十七、IO流(写入转换流)

/*
写入转换流:
*/
import java.io.*;
class TransStreamDemo 
{
	public static void main(String[] args)
	{
		BufferedReader bufr=null;
		BufferedWriter bufw=null;
		try
		{
			/*
			//获取键盘录入对象
			InputStream in=System.in;
			//将字节流对象转换成字符流对象，使用转换流InputStreamReader
			InputStreamReader isr=new InputStreamReader(in);
			//为了提高效率，将字符串进行缓冲区技术的高效操作，使用BufferedReader
			BufferedReader bufr=new BufferedReader(isr);
			*/
			bufr=new BufferedReader(new InputStreamReader(System.in));

			/*
			OutputStream out=System.out;
			OutputStreamWriter osw=new OutputStreamWriter(out);
			BufferedWriter bufw=new BufferedWriter(osw);
			*/

			bufw=new BufferedWriter(new OutputStreamWriter(System.out));

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

				try
				{
					bufw.write(line);
					bufw.newLine();
					bufw.flush();
				}
				catch (IOException e)
				{
					throw new RuntimeException("写入失败");
				}		
			}
		}
		catch (IOException e)
		{
			throw new RuntimeException("读取失败");
		}
		finally
		{
			
			try
			{
				bufr.close();
			}
			catch (IOException e)
			{
				throw new RuntimeException("关闭读取流失败");
			}
			try
			{
				bufw.close();
			}
			catch (IOException e)
			{
				throw new RuntimeException("关闭写入流失败");
			}
		}				
	}
}

十八、IO流(流操作规律)

1.源：键盘录入。

目的：控制台。

2.需求：想把键盘录入的数据存储到一个文件中。

源：键盘。

目的：文件。

3.需求：想要将一个文件的数据打印在控制台上。

源：文件。

目的：控制台。

流操作的基本规律，通过三个明确来完成。

1.明确源和目的：

源：输入流。InputStream Reader

目的：输出流。OutputStream Writer

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

是：字符流。

不是：字节流。

3.当体系明确后，再明确要使用哪个具体的对象。通过设备来区分。

源设备：内存，硬盘，键盘。

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

1.将一个文本文件中的数据存储到另一个文件中（复制文本文件）。

源：读取流，InputSteam Reader

是不是操作文本文件？

是，用Reader,这样体系就明确了。

接下来明确要使用该体系的哪个对象。

明确设备：硬盘，一个文件

Reader体系中可以操作文件的对象是FileReader

是否需要提高效率？

是，加入Reader体系中缓冲区BufferedReader

FileReader fr=new FileReader("a.txt");

BufferedReader bufr=new BufferedReader(fr);

目的：OutputStream Writer

是否是纯文本？

是，用Writer。

设备：硬盘，一个文件。

Writer体系中可以操作文件的对象FileWriter

是否需要提高效率？

是，加入Writer体系中缓冲区BufferedWriter

FileWriter fw=new FileWriter("b.txt");

BufferedWriter bufw=new BufferedWriter(fw);

2.将键盘录入的数据保存到一个文件中。

源：InputStream Reader

是不是纯文本？

是，用Reader

设备：键盘。对应的对象是System.in

不是选择Reader吗？System.in对应的不是字节流吗？

为了操作键盘的文本数据方便，转成字符流按照字符串操作最方便。

所以既然明确了Reader，那么就将System.in转换成Reader。用到了

Reader体系中的转换流InputStreamReader

InputStreamReader isr=new InputStreamReader(System.in);

需要提高效率吗？

需要，用BufferedReader

BufferedReader bufr=new BufferedReader(isr);

目的：OutputStream Writer

是否是纯文本？

是，用Writer

设备：硬盘，一个文件。用FileWriter。

FileWriter fw=new FileWriter("c.txt");

需要提高效率吗？需要。

BufferedWriter bufw=new BufferedWriter(fw);

扩展：

想要把录入的数据按照指定的编码表（utf-8）将数据存入文件中。

目的：OutputStream Writer

是否是纯文本？是，用Writer

设备：硬盘，一个文件。用FileWriter。

FileWriter是使用默认的编码表：GBK

但是存储时需要加入指定编码表，而指定的编码表只有转换流可以指定。

而该转换流对象要接受一个字节输出流，而且还可以操作文件的字节输出流 FileOutputStream

OutputStreamWriter osw=new OutputStreamWriter(new FileOutputStream("d.txt"),"UTF-8");

需要提高效率吗？需要。

BufferedWriter bufw=new BufferedWriter(osw);

所以，转换流什么时候使用？字符和字节之间的桥梁通常涉及到字符编码转换时，需要用到转换流。

/*
流操作规律：
*/
import java.io.*;
class TransStreamDemo2 
{
	public static void main(String[] args)throws IOException 
	{
		
		BufferedReader bufr=new BufferedReader(new InputStreamReader(System.in));//2.
		//BufferedReader bufr=new BufferedReader(new InputStreamReader(new FileInputStream("TransStreamDemo2.java")));//3

		BufferedWriter bufw=new BufferedWriter(new OutputStreamWriter(new FileOutputStream("out.txt")));//2.
		//BufferedWriter bufw=new BufferedWriter(new OutputStreamWriter(System.out));//3

		String line=null;
		while((line=bufr.readLine())!=null)
		{
			if("over".equals(line))
				break;
			//System.out.println(line);
			bufw.write(line);
			bufw.newLine();
			bufw.flush();
		}
		bufr.close();
	}
}

十九、IO流(改变标准输入输出设备)

/*
改变标准输入输出设备：
*/
import java.io.*;
class TransStreamDemo2 
{
	public static void main(String[] args)throws IOException 
	{
		System.setIn(new FileInputStream("TransStreamDemo2.java"));//改变输入设备
		System.setOut(new PrintStream("pad.txt"));//改变输出设备
		
		BufferedReader bufr=new BufferedReader(new InputStreamReader(System.in));
		
		BufferedWriter bufw=new BufferedWriter(new OutputStreamWriter(System.out));

		String line=null;
		while((line=bufr.readLine())!=null)
		{
			if("over".equals(line))
				break;
			//System.out.println(line);
			bufw.write(line);
			bufw.newLine();
			bufw.flush();
		}
		bufr.close();
		bufw.close();
	}
}

二十、IO流(异常的日志信息)

/*
异常的日志信息:
*/
import java.io.*;
import java.util.*;
import java.text.*;
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(s);
				System.setOut(ps);
			}
			catch (IOException ee)
			{
				throw new RuntimeException("日志文件创建失败");
			}
			e.printStackTrace(System.out);
		}
		
	}
}

二十一、IO流(系统信息)

/*
系统信息:
*/
import java.util.*;
import java.io.*;
class SystemInfo 
{
	public static void main(String[] args) 
	{
		try
		{
			Properties prop=System.getProperties();
			prop.list(new PrintStream("sysinfo.txt"));
		}
		catch (IOException e)
		{
			throw new RuntimeException("建立sysinfo.txt文件失败");
		}		
	}
}

yangcheng91

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java基础_IO流（字符流缓冲区和字节流相关操作以及相关操作技巧）

一、IO流(BufferedWriter)字符流的缓冲区：缓冲区提高了数据的读写效率，对应的类：BufferedWriterBufferedReader缓冲区要结合流才可以使用，在流的基础上对流的功能进行了增强。/*缓冲区的出现是为了提高流的操作效率，所以在创建缓冲区之前必须先有流对象。该缓冲区中提供了一个跨平台换行符：newLine();*/import java
复制链接

扫一扫