黑马程序眼-----------IO流（下）

最新推荐文章于 2023-11-15 23:02:38 发布

lv13335152486

最新推荐文章于 2023-11-15 23:02:38 发布

阅读量274

点赞数

分类专栏： JAVA基础日记文章标签： java基础学习技术博客

本文链接：https://blog.csdn.net/lv13335152486/article/details/45190197

版权

JAVA基础日记专栏收录该内容

11 篇文章 0 订阅

订阅专栏

-----------Android培训、java培训、期待与您交流------------

IO流（下）

一、File类

用来将文件或者文件夹封装成对象

方便对文件与文件夹的属性信息进行操作。

File对象可以作为参数传递给流的构造函数

File类常见方法：

1、创建

boolean createNewFile():在指定位置创建文件，如果该文件已经存在，则不创建，返回false。

和输出流不一样，输出流对象一建立创建文件。而且文件已经存在，会覆盖。

boolean mkdir():创建文件夹。

boolean mkdirs():创建多级文件夹。

2、删除

boolean delete()：删除失败返回false。如果文件正在被使用，则删除不了返回falsel。

void deleteOnExit();在程序退出时删除指定文件。

3，判断

boolean exists() :文件是否存在.

isFile(): 是否是文件

isDirectory(); 是否是文件夹

isHidden(); 是否隐藏

isAbsolute(); 是否是绝对路径

4、获取信息。

getName():

getPath():

getParent(): 获取父路径

getAbsolutePath()

long lastModified() 最后一次修改的时间

long length()

列出指定目录下文件或者文件夹，包含子目录中的内容。

也就是列出指定目录下所有内容。

因为目录中还有目录，只要使用同一个列出目录功能的函数完成即可。

在列出过程中出现的还是目录的话，还可以再次调用本功能。

也就是函数自身调用自身。

这种表现形式，或者编程手法，称为递归。

递归要注意：

1、限定条件。

2、要注意递归的次数。尽量避免内存溢出。

二、Properties类

Properties是hashtable的子类。

也就是说它具备map集合的特点。而且它里面存储的键值对都是字符串。

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

该对象的特点：可以用于键值对形式的配置文件。

那么在加载数据时，需要数据有固定格式：键=值。

可以操作硬盘上的数据

Properties基本操作：

1、设置和获取元素：

//	设置和获取元素。
	public static void setAndGet()
	{
		Properties prop = new Properties();

		prop.setProperty("zhangsan","30");
		prop.setProperty("lisi","39");

		System.out.println(prop);
		String value = prop.getProperty("lisi");
		System.out.println(value);
			
		prop.setProperty("lisi",89+"");

		Set<String> names = prop.stringPropertyNames();
		for(String s : names)
		{
			System.out.println(s+":"+prop.getProperty(s));
		}
	}

2、将流中的数据存储到集合中

想要将info.txt中键值数据存到集合中进行操作。

1、用一个流和info.txt文件关联。

2、读取一行数据，将该行数据用"="进行切割。

3、等号左边作为键，右边作为值。存入到Properties集合中即可

public static void method_1()throws IOException
	{
		BufferedReader bufr = new BufferedReader(new FileReader("info.txt"));

		String line = null;
		Properties prop = new Properties();

		while((line=bufr.readLine())!=null)
		{
			String[] arr = line.split("=");
			prop.setProperty(arr[0],arr[1]);
		}
		bufr.close();
		System.out.println(prop);
	}

方法二：

public static void method_2()throws IOException
	{
		Properties prop = new Properties();
		FileInputStream fis = new FileInputStream("info.txt");

		//将流中的数据加载进集合。
		prop.load(fis);
		prop.list(System.out);
		fis.close();
	}

三、IO包中的其他类

打印流

PrintWriter与PrintStream

可以直接操作输入流和文件。

序列流

SequenceInputStream

对多个流进行合并。

操作对象

ObjectInputStream与ObjectOutputStream

被操作的对象需要实现Serializable （标记接口);

静态不能被序列化。

字节打印流：
PrintStream
构造函数可以接收的参数类型：
1、file对象。File
2、字符串路径。String
3、字节输出流。OutputStream

字符打印流：
PrintWriter
构造函数可以接收的参数类型：
1、file对象。File
2、字符串路径。String
3、字节输出流。OutputStream
4、字符输出流，Writer。

管道流

PipedInputStream和PipedOutputStream

输入输出可以直接进行连接，通过结合线程使用。

输入输出在两个线程中，使用阻塞式方法
管道流示例：

import java.io.*;
class Read implements Runnable
{
	private PipedInputStream in;
	Read(PipedInputStream in)
	{
		this.in = in;
	}
	public void run()
	{
		try
		{
			byte[] buf = new byte[1024];

			System.out.println("读取前。。没有数据阻塞");
			int len = in.read(buf);
			System.out.println("读到数据。。阻塞结束");
			String s= new String(buf,0,len);
			System.out.println(s);
			in.close();
		}
		catch (IOException e)
		{
			throw new RuntimeException("管道读取流失败");
		}
	}
}
class Write implements Runnable
{
	private PipedOutputStream out;
	Write(PipedOutputStream out)
	{
		this.out = out;
	}
	public void run()
	{
		try
		{
			System.out.println("开始写入数据，等待6秒后。");
			Thread.sleep(6000);
			out.write("piped lai la".getBytes());
			out.close();
		}
		catch (Exception e)
		{
			throw new RuntimeException("管道输出流失败");
		}
	}
}
class  PipedStreamDemo
{
	public static void main(String[] args) throws IOException
	{

		PipedInputStream in = new PipedInputStream();
		PipedOutputStream out = new PipedOutputStream();
		in.connect(out);

		Read r = new Read(in);
		Write w = new Write(out);
		new Thread(r).start();
		new Thread(w).start();
	}
}

执行结果：

RandomAccessFile

该类不算是IO体系中子类。

而是直接继承自Object。

但是它是IO包中成员。因为它具备读和写功能。

内部封装了一个数组，而且通过指针对数组的元素进行操作。

可以通过getFilePointer获取指针位置，

同时可以通过seek改变指针的位置。

其实完成读写的原理就是内部封装了字节输入流和输出流。

通过构造函数可以看出，该类只能操作文件。

而且操作文件还有模式：只读r，，读写rw等。

如果模式为只读 r。不会创建文件。会去读取一个已存在文件，如果该文件不存在，则会出现异常。

如果模式rw。操作的文件不存在，会自动创建。如果存在则不会覆盖。

操作基本数据类型

DataInputStream与DataOutputStream

操作字节数组

ByteArrayInputStream与ByteArrayOutputStream

操作字符数组

CharArrayReader与CharArrayWrite

操作字符串

StringReader 与StringWriter

用于操作字节数组的流对象。

ByteArrayInputStream ：在构造的时候，需要接收数据源，。而且数据源是一个字节数组。

ByteArrayOutputStream：在构造的时候，不用定义数据目的，因为该对象中已经内部封装了可变长度的字节数组。

这就是数据目的地。

因为这两个流对象都操作的数组，并没有使用系统资源。

所以，不用进行close关闭。

在流操作规律讲解时：

源设备：

键盘 System.in，硬盘 FileStream，内存 ArrayStream。

目的设备：

控制台 System.out，硬盘FileStream，内存 ArrayStream。

用流的读写思想来操作数组。

四、字符编码

字符流的出现为了方便操作字符。

更重要是的加入了编码转换。

通过子类转换流来完成。

InputStreamReader

OutputStreamWriter

在两个对象进行构造的时候可以加入字符集。

编码表的由来：

计算机只能识别二进制数据，早期由来是电信号。

为了方便应用计算机，让它可以识别各个国家的文字。

就将各个国家的文字用数字来表示，并一一对应，形成一张表。

这就是编码表。

常见的编码表：

ASCII：美国标准信息交换码。

用一个字节的7位可以表示。

ISO8859-1：拉丁码表。欧洲码表

用一个字节的8位表示。

GB2312：中国的中文编码表。

GBK：中国的中文编码表升级，融合了更多的中文文字符号。

Unicode：国际标准码，融合了多种文字。

所有文字都用两个字节来表示,Java语言使用的就是unicode

UTF-8：最多用三个字节来表示一个字符。

转换流的编码应用：

可以将字符以指定编码格式存储。

可以对文本数据指定编码格式来解读。

指定编码表的动作由构造函数完成

编码：字符串变成字节数组。

String-->byte[]; str.getBytes(charsetName);

解码：字节数组变成字符串。

byte[] -->String: new String(byte[],charsetName);

练习：

有五个学生，每个学生有3门课的成绩，
从键盘输入以上数据（包括姓名，三门课成绩），
输入的格式：如：zhagnsan，30，40，60计算出总成绩，
并把学生的信息和计算出的总分数高低顺序存放在磁盘文件"stud.txt"中。
1、描述学生对象。
2、定义一个可操作学生对象的工具类。

思想：

1、通过获取键盘录入一行数据，并将该行中的信息取出封装成学生对象。

2、因为学生有很多，那么就需要存储，使用到集合。因为要对学生的总分排序。

所以可以使用TreeSet。

3、将集合的信息写入到一个文件中。

代码如下：

import java.io.*;
import java.util.*;
class Student implements Comparable<Student>
{
	private String name;
	private int ma,cn,en;
	private int sum;

	Student(String name,int ma,int cn,int en)
	{
		this.name = name;
		this.ma = ma;
		this.cn = cn;
		this.en = en;
		sum = ma + cn + en;
	}
	public int compareTo(Student s)
	{
		int num = new Integer(this.sum).compareTo(new Integer(s.sum));
		if(num==0)
			return this.name.compareTo(s.name);
		return num;
	}
	public String getName()
	{
		return name;
	}
	public int getSum()
	{
		return sum;
	}
	public int hashCode()
	{
		return name.hashCode()+sum*78;
	}
	public boolean equals(Object obj)
	{
		if(!(obj instanceof Student))
			throw new ClassCastException("类型不匹配");
		Student s = (Student)obj;

		return this.name.equals(s.name) && this.sum==s.sum;
	}
	public String toString()
	{
		return "student["+name+", "+ma+", "+cn+", "+en+"]";
	}
}
class StudentInfoTool
{
	public static Set<Student> getStudents()throws IOException//默认比较器
	{
		return getStudents(null);
	}
	public static Set<Student> getStudents(Comparator<Student> cmp)throws IOException//自定义比较器
	{
		BufferedReader bufr = 
			new BufferedReader(new InputStreamReader(System.in));

		String line = null;		
		Set<Student> stus  = null;
		if(cmp==null)
			stus = new TreeSet<Student>();
		else
			stus = new TreeSet<Student>(cmp);
		while((line=bufr.readLine())!=null)
		{
			if("over".equals(line))
				break;
			
			String[] info = line.split(",");		
			Student stu = new Student(info[0],Integer.parseInt(info[1]),
						Integer.parseInt(info[2]),
						Integer.parseInt(info[3]));			
			stus.add(stu);
		}
		bufr.close();
		return stus;
	}

	public static void write2File(Set<Student> stus)throws IOException//向文件中写入学生信息
	{
		BufferedWriter bufw = new BufferedWriter(new FileWriter("stuinfo.txt"));

		for(Student stu : stus)
		{
			bufw.write(stu.toString()+"\t");
			bufw.write(stu.getSum()+"");
			bufw.newLine();
			bufw.flush();
		}
		bufw.close();
	}
}
class StudentInfoTest 
{
	public static void main(String[] args) throws IOException
	{
		Comparator<Student> cmp = Collections.reverseOrder();//比较器强行逆转

		Set<Student> stus = StudentInfoTool.getStudents(cmp);

		StudentInfoTool.write2File(stus);
	}
}

lv13335152486

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
黑马程序眼-----------IO流（下）

IO流（下）一、File类用来将文件或者文件夹封装成对象方便对文件与文件夹的属性信息进行操作。 File对象可以作为参数传递给流的构造函数File类常见方法：1、创建boolean createNewFile():在指定位置创建文件，如果该文件已经存在，则不创建，返回false。和输出流不一样，输出流对象一建立创建文件。而且文件已经存
复制链接

扫一扫