黑马程序员java之IO_2

最新推荐文章于 2022-01-06 17:26:46 发布

Zero_120_1

最新推荐文章于 2022-01-06 17:26:46 发布

阅读量300

点赞数

分类专栏： java基础

本文链接：https://blog.csdn.net/Zero_120_1/article/details/48210477

版权

java基础专栏收录该内容

12 篇文章 0 订阅

订阅专栏

------- <a href="http://www.itheima.com" target="blank">android培训</a>、<a href="http://www.itheima.com" target="blank">java培训</a>、期待与您交流！ ----------

流的操作规律：

1，明确源和目的。

数据源：就是需要读取，可以使用两个体系：InputStream、Reader；

数据汇：就是需要写入，可以使用两个体系：OutputStream、Writer；

2，操作的数据是否是纯文本数据？

如果是：数据源：Reader

数据汇：Writer

如果不是：数据源：InputStream

数据汇：OutputStream

3，虽然确定了一个体系，但是该体系中有太多的对象，到底用哪个呢？

明确操作的数据设备。

数据源对应的设备：硬盘(File)，内存(数组)，键盘(System.in)

数据汇对应的设备：硬盘(File)，内存(数组)，控制台(System.out)。

4，需要在基本操作上附加其他功能吗？比如缓冲。

如果需要就进行装饰。

想要操作文本文件，必须要进行编码转换，而编码转换动作转换流都完成了。所以操作文件的流对象只要继承自转换流就可以读取一个字符了。

但是子类有一个局限性，就是子类中使用的编码是固定的，是本机默认的编码表，对于简体中文版的系统默认码表是GBK。

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

InputStreamReaderisr =newInputStreamReader(newFileInputStream("a.txt"),"gbk");

以上两句代码功能一致，

如果仅仅使用平台默认码表，就使用FileReader fr = newFileReader("a.txt"); //因为简化。

如果需要制定码表，必须用转换流。

转换流 =字节流+编码表。

转换流的子类File =字节流 +默认编码表。

凡是操作设备上的文本数据，涉及编码转换，必须使用转换流。

package pract;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;

public class InputStreamReaderDemo {
	/**
	3、编写程序，循环接收用户从键盘输入多个字符串，
	直到输入“end”时循环结束，并将所有已输入的字符串按字典顺序倒序打印。

	*/
	public static void main(String[] args) {
		reverseString();
	}
	public static void reverseString(){
		BufferedReader bufr = null;
		BufferedWriter bufw = null;
		
		try {
			//定义一个键盘录入的方法，由于键盘录入是字节流，所以需要用转换流接收。
			bufr = new BufferedReader(new InputStreamReader(System.in));
			//输出也需要转换流
			bufw = new BufferedWriter(new OutputStreamWriter(System.out));
			
			String line = null;
			StringBuilder sb = null;//定义了一个空的StringBuilder对象
			while((line=bufr.readLine())!=null){
				if(line.equals("end"))//如果输入end 程序结束
					break;
				sb = new StringBuilder(line);//把获取到的的信息传递给StringBuilder对象
				//调用StringBuilder对象的reverse()方法和toString()方法
				bufw.write(sb.reverse().toString());//把StringBuilder信息传递给缓冲区
				bufw.newLine();
				bufw.flush();
				//StringBuilder的存在意义就是为了字符串的反转reverse()而出现的。
			}
		} catch (Exception e) {
			throw new RuntimeException("键盘录入失败");
		}
		finally{
			try {
				if(bufr!=null)
					bufr.close();
			} catch (Exception e) {
				throw new RuntimeException("录入流关闭失败");
			}
			try {
				if(bufw!=null)
					bufw.close();
			} catch (Exception e2) {
				throw new RuntimeException("输出流关闭失败");
			}
		}
	}

}

File类：将文件系统中的文件和文件夹封装成了对象。提供了更多的属性和行为可以对这些文件和文件夹进行操作。这些是流对象办不到的，因为流只操作数据。

File类常见方法：

1：创建。

boolean createNewFile()：在指定目录下创建文件，如果该文件已存在，则不创建。而对操作文件的输出流而言，输出流对象已建立，就会创建文件，如果文件已存在，会覆盖。除非续写。

boolean mkdir()：创建此抽象路径名指定的目录。

boolean mkdirs()：创建多级目录。

2：删除。

boolean delete()：删除此抽象路径名表示的文件或目录。

void deleteOnExit()：在虚拟机退出时删除。

注意：在删除文件夹时，必须保证这个文件夹中没有任何内容，才可以将该文件夹用delete删除。

window的删除动作，是从里往外删。注意：java删除文件不走回收站。要慎用。

3：获取.

long length()：获取文件大小。

String getName()：返回由此抽象路径名表示的文件或目录的名称。

String getPath()：将此抽象路径名转换为一个路径名字符串。

String getAbsolutePath()：返回此抽象路径名的绝对路径名字符串。

String getParent()：返回此抽象路径名父目录的抽象路径名，如果此路径名没有指定父目录，则返回null。

longlastModified()：返回此抽象路径名表示的文件最后一次被修改的时间。

File.pathSeparator：返回当前系统默认的路径分隔符，windows默认为“；”。

File.Separator：返回当前系统默认的目录分隔符，windows默认为“\”。

4：判断：

boolean exists()：判断文件或者文件夹是否存在。

boolean isDirectory()：测试此抽象路径名表示的文件是否是一个目录。

boolean isFile()：测试此抽象路径名表示的文件是否是一个标准文件。

boolean isHidden()：测试此抽象路径名指定的文件是否是一个隐藏文件。

boolean isAbsolute()：测试此抽象路径名是否为绝对路径名。

5：重命名。

boolean renameTo(Filedest)：可以实现移动的效果。剪切+重命名。

String[] list()：列出指定目录下的当前的文件和文件夹的名称。包含隐藏文件。

如果调用list方法的File对象中封装的是一个文件，那么list方法返回数组为null。如果封装的对象不存在也会返回null。只有封装的对象存在并且是文件夹时，这个方法才有效。

package pract;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.PrintWriter;

/*

4、编写一个程序，把指定目录下的所有的带.java文件都拷贝到
另一个目录中，拷贝成功后，把后缀名是.java的改成.txt。
*/

class Demo4 {
	public static void main(String[] args) {
		File yuan = new File("C:\\Users\\zety-li\\Desktop\\25题");
		File mudi = new File("C:\\Users\\zety-li\\Desktop\\25题\\day04");

		copy_1( yuan, mudi);
	}

	public static void copy_1(File yuan , File mudi){
		//File类，
		if(!mudi.exists())//判断目的路径是否存在，不存在则创建。
			mudi.mkdir();
		if(!mudi.isDirectory())//判断目的路径是否是目录，不是则创建。
			mudi.mkdir();

		File[] files = yuan.listFiles();//获取此目录下的文件。

		for(File file : files){
			if(file.isDirectory())//如果文件是目录的话，继续调用本类。这种方法就做递归。
				/*
				 * 递归：就是函数自身调用自身。
					什么时候用递归呢？
					当一个功能被重复使用，而每一次使用该功能时的参数不确定，都由上次的功能元素结果来确定。
					简单说：功能内部又用到该功能，但是传递的参数值不确定。(每次功能参与运算的未知内容不确定)。

					递归的注意事项：
					1：一定要定义递归的条件。
					2：递归的次数不要过多。容易出现 StackOverflowError 栈内存溢出错误。
					其实递归就是在栈内存中不断的加载同一个函数。
					*/
				copy_1(file,mudi);//调用自己本身。
			else if(file.getName().endsWith(".java"))
				//当目录下都是文件的时候判断文件是否是以.java结尾，是就运行copy_2();
				copy_2(file , mudi);
		}

	}
	public static void copy_2(File file , File mudi){
		BufferedReader bufr = null;
		PrintWriter out= null;

		try{
			bufr = new BufferedReader(new FileReader(file));
			
			out = new PrintWriter(mudi+"\\"+file.getName().replace(".java",".txt"));
			// 这是字符打印流，
			String line = null;
				
			while((line=bufr.readLine())!=null){
				out.println(line);
			}

		}
		catch (Exception e){
			throw new RuntimeException("复制失败，请重新复制");
		}
		finally{
			try{
				if(bufr!= null)
					bufr.close();
				if(out!=null)
					out.close();
			}
			catch (Exception e){
				throw new RuntimeException("关闭失败 ");
			}
		}
	}
}

Java.util.Properties：一个可以将键值进行持久化存储的对象。Map--Hashtable的子类。

Map

|--Hashtable

|--Properties：用于属性配置文件，键和值都是字符串类型。

特点：1：可以持久化存储数据。2：键值都是字符串。3：一般用于配置文件

|-- load()：将流中的数据加载进集合。

原理：其实就是将读取流和指定文件相关联，并读取一行数据，因为数据是规则的key=value，所以获取一行后，通过 = 对该行数据进行切割，左边就是键，右边就是值，将键、值存储到properties集合中。

|-- store()：写入各个项后，刷新输出流。

|-- list()：将集合的键值数据列出到指定的目的地。

properties是集合中和IO技术相结合的集合容器。

package pract;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Properties;

public class PropertiesDemo {

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

	public static void loadDemo()throws IOException
	{
		Properties prop = new Properties();//想使用其中的功能就要创建其对象
		FileInputStream fis = new FileInputStream("info.txt");

		//将流中的数据加载进集合。
		prop.load(fis);
		//修改或添加集合properties中加入元素。但是这个只加入到流中。
		prop.setProperty("wangwu","39");

		FileOutputStream fos = new FileOutputStream("info.txt");
		//创建一个输出流，因为store方法通过输出流可以吧流中的数据刷到配置文件中。
		prop.store(fos,"haha");
		//haha属于注释信息，可以随意订制
		prop.list(System.out);//列出集合元素

		fos.close();//释放资源
		fis.close();

	}

}

介绍几种IO包中扩展功能的流对象：基本都是装饰设计模式。

PrintStream：打印流

1：提供了更多的功能，比如打印方法。可以直接打印任意类型的数据。

2：它有一个自动刷新机制，创建该对象，指定参数，对于指定方法可以自动刷新。

3：它使用的本机默认的字符编码.

4：该流的print方法不抛出IOException。

该对象的构造函数。

PrintStream(File file) ：创建具有指定文件且不带自动行刷新的新打印流。

PrintStream(File file, String csn)：创建具有指定文件名称和字符集且不带自动行刷新的新打印流。

PrintStream(OutputStream out)：创建新的打印流。

PrintStream(OutputStream out, boolean autoFlush)：创建新的打印流。

PrintStream(OutputStream out, boolean autoFlush, String encoding)：创建新的打印流。

PrintStream(String fileName)：创建具有指定文件名称且不带自动行刷新的新打印流。

PrintStream(String fileName, String csn)

PrintStream可以操作目的：1：File对象。2：字符串路径。3：字节输出流。

前两个都JDK1.5版本才出现。而且在操作文本文件时，可指定字符编码了。

当目的是一个字节输出流时，如果使用的println方法，可以在printStream对象上加入一个true参数。这样对于println方法可以进行自动的刷新，而不是等待缓冲区满了再刷新。最终print方法都将具体的数据转成字符串，而且都对IO异常进行了内部处理。

既然操作的数据都转成了字符串，那么使用PrintWriter更好一些。因为PrintWrite是字符流的子类，可以直接操作字符数据，同时也可以指定具体的编码。

--------------------------------------------------------

PrintWriter：具备了PrintStream的特点同时，还有自身特点：

该对象的目的地有四个：1：File对象。2：字符串路径。3：字节输出流。4：字符输出流。

开发时尽量使用PrintWriter。

方法中直接操作文件的第二参数是编码表。

直接操作输出流的，第二参数是自动刷新。

package pract;

import java.io.BufferedReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;

public class PrintStreamDemo {
	
	public static void main(String[] args) throws IOException
	{
		BufferedReader bufr = //键盘录入
			new BufferedReader(new InputStreamReader(System.in));
		//输出流：加了true可以自动刷新
		PrintWriter out = new PrintWriter(new FileWriter("a.txt"),true);

		String line = null;

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

			//out.flush();自动刷新不需要再手动刷新了
		}

		out.close();
		bufr.close();

	}
}

SequenceInputStream：序列流，作用就是将多个读取流合并成一个读取流。实现数据合并。

表示其他输入流的逻辑串联。它从输入流的有序集合开始，并从第一个输入流开始读取，直到到达文件末尾，接着从第二个输入流读取，依次类推，直到到达包含的最后一个输入流的文件末尾为止。

这样做，可以更方便的操作多个读取流，其实这个序列流内部会有一个有序的集合容器，用于存储多个读取流对象。

该对象的构造函数参数是枚举，想要获取枚举，需要有Vector集合，但不高效。需用ArrayList，但ArrayList中没有枚举，只有自己去创建枚举对象。

但是方法怎么实现呢？因为枚举操作的是具体集合中的元素，所以无法具体实现，但是枚举和迭代器是功能一样的，所以，可以用迭代替代枚举。

合并原理：多个读取流对应一个输出流。

切割原理：一个读取流对应多个输出流。

package pract;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.SequenceInputStream;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.Iterator;

public class SplitFile {
	
	public static void main(String[] args) throws IOException
	{
		//splitFile();
		merge();
	}


	public static void merge()throws IOException//组合
	{
		ArrayList<FileInputStream> al = new ArrayList<FileInputStream>();

		for(int x=1; x<=3; x++)
		{
			al.add(new FileInputStream("c:\\splitfiles\\"+x+".part"));
		}

		final Iterator<FileInputStream> it = al.iterator();

		Enumeration<FileInputStream> en = new Enumeration<FileInputStream>()
		{//复写枚举方法
			public boolean hasMoreElements()
			{
				return it.hasNext();
			}
			public FileInputStream nextElement()
			{
				return it.next();
			}
		};

		SequenceInputStream sis = new SequenceInputStream(en);//合并流


		FileOutputStream fos = new FileOutputStream("c:\\splitfiles\\0.bmp");

		byte[] buf = new byte[1024];

		int len = 0;

		while((len=sis.read(buf))!=-1)
		{
			fos.write(buf,0,len);
		}

		fos.close();
		sis.close();
	}

	public static void splitFile()throws IOException//切割
	{
		FileInputStream fis =  new FileInputStream("c:\\1.bmp");

		FileOutputStream fos = null;


		byte[] buf = new byte[1024*1024];//这是1M，

		int len = 0;
		int count = 1;
		while((len=fis.read(buf))!=-1)
		{
			fos = new FileOutputStream("c:\\splitfiles\\"+(count++)+".part");
			fos.write(buf,0,len);//当数组满了就进行切割
			fos.close();
		}
		
		fis.close();
		
	}

}

对象的序列化：目的：将一个具体的对象进行持久化，写入到硬盘上。

注意：静态数据不能被序列化，因为静态数据不在堆内存中，是存储在静态方法区中。

如何将非静态的数据不进行序列化？用transient关键字修饰此变量即可。

Serializable：用于启动对象的序列化功能，可以强制让指定类具备序列化功能，该接口中没有成员，这是一个标记接口。这个标记接口用于给序列化类提供UID。这个uid是依据类中的成员的数字签名进行运行获取的。如果不需要自动获取一个uid，可以在类中，手动指定一个名称为serialVersionUID id号。依据编译器的不同，或者对信息的高度敏感性。最好每一个序列化的类都进行手动显示的UID的指定。

package pract;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

public class ObjectStreamDemo {
	
	public static void main(String[] args)throws Exception {
		writeObj();
		readObj();
	}
	public static void readObj()throws Exception{
		ObjectInputStream ois = new ObjectInputStream(new FileInputStream("obj.txt"));
		//开始读取文件内容
		Person p = (Person)ois.readObject();//转型

		System.out.println(p);
		ois.close();
	}

	public static void writeObj()throws IOException{
		ObjectOutputStream oos = 
			new ObjectOutputStream(new FileOutputStream("obj.txt"));

		oos.writeObject(new Person("lisi0",399,"kr"));//写入一个对象。

		oos.close();
	}
}
class Person implements Serializable{
	
	public static final long serialVersionUID = 42L;

	private String name;
	transient int age;
	static String country = "cn";
	Person(String name,int age,String country){
		this.name = name;
		this.age = age;
		this.country = country;
	}
	
	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public String toString()
	{
		return name+":"+age+":"+country;
	}
}

Zero_120_1

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
黑马程序员java之IO_2

------- android培训、java培训、期待与您交流！ ----------流的操作规律：1，明确源和目的。数据源：就是需要读取，可以使用两个体系：InputStream、Reader；数据汇：就是需要写入，可以使用两个体系：OutputStream、Writer；2，操作的数据是否是纯文本数据？如果
复制链接

扫一扫