黑马程序员——IO流：字节流，字符流及键盘录入

　------- android培训、java培训、期待与您交流！ ----------

IO流

概述：1，IO流用来处理设备间的数据传输。
      2，Java对数据的操作是通过流的方式。
      3，Java用于操作流的对象都在IO包中。
      4，流按操作数据分为两种：字节流和字符流。
      5，流按流向分为：输入流和输出流。
注意：流只能操作数据，而不能操作文件。
IO流的常用基类：
        1）字节流的抽象基流：InputStream和OutputStream
        2）字符流的抽象基流：Reader和Writer
注：此四个类派生出来的子类名称都是以父类名作为子类名的后缀，以前缀为其功能；
    如InputStream子类FileInputStream；Reader子类FileReader

字符流

概述： 1、字符流中的对象融合了编码表。使用的是默认的编码，即当前系统的编码。
       2、字符流只用于处理文字数据，而字节流可以处理媒体数据。
       3、既然IO流是用于操作数据的，那么数据的最常见体现形式是文件。
写入字符流步骤
        1、创建一个FileWriter对象，该对象一被初始化，就必须要明确被操作的文件。
  且该目录下如果已有同名文件，则同名文件将被覆盖。其实该步就是在明确数据要存放的目的地。
        2、调用write(String s)方法，将字符串写入到流中。
        3、调用flush()方法，刷新该流的缓冲，将数据刷新到目的地中。
        4、调用close()方法，关闭流资源。但是关闭前会刷新一次内部的缓冲数据，并将数据刷新到目的地中。
close()和flush()区别：
        flush()刷新后，流可以继续使用；
       而close()刷新后，将会关闭流，不可再写入字符流。
读取字符流步骤
        1，创建一个文件读取流对象，和指定名称的文件相关联。要保证该文件已经存在，
  若不存在，将会发生异常FileNotFoundException。
        2，调用读取流对象的read()方法。read()：一次读一个字符，且会继续往下读。
           第一种方式：读取单个字符。第二种方式：通过字符数组进行读取。
        3，读取后要调用close方法将流资源关闭。
练习：

/*
练习：将C盘一个文本文件进行复制到D盘。
复制原理：将文件数据存储到另一个文件中。
步骤：
1，在D盘创建一个文件，用于存储要C盘的文件的数据。
2，定义读取流和C盘文件关联。
3，通过不断的读写完成数据存储。
4，关闭资源。
*/


import java.io.*;
class CopyTest
{
	public static void main(String[] args)
	{
		copyMethod();
	}


	public static void copyMethod()
	{
		FileWriter fw = null;
		FileReader fr = null;
		try
		{
			fw = new FileWriter("melon84_copy.txt");//创建目的地
			fr = new FileReader("melon84.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)
			{
			}
		}		
	}
}

字符流的缓冲区

概述：1，缓冲区的出现提高了对数据的读写效率。
      2，对应类BufferWrite，BufferRead。
      3，缓冲区要结合流才可以使用。
      4，在流的基础上对流的功能进行了增强。

练习：复制一个文本文件，并添加缓冲区！

import java.io.*;
class BufferTest
{
	public static void main(String[] args)
	{
		copyMethod();
	}


	public static void copyMethod()
	{
		BufferedWriter bfw = null;
		BufferedReader bfr = null;
		try
		{
			bfw = new BufferedWriter(new FileWriter("melon84_copy01.txt"));
			bfr = new BufferedReader(new FileReader("melon84.txt"));//将字符流对象作为参数传递给缓冲区对象的构造函数
			
			String line = null;
			/*
			该缓冲区提供了一次读一行的方法readLine，方便数据获取。当返回null时，表示读到结尾。
			readLine方法返回的时候只返回回车符之前的数据内容，并不返回回车符。
			*/
			while((line=bfr.readLine())!=null)
			{
				bfw.write(line);
				bfw.newLine();//换行
				bfw.flush();//只要用到缓冲区，就要记得刷新。
			}
		}
		catch(IOException e)
		{
			throw new RuntimeException("读写失败");
		}
		finally
		{
			if(bfr!=null)
				try
				{
					bfr.close();
				}
			catch(IOException e)
			{
				throw new RuntimeException("读取关闭失败");
			}


			if(bfw!=null)
				try
				{
					bfw.close();
				}
			catch(IOException e)
			{
				throw new RuntimeException("写入关闭失败");
			}
		}		
	}
}

装饰设计模式

    当想要对已有的对象进行功能增强时，可以定义类，将已有对象传入，基于已有的功能，并提供功能，
该自定义的类成为装饰类。
    装饰类通常会通过构造函数方法接收被装饰的对象，并基于被装饰的对象的功能，提供更强的功能。
装饰和继承的区别：
        1，装饰模式比继承要灵活。避免了继承体系的臃肿，且降低了类与类之间的关系。
        2，装饰类因为增强已有对象，具备的功能和已有的是相同的，只不过提供了更强的功能，所以装饰类和被装饰的类通常都是属于一个体系。
        3，从继承结构转为组合结构。
建议：在定义类的时候，不要以继承为主；可通过装饰设计模式进行增强类功能。灵活性较强，当装饰类中的功能不适合，可再使用被装饰类的功能。

字节流

两个基类：InputStream，OutputStream
字节流和字符流的基本操作是相同的，但字节流还可以操作其他媒体文件，如图片。
特点：字节流操作的是字节，即数据的最小单位，不需要像字符流一样要进行转换为字节。所以可直接将字节数据写入到指定文件中。不用进行刷流动作
练习：

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


import java.io.*;


class StreamTest
{
	public static void main(String[] args)
	{
		streamMethod();
	}


	public static void streamMethod()
	{
		FileOutputStream fos = null;//用字节读取流对象和图片关联
		FileInputStream fis = null;


		try
		{
			fos = new FileOutputStream("63_0.jpg");
			fis = new FileInputStream("63.jpg");


			byte[] by =new byte[1024];//定义数组，用于储存数据，提高读写效率
			int len=0;
			while((len=fis.read(by))!=-1)
			{
				fos.write(by,0,len);
			}
		}
		
		catch(IOException e)
		{
			throw new RuntimeException("复制失败");
		}


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


			try
			{
				fis.close();
			}
			catch(IOException e)
			{
				throw new RuntimeException("写入关闭失败");
			}
		}
	}
}

字节流缓冲区

所对应的类：BufferedOutputStream，BufferedInputStream
练习：通过缓冲区复制音乐文件

import java.io.*;


class CopyMusic
{
	public static void main(String[] args)
	{
		long start =System.currentTimeMillis();
		streamMethod();
		long end =System.currentTimeMillis();
		System.out.println((end-start)+"毫秒");//获取复制音乐文件所用的时间
	}


	public static void streamMethod()
	{
		BufferedOutputStream bfos = null;//定义缓冲区
		BufferedInputStream bfis = null;


		try
		{
			bfos = new BufferedOutputStream(new FileOutputStream("Copy01.mp3"));
			bfis = new BufferedInputStream(new FileInputStream("The Right Time.mp3"));


			int len=0;
			while((len=bfis.read())!=-1)
			{
				bfos.write(len);
			}
		}
		
		catch(IOException e)
		{
			throw new RuntimeException("复制失败");
		}


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


			try
			{
				bfis.close();
			}
			catch(IOException e)
			{
				throw new RuntimeException("写入关闭失败");
			}
		}
	}
}

读取键盘录入

 
System.out:对应的是标准输出设备，控制台。
System.in:对应的是标准输入设备：键盘。
练习：

import java.io.*;


class JianPan
{
	public static void main(String[] args)throws IOException
	{
		InputStream in = System.in;
		StringBuilder s = new StringBuilder();//定义缓冲区，用于临时储存数据，用于每录入一行数据，就可以打印
	
		while(true)
		{
			int ch=in.read();
			if(ch=='\r')
				continue;
			if(ch=='\n')
			{
				String st =s.toString();//将缓冲区数据转成字符串类型
				if("over".equals(st))//设置结束条件，当输入over时，程序结束
					break;
				System.out.println(st.toUpperCase());//将打印的数据转换成大写
				s.delete(0,s.length());//每打印一次，清空一次缓冲区
			}
			else
				s.append((char)ch);
		}
	}
}