IO流的概念及使用方法二

最新推荐文章于 2022-05-27 10:53:21 发布

nancy199006

最新推荐文章于 2022-05-27 10:53:21 发布

阅读量408

点赞数

本文链接：https://blog.csdn.net/nancy199006/article/details/43606547

版权

package java学习;
/**
 * 
 * @author zhaocx1
 * 
 */
/*
 * 缓冲区的出现是为了提高流的操作效率而出现的。
 * 所以在创建缓冲区之前，就必须要先有流对象。
 * 该缓冲区中提供了一个跨平台的换行符。
 * newLine();
 */
import java.io.BufferedWriter;//导入IO流包中的类包
import java.io.FileWriter;
import java.io.IOException;

public class BufferedDemo {
	public static void main(String[] args) throws IOException {//函数上抛出异常
		// 创建一个流对象。
		FileWriter fw = new FileWriter("buf.txt");
		// 为了提高字符写入流率，加入了缓冲技术。只要将被提高效率的流对象作为参数传递给缓冲区的构造函数即可。
		BufferedWriter bufw = new BufferedWriter(fw);

		for (int x = 1; x < 5; x++) {
			bufw.write("abcdefg" + x);
			//对读取的数据进行换行
			bufw.newLine();
			//刷新流资源
			bufw.flush();
		}
		// bufw.write("abc\r\ndefg");

		// 记住,只要用到缓冲区，就要记得刷新。
		// bufw.flush();

		// 其实关闭缓冲区就是在关闭关闭缓冲区中的流对象。
		bufw.close();
	}

}

package java学习;
/**
 * 
 * @author zhaocx1
 * 
 */
/*
 * readLine方法的原理：
 * 无论是读一行，获取多个字符，其实最终都是在硬盘上一个一个读取，所以最宠使用的还是read方法一次读一个的方法。
 */
public class readLineDemo {
	public static void main(String[] args)
	{
		System.out.println("hello");
	}
}

package java学习;

/**
 * 
 * @author zhaocx1
 * 
 */
/*
 * 通过缓冲区复制一个.java文件。
 * ReadLine方法返回的时候只返回回车符之前的数据内容，并不返回回车符。
 */

import java.io.BufferedReader;//导入IO流包中的类包
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class BufferedCopyFileDemo {
	public static void main(String[] args) {
		BufferedReader bufr = null;// 定义一个缓冲区读取流，初始化值空
		BufferedWriter bufw = null;// 定义一个缓冲区写入流，初始化值为空
		try {// 对IO流中的方法操作进行异常处理
			//通过缓冲区读取一个文件
			bufr = new BufferedReader(new FileReader("BufferedWriterDemo.java"));
			//通过缓冲区写入一个文件
			bufw = new BufferedWriter(new FileWriter("bufWriter.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("写入关闭失败");
			}

		}

	}

}

package java学习;
/**
 * 
 * @author zhaocx1
 * 
 */
/*
 * 装饰设计模式：
 * 当想要对已有的对象进行功能增强时，可以定义一个类，将已有对象传入，
 * 基于已有的功能，并提供加强功能。
 * 那么，自定义的该类成为装饰类。
 * 
 * 装饰类通常会通过构造方法接受被装饰的对象。
 * 并基于被装饰的对象的功能，提供更强的功能。
 */
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("甜点");
		System.out.println("水果");
	}

}

public class ZhuangShiSheJiDemo {
	public static void main(String[] args) {
		Person p = new Person();//new一个对象，对对象进行实例化
		p.chifan();
		SuperPerson sp = new SuperPerson(p);//new一个对象，对对象进行实例化，并将已有对象传入
		sp.superChifan();
	}
}

package javaStudy;
/**
 * 
 * @author zhaocx1
 * 
 */
/*
 * MyReader//专门用于读取数据的类。
 *       1--MyTextReader
 *          --MyBufferTextReader
 *       1--MyMediaReader
 *          --MyBufferMediaReader
 *       1--MyDataReader
 *          --MyBufferDataReader
 * 
 * class MyBufferReader 
 * {
 *      MyBufferReader(MyBufferdTextReader text){}
 *      MyBufferReader(MyBufferdMediaReader media){}
 * }
 * 上面这个类扩展性很差，
 * 找到其参数的共同类型，通过多态的形式，可以提高扩展性。
 * class MyBufferReader extends MyReader
 * {
 *     private MyReader r;
 *     MyBufferReader(MyReader r){}
 * }
 * 
 * MyReader//专门用于读取数据的类。
 *       1--MyTextReader
 *       1--MyMediaReader
 *       1--MyDataReader
 *       1--MyBufferDataReader
 * 
 * 装饰模式比继承要灵活，避免了继承体系臃肿。
 * 而且降低了类与类之间的关系。
 * 
 * 装饰类因为是增强已有对象，具备的功能和已有的是相同的，只不过提供了更强功能，
 * 所有装饰类和被装饰类通常都属于一个体系中的。
 */
public class ZhuangShiAndExtend {
	public static void main(String[] args)
	{
		System.out.println("hello world");
	}

}

package javaStudy;
/**
 * 
 * @author zhaocx1
 * 
 */
import java.io.FileReader;//导入IO流包中的类包
import java.io.IOException;
import java.io.LineNumberReader;

public class LineNumberReader1 {
	public static void main(String[] args) throws IOException {//函数上抛出异常，函数内可以不用进行处理
		//定义一个文件读取流读取一个文件
		FileReader fr = new FileReader("PersonDemo.java");
        //将文件读取流作为参数传递到LineNumberReader对象中
		LineNumberReader lnr = new LineNumberReader(fr);

		String line = null;
		//设置从某一行开始读取数据
		lnr.setLineNumber(100);
		//讲读取到的数据放到字符串中
		while ((line = lnr.readLine()) != null) {
			//输出打印内容
			System.out.println(lnr.getLineNumber() + ":" + line);
		}
		lnr.close();//关闭流资源
	}

}

package javaStudy;
/**
 * 
 * @author zhaocx1
 * 
 */
/*
 * 字符流：
 * FileReader
 * FileWriter 
 * 
 * BufferedReader
 * BufferedWriter
 * 
 * 字节流：操作图片
 * InputStream(读）  OutputStream(写，输出都是写)
 * 
 * 需求：想要操作图片数据，这时就要用到字节流。
 */
import java.io.FileInputStream;//导入IO流包中的类包
import java.io.FileOutputStream;
import java.io.IOException;

public class InputStreamFileDemo {
	public static void main(String[] args) throws IOException {//主函数抛出异常
		readFile3();//调用静态方法
	}

	public static void readFile3() throws IOException {//定义一个静态方法抛出异常
		//定义字节流文件读取一个文件
		FileInputStream fis = new FileInputStream("for.txt");

		// int num=fis.available();

		byte[] buf = new byte[fis.available()];// 定义一个刚刚好的缓冲区，不用再循环了。
        //将文件的数组读到数组中
		fis.read(buf);

		// System.out.println("num=="+num);
		System.out.println(new String(buf));//输出打印独到的数组，以字符串形式
		fis.close();//关闭流资源
	}

	public static void readFile2() throws IOException {//定义一个静态方法抛出异常
		//定义字节流文件读取一个文件
		FileInputStream fis = new FileInputStream("for.txt");
		//定义一个byte类型的数组，用于存储独到的数组
		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 readFile1() throws IOException {//定义一个静态方法抛出异常
		//定义字节流文件读取一个文件
		FileInputStream fis = new FileInputStream("for.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("for.txt");
		fos.write("abcdef".getBytes()); // 把字符串变成字节数组。
        //关闭流资源
		fos.close();

	}
}

package javaStudy;

/**
 * 
 * @author zhaocx1
 * 
 */
/*
 * 复制图片
 * 思路：
 * 1.用字节读取流对象和图片关联。
 * 2.用字节写入流创建一个图片文件，用于存储获取到的图片数据。
 * 3.通过循环读写，完成数据的存储。
 * 4.关闭资源。
 */
import java.io.FileInputStream;//导入IO流包中的类包
import java.io.FileOutputStream;
import java.io.IOException;

public class CopyPictureDemo {
	public static void main(String[] args) {
        //定义一个字节流读取流
		FileInputStream fis = null;
		//定义一个字节写入流
		FileOutputStream fos = null;
		try {//对字节流操作方法进行异常处理
			//通过字节流读取读片
			fis = new FileInputStream("d:\\1.JPG");
			//通过字节写入流创建一张图片
			fos = new FileOutputStream("d:\\2.JPG");
			//定义一个byte类型的数组用于存储读到 的数组
			byte[] buf = new byte[1024];
			int len = 0;
			while ((len = fis.read(buf)) != -1) {//对数据进行一个一个读取
				fos.write(buf, 0, len);//将读到的数据写入到创建的图片中
			}

		} catch (IOException e) {//catch后面跟的是异常对象
			throw new RuntimeException("复制文件失败");
		} finally {//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("写入关闭失败");//抛出异常
			}
		}
	}
}

package javaStudy;

import java.io.BufferedInputStream;//导入IO流包中的类包
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

/**
 * 
 * @author zhaocx1
 * 
 */
/*
 * 演示mp3的复制，通过缓冲区。
 * 
 * BufferdOutputStream BufferedInputStream
 */

public class InputStreamBufferedDemo {
	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 {
		// 通过字节流缓冲区读取一个MP3
		BufferedInputStream bufis = new BufferedInputStream(
				new FileInputStream("d:\\小苹果.mkv"));
		// 通过字节流缓冲区创建一个MP3用于存储读到的数据
		BufferedOutputStream bufos = new BufferedOutputStream(
				new FileOutputStream("d:\\小苹果_copy.mkv"));

		int by = 0;
		while ((by = bufis.read()) != -1) {// 对数据进行读取
			bufos.write(by);
		}
		bufos.close();// 关闭流资源
		bufis.close();
	}
}

package javaStudy;
/**
 * 
 * @author zhaocx1
 * 
 */
/*
 * 读取键盘录入。
 * System.out:对应的是标准的输出设备，控制台。
 * System.in：标准的输入设备，键盘。
 * 
 * 需求： 
 * 通过键盘录入数据。
 * 当录入一行数据后，就将改行数据进行打印。
 * 如果录入的数据是over，那么停止录入。
 * 
 * 通过刚才的键盘录入一行数据并打印其大写，发现其实就是读一行原理。
 * 也就是readLine方法。
 * 能不能直接使用readLine方法来完成键盘录入一行数据的读取呢？
 * readLine方法是字符流BufferedReader类中的方法。
 * 
 * 而键盘录入的read方法是字节流InputStream的方法。
 * 那么能不能将字节流转成字符流在使用字符流缓冲区的readLine方法呢？
 */
import java.io.*;

public class KeyDemo {
	public static void main(String[] args) throws IOException {//函数上抛出异常
		// 获取键盘录入对象。
<span style="white-space:pre">		</span>
<span style="white-space:pre">		</span>//InputStream in = System.in;
<span style="white-space:pre">		</span>// 将字节流对象转成字符流对象，使用转换流，InputStreamReader.
<span style="white-space:pre">		</span>//InputStreamReader isr = new InputStreamReader(in);


<span style="white-space:pre">		</span>// 为了提高效率，将字符串进行缓冲区技术高效操作，使用BufferedReader.
<span style="white-space:pre">		</span>//BufferedReader bufr = new BufferedReader(isr);
<span style="white-space:pre">		</span>
<span style="white-space:pre">		</span>BufferedReader bufr=new BufferedReader(new InputStreamReader(System.in));//键盘录入  一定要记住
<span style="white-space:pre">		</span>BufferedWriter bufw=new BufferedWriter(new OutputStreamWriter(System.out));//键盘输出  一定要记住
<span style="white-space:pre">		</span>
<span style="white-space:pre">		</span>
<span style="white-space:pre">		</span>String line = null;
<span style="white-space:pre">		</span>while ((line = bufr.readLine()) != null) {
<span style="white-space:pre">			</span>if("over".equals(line)) 
<span style="white-space:pre">				</span>break; //定义一个键盘结束标记。
<span style="white-space:pre">			</span>System.out.println(line.toUpperCase());
<span style="white-space:pre">		</span>}
<span style="white-space:pre">		</span>bufr.close();


<span style="white-space:pre">	</span>}

}

package javaStudy;

/**
 * 
 * @author zhaocx1
 * 
 */
import java.io.BufferedReader;//导入IO流包中的类包
import java.io.BufferedWriter;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;

/*
 * 流操作的基本规律：
 * 最痛苦的就是流对象有很多，不知道该用哪一个。
 * 
 * 通过三个明确来完成：
 * 1.明确操作源和目的。
 *     源：输入流。 InputStream  Reader
 *     目的：输出流。 OutputStream Writer
 * 2.操作的数据是否是纯文本。
 *     是：用字符流。
 *     不是：字节流。
 * 3.当体系明确后，再明确使用哪个具体的对象。
 *     通过设备来进行区分：
 *     源设备：内存，硬盘，键盘。
 *     目的设备：内存，硬盘，控制台。
 * 
 * 1，将一个文本文件中的数据存储到另一个文件中，复制文件。
 *     源：因为是源，所以使用读取流，InputStream Reader
 *        因为是操作文本文件，所以选择Reader
 *        此时体系明确。
 *     
 *     接下来明确要使用该体系中的哪个对象。
 *     明确设备：硬盘。
 *     Reader体系中可以操作的文件的对象是FileReader.
 *     
 *     是否需要提高效率，是！ 加入Reader体系中的BufferedReader.
 *     FileReader fr=new FileReader("a.xt"); 
 *     BufferedReader bufr=new BufferedReader(fr);
 *     
 *   目的：OuputStream  Writer
 *       因为此时是纯文本文件，使用Writer
 *       设备：硬盘，一个文件。
 *       Writer体系中可以操作文件的对象是FileWriter.
 *
 *      是否需要提高效率，是！ 加入Writer体系中的BufferedWriter.
 *      FileWriter fw=new FileWriter("b.txt");
 *      BufferedWriter bufw=new BufferedWriter("fw.txt");
 *      
 * 练习：将一个图片文件中数据存储到另一个文件中，复制文件，要按照以上格式自己完成三个明确。
 */
public class IOCaoZuoDemo1 {

	public static void main(String[] args) throws IOException {
		// 通过键盘录入在读取文件中的数据
		BufferedReader bufr = new BufferedReader(new InputStreamReader(
				new FileInputStream("字符读取流缓冲区.java")));
		// 通过键盘输出读取文件中的数据
		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();//对写入的数据进行换行

			System.out.println(line.toUpperCase());//以大写形式输出打印读到的信息
		}
		bufr.close();//关闭流资源
		bufw.close();
	}

}

package javaStudy;
/**
 * 
 * @author zhaocx1
 * 
 */
import java.io.FileInputStream;//导入IO流包中的类包
import java.io.IOException;
import java.io.PrintStream;

/*
 * 2.需求：将键盘录入的数据保存到一个文件中。
 *     这个需求中有源和目的的存在。那么分别分析：
 *     源：InputStream  Reader
 *     因为是纯文本，所以使用Reader
 * 
 *     设备：键盘，对应的对象是System.in.cc
 *     不是选择Reader吗？System.in.对应的不是字节流吗？
 *     为了操作键盘的文本呢数据方便，转成字符流按照字符串操作是最方便的。
 *     所以既然明确了Reader，那么就将System.in转换成字符流Reader。
 *     用到Reader体系中的转换流，InputStreamReader
 *     
 *     InputStreamReader isr=new InputStreamReader(System.in);
 *     
 *     需要提高效率吗？需要!BufferedReader 
 *     BufferedReader bufr=new BufferedReader(isr);
 *     
 *     FileWriter fw=new FileWriter("c.txt");
 *     需要提高效率吗？需要。
 *     BufferedWriter  bufw=new BufferedWriter(fw);
 *     
 *     
 *     扩展一下，想要把录入的数据按照指定的编码表（utf-8）,将数据存到文件中。
 *     目的：OutputStreamWriter
 *     是否是纯文本呢？是 Writer!
 *     设备：硬盘，一个文件，使用FileWriter.
 *     但是FileWriter是使用的默认编码表，GBK.
 *     
 *     但是存储时，需要加入指定编码表utf-8，而指定的编码表只有转换流可以指定。
 *     所以使用的对象是OutputStreamWriter.
 *     而该转换流对象要接受一个字节输出流，而且还可以操作的文件的字节输出流，FileOutputStream
 *     
 *     OutputStreamWriter osw=new OutputStreamWriter(new FileOutputStream("d.txt),"UTF-8");
 *     需要高效吗？需要
 *     BufferedWriter bufw=new BufferedWriter(osw);
 *     
 *     所以，记住，   
 */

public class IOCaoZuoDemo2 {
	public static void main(String[] args)throws IOException
	{
		System.setIn(new FileInputStream("a.txt"));//改变标准输入设备
		System.setOut(new PrintStream("b.txt"));//改变标准输出设备
	}
}

nancy199006

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
IO流的概念及使用方法二

package java学习;/** * * @author zhaocx1 * *//* * 缓冲区的出现是为了提高流的操作效率而出现的。 * 所以在创建缓冲区之前，就必须要先有流对象。 * 该缓冲区中提供了一个跨平台的换行符。 * newLine(); */import java.io.BufferedWriter;//导入IO流包中的类包import java.
复制链接

扫一扫