java流：字符缓冲流，装饰设计模式，适配器设计模式，字节流

字符缓冲流之缓冲写出流BufferedWriter

package com.qianfeng.test;

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;

/*
 * 字符缓冲流：又叫字符缓冲区，是为了提高读写的能力，本身没有读写的能力，要想进行读写必须依靠字符流来实现。
 * 
 * 可以将缓冲流比作催化剂或者高速的小车。
 * 
 * 字符缓冲流分类：
 * 1.字符缓冲读入流：BufferedReader		辅助读，没有读的能力
 * 2.字符缓冲写出流：BufferedWriter		辅助写，没有写的能力
 * 
 */
public class Demo2 {

	public static void main(String[] args) throws IOException {
		
		//1.创建缓冲写出流
		BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter("temp1.txt"));
		
		//2.写
		bufferedWriter.write("bingbing");
		/*
		 * 换行，优点：有跨平台性。
		 */
		bufferedWriter.newLine();
		bufferedWriter.write("bingbing2");
		
		//3.关闭流。a：关闭写出流  b：刷新  c：关闭缓冲写出流
		bufferedWriter.close();
	}
	
}

---

字符缓冲流之缓冲读入流BufferedReader

package com.qianfeng.test;

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class Demo3 {

	public static void main(String[] args) throws IOException {
		
		/*
		 * 1.字符缓冲读入流：BufferedReader		辅助读，没有读的能力
		 */
		//1.创建字符缓冲读入流的对象
		BufferedReader reader = new BufferedReader(new FileReader("temp1.txt"));
		
		//2.读
		//a:一次读一个字符
//		int num;
//		while((num = reader.read())!=-1){
//			System.out.print((char)num);
//		}
		
		//b:一次读多个字符
//		int num;
//		char[] arr = new char[4];
//		while((num = reader.read(arr))!=-1){
//			System.out.print(new String(arr,0,num));
//		}
		//c:一次读一行-readLine()
		//特点：不会将当前的换行符返回；返回值就是我们读到的内容，以字符串的形式返回。当返回null的时候说明读完了。
		String data = null;
		while((data = reader.readLine())!=null){
			System.out.print(data);
			System.out.println();//打印到控制台时使用的换行符。
		}
		
		//3.关闭流
		reader.close();
	}
}

---

使用字符缓冲流实现文件的复制

package com.qianfeng.test;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

/*
 * 使用字符缓冲流实现文件的复制
 * 要求：1.将Demo1.java的内容复制到Demo1copy.java
 * 2.读的方式要采用三种
 */
public class Demo4 {

	public static void main(String[] args) throws IOException {
		
		//1.创建缓冲读入流和缓冲写出流
		BufferedReader reader = new BufferedReader(new FileReader("src\\com\\qianfeng\\test\\Demo1.java"));
		BufferedWriter writer = new BufferedWriter(new FileWriter("Demo1copy.java"));
		
		//2.读写
		//a：一个字符一个字符
//		int num;
//		while((num=reader.read())!=-1){
//			writer.write(num);
//		}
		
		//b:一次读多个字符
//		int num;
//		char[] arr = new char[10];
//		while((num=reader.read(arr))!=-1){
//			writer.write(arr,0,num);
//		}
		
		//c:一次读一行
		String data = null;
		while((data = reader.readLine())!=null){
			writer.write(data);
			writer.newLine();
		}
		
		//3.关闭流
		reader.close();
		writer.close();
		
	}
}

---

LineNumberReader类，设置、获取行号

package com.qianfeng.test;

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.LineNumberReader;

/*
 * LineNumberReader:是BufferedReader的子类，不能读，但是可以提高效率，
 * 特有功能：设置行号，获取行号。
 */
public class Demo5 {

	public static void main(String[] args) throws IOException {
		
		//1.创建缓冲流
		LineNumberReader lineNumberReader = new LineNumberReader(new FileReader("src\\com\\qianfeng\\test\\Demo2.java"));
		
		//设置行号
		//注意点：默认从0开始设置，从1开始记数。
		lineNumberReader.setLineNumber(0);
		
		//2.读
		String data =null;
		while((data=lineNumberReader.readLine())!=null){
			System.out.print(lineNumberReader.getLineNumber());//获取行号
			System.out.print(data);
			System.out.println();
		}
		
		//3.关闭流
		lineNumberReader.close();
		
	}
}

---

装饰设计模式、适配器设计模式

package com.qianfeng.test;

import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;

/*
 * 模拟BufferedReader
 * 分析:
 * 1.要属于流的体系
 * 2.要有一个Reader类型的成员变量
 * 3.要有一个带参数的方法接收外部的流对象
 * 4.模拟readLine()方法,实现读一行的功能
 * 5.重写close()方法
 */
public class Demo6 {
	public static void main(String[] args) throws IOException {
		MyBufferedReader myBufferedReader = new MyBufferedReader(new FileReader("temp1.txt"));
		
		String data = null;
		while ((data = myBufferedReader.readLine()) != null) {
			System.out.print(data);
			System.out.println();
		}
		
		myBufferedReader.close();
	}
}
//1.要属于流的体系
class MyBufferedReader extends Reader{
	
	//2.要有一个Reader类型的成员变量
	Reader reader;
	//3.要有一个带参数的方法接收外部的流对象
	public MyBufferedReader(Reader reader) {
		this.reader = reader;
	}
	
	//4.模拟readLine()方法,实现读一行的功能
	public String readLine() throws IOException {
		//a:准备一个临时的可变字符串存储当前行的内容
		StringBuffer stringBuffer = new StringBuffer();
		//b:开始读
		int num;
		while ((num = reader.read()) != -1) {
			if (num == '\r') {//继续读
				continue;
			}else if (num == '\n') {//停止读
				return stringBuffer.toString();
			}else {
				stringBuffer.append((char)num);
			}
		}
		
		//c:当文本没有内容时的处理:
		if (stringBuffer.length() == 0) {
			return null;
		}
		
		//d:当文本只有一行,没有换行符
		return stringBuffer.toString();
		
		//e:这里写提高效率的代码
	}
	
	
	
	@Override
	public int read(char[] cbuf, int off, int len) throws IOException {
		return 0;
	}

	//5.重写close()方法
	@Override
	public void close() throws IOException {
		//关闭读入流
		this.reader.close();
		//将自己关闭
		//this.close();
	}
	
}

/*
 * 装饰设计模式:基于已经实现的功能,提供增强的功能.
 * 装饰设计模式的由来就来自于对缓冲流的实现.
 * 
 * 特点:从缓冲流的角度讲解
 * 1.使流原来的继承体更加的简单
 * 2.提高了效率
 * 3.由于是在原有的基础上提高增强的功能,所以他还要属于原来的体系
 * 
 * 演示:如果自己设计装饰设计模式,怎么处理?
 * 1.原来的类  Test
 * 2.装饰类   BTest
 * 
 * 
 * 步骤:
 * 1.让BTest 继承自Test
 * 2.在BTest内有一个Test类型的成员变量
 * 3.通过BTest内一个带参数的构造方法接收外部传入的一个Test类型的对象,交给内部的Test的属性
 * 4.在实现功能的时候,调用传入的Test类型的对象实现原有的功能,自己实现增强的功能.
 * 
 * 
  * 适配器设计模式:通常可以变相的理解成装饰设计模式
 * 实例:要求在子类中只使用play方法
 * 
 * 分析:Dog是继承了ZiMidel类,ZiMidel类实现了Inter接口
 * 当Dog类想要实现Inter接口的一个方法的时候,如果直接实现Inter接口,就必须将所有的方法都实现,
 * 如果在Dog类与Inter接口之间插入一个类,让这个类去实现Inter接口的所有方法,作为这个类的子类只需要实现自己需要的方法
 * 
 * 我们将中间的这个类就可以成为适配器类
 * 
 */


interface Inter{
	public void play();
	public void song();
	public void run();
	public void eat();
	public void jump();
}
//适配器类
class ZiMidel implements Inter{

	@Override
	public void play() {
		
	}

	@Override
	public void song() {
		
	}

	@Override
	public void run() {
		
	}

	@Override
	public void eat() {
		
	}

	@Override
	public void jump() {
		
	}
	
}


//创建狗类,我只想让她实现play方法?
class Dog extends ZiMidel{
	public void play() {
		
	}
}

class Cat extends ZiMidel{
	public void song() {
		
	}
}

---

字节流

package com.qianfeng.test;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;

/*
 * 字符流：传输的是字节，只能用于字符的传输
 * 		字符读入流：Reader
 * 				read（）	read（数组）
 * 		字符写出流：Writer
 * 				write（int c）  write（char[] arr）  write(String s)
 * 		缓冲字符读入流:BufferedReader
 * 				readLine()
 * 		缓冲字符写出流：BufferedWriter
 * 				newLine()
 * 
 * 字节流：传输的是字节，可以传输所有的内容
 * 		字节输入流：InputStream
 * 		字节输出流：OutputStream
 * 		缓冲字节输入流：BufferedInputStream
 * 		缓冲字节输出流：BufferedOutputStream
 * 
 * 
 * 
 */
public class Demo7 {

	public static void main(String[] args) throws IOException {
		
		//写
		writeFile();
		//读1
		readFile1();
		//读2
		readFile2();
		//读3
		readFile3();
		
	}
	
	//写
	public static void writeFile() throws IOException{
		//创建字节写出流
		OutputStream outputStream = new FileOutputStream("temp2.txt");
		outputStream.write("bingbing".getBytes());//使用默认的格式编码
		outputStream.close();
	}
	
	//读1--一个字符一个字符
	public static void readFile1() throws IOException{
		FileInputStream fileInputStream = new FileInputStream("temp2.txt");
		int num;
		while((num=fileInputStream.read())!=-1){
			System.out.print((char)num);
		}
		fileInputStream.close();
	}
	
	//读2--一次多个字符
	public static void readFile2() throws IOException{
		FileInputStream fileInputStream = new FileInputStream("temp2.txt");
		int num;
		byte[] arr = new byte[4];
		while((num=fileInputStream.read(arr))!=-1){
			System.out.print(new String(arr,0,num));
		}
		fileInputStream.close();
	}
	
	//读3--一次全部读出
	public static void readFile3() throws IOException{
		FileInputStream fileInputStream = new FileInputStream("temp2.txt");
		//获取的所有的字节数
		//注意：如果文本的字节数太大不建议使用。
		int nums = fileInputStream.available();
		int num;
		byte[] arr = new byte[nums];
		num=fileInputStream.read(arr);
		System.out.print(new String(arr,0,num));
		fileInputStream.close();
	}
	
	
}

---

使用字节流实现图片的复制

package com.qianfeng.test;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;

/*
 * 使用字节流实现图片的复制
 */
public class Demo8 {

	
	public static void main(String[] args) throws IOException {
		
		//1.创建字节输入流，输出流
		FileInputStream fileInputStream = new FileInputStream("C:\\Users\\acer\\Desktop\\111.jpg");
		FileOutputStream outputStream = new FileOutputStream("C:\\Users\\acer\\Desktop\\222.jpg");
		
		//2.完成读写
		int num;
		while((num=fileInputStream.read())!=-1){
			outputStream.write(num);
		}
		
		//3.关闭流
		fileInputStream.close();
		outputStream.close();
		
	}
}

---

使用缓冲字节流实现图片的复制

package com.qianfeng.test;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
/*
 * 使用缓冲字节流实现图片的复制
 */
public class Demo9 {

	public static void main(String[] args) throws IOException {
		
		//1.创建
		BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream("C:\\Users\\acer\\Desktop\\111.jpg"));
		BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(new FileOutputStream("C:\\Users\\acer\\Desktop\\2223.jpg"));
		
		//2.完成读写
		int num;
		while((num=bufferedInputStream.read())!=-1){
			bufferedOutputStream.write(num);
		}
		
		//3.关闭流
		bufferedInputStream.close();
		bufferedOutputStream.close();
		
	}
}

---

标准输入流 System. in、标准输出流System.out

package com.qianfeng.test;

import java.io.IOException;
import java.io.InputStream;

/*
 * 标准输入流：System.in:此流已经被打开，准备提供数据。这个流默认对应键盘（输入源）的输入或由主机或用户提供的输入源。
 * 标准输出流：System.out
 * 
 */
public class Demo10 {

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

		// 标准输入流 输入源：键盘 中转点：内存 输出源：控制台
		InputStream inputStream = System.in;// 这个流已经默认绑定了键盘，所以可以直接从键盘接实数据。这是字节流。
		// int num = inputStream.read();//是一个阻塞式的方法，会一直等待用户输入。
		// System.out.println(num);

		/*
		 * 实例：要求可以从键盘不断的接收字节 要求：一行一行的接收
		 */
		myReadLine(inputStream);

	}

	//
	public static void myReadLine(InputStream inputStream) throws IOException {
		StringBuffer stringBuffer = new StringBuffer();
		while (true) {
			int num = inputStream.read();
			if (num == '\r') {
				continue;
			} else if (num == '\n') {
				System.out.println(stringBuffer.toString());

				// 当输入over的时候认为是结束
				if (stringBuffer.toString().equals("over")) {
					break;
				}

				// 清除上一次的内容
				stringBuffer.delete(0, stringBuffer.length());
				
			} else {
				stringBuffer.append((char) num);
			}
		}
	}
}