黑马程序员--Java基础学习(IO流及字符编码)第二十一天

最新推荐文章于 2024-09-15 19:46:31 发布

shdoshzdd

最新推荐文章于 2024-09-15 19:46:31 发布

阅读量753

点赞数

文章标签：黑马程序员 java 面向对象 io流

本文链接：https://blog.csdn.net/shdoshzdd/article/details/47905705

版权

------ Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

Java基础学习(IO流及字符编码)第二十一天

一，对象的序列化

操作对象：ObjectInputStream 与 ObjectOutputStream。

把对象存储在硬盘上成为对象的持久化存储。

注：静态成员不能序列化，只能对堆内存中的数据序列化。

transient修饰的数据也不能序列化，保证其值在堆内存中，而不再文件中。

对对象的存储与取出代码示例：

import java.io.*;
class ObjectStreamDemo 
{
	public static void main(String[] args) throws Exception
	{
		writeObj();
	}
	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("lisi",39,"kr"));

		oos.close();
	}
}

二，管道流

管道流：PipedInputStream和PipedOutputStream。

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

1，集合中涉及到IO流的是Properties。

2，IO流中涉及到多线程的是管道流。

管道流操作代码示例：

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();
	}
}

三，IO包中其他类

RandomAccessFile类，作用：随机访问文件，自身具备读写的方法。通过skipBytes(int x)，seek(int x) 来达到随机访问。

该类不算是IO体系中子类。
而是直接继承自Object。
但是它是IO包中成员。因为它具备读和写功能。
内部封装了一个数组，而且通过指针对数组的元素进行操作。
可以通过getFilePointer获取指针位置。
同时可以通过seek改变指针的位置。
其实完成读写的原理就是内部封装了字节输入流和输出流。
通过构造函数可以看出，该类只能操作文件。
而且操作文件还有模式:只读r，，读写rw等。
如果模式为只读r。不会创建文件。会去读取一个已存在的文件，如果该文件不存在，则会出现异常。
如果模式为rw。操作的文件不存在，会自动创建。如果存在则不会覆盖。

RandomAccessFile代码示例：

import java.io.*;

class RandomAccessFileDemo 
{
	public static void main(String[] args) throws IOException
	{
		writeFile();

		System.out.println(Integer.toBinaryString(258));

		readFile();

		writeFile_2();
	}
	
	public static void readFile()throws IOException
	{
		RandomAccessFile raf = new RandomAccessFile("ran.txt","r");
		//raf.write("hhah".getBytes());

		//调整对象中指针。
		//raf.seek(8*0);

		//跳过指定的字节数。
		raf.skipBytes(8);

		byte[] buf = new byte[4];

		raf.read(buf);

		String name = new String(buf);
		
		int age = raf.readInt();
		
		System.out.println("name="+name);

		System.out.println("age="+age);

		raf.close();
	
	}

	public static void writeFile_2()throws IOException
	{
		RandomAccessFile raf = new RandomAccessFile("ran.txt","rw");

		raf.seek(8*3);
		raf.write("周期".getBytes());
		raf.writeInt(103);

		raf.close();

	}
	public static void writeFile()throws IOException
	{
		RandomAccessFile raf = new RandomAccessFile("ran.txt","rw");

		raf.write("李四".getBytes());
		//raf.write(97);
		//raf.write(258);
		raf.writeInt(97);
		raf.write("王五".getBytes());
		raf.writeInt(99);

		raf.close();
	}
}

DataStream：操作基本数据类型的流对象。

1，操作基本数据类型：DataInputStream 与 DataOutputStream。

2，操作字节数组：ByteArrayInputStream 与 ByteArrayOutputStream。

3，操作字符数组：CharArrayReader 与 CharArrayWirter。

4，操作字符串：String Reader 与 StringWriter。

DataInputStream 与 DataOutputStream代码示例：

import java.io.*;
class DataStreamDemo 
{
	public static void main(String[] args) throws IOException
	{
		writeData();
		readData();
		writeUTFDemo();

		OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("utf.txt"),"utf-8");

		osw.write("你好");
		osw.close();

		readUTFDemo();

	}
	public static void readUTFDemo()throws IOException
	{
		DataInputStream dis = new DataInputStream(new FileInputStream("utfdata.txt"));

		String s = dis.readUTF();
		System.out.println(s);
		dis.close();
	}
	public static void writeUTFDemo()throws IOException
	{
		DataOutputStream dos = new DataOutputStream(new FileOutputStream("utfdata.txt"));

		dos.writeUTF("你好");

		dos.close();
	}
	public static void readData() throws IOException
	{
		DataInputStream dis = new DataInputStream(new FileInputStream("data.txt"));

		int num = dis.readInt();
		boolean b = dis.readBoolean();
		double d = dis.readDouble();

		System.out.println("num="+num);
		System.out.println("b="+b);
		System.out.println("d="+d);
	}
	public static void writeData()throws IOException
	{
		DataOutputStream dos = new DataOutputStream(new FileOutputStream("data.txt"));
		
		dos.writeInt(234);
		dos.writeBoolean(true);
		dos.writeDouble(9887.54);
		
		dos.close();
	}
}

ByteArrayInputStream 与 ByteArrayOutputStream

用于操作字节数组的流对象。
ByteArrayInputStream : 在构造的时候，需要接收数据源，而且数据源是一个字节数组。
ByteArrayOutputStream :在构造时候，不用定义数据目的，因为该对象中已经内部封装了可变长度的字节数组。
这就是数据目的地。
因为这两个流对象都操作的数据，并没有使用系统资源。
所以，不用进行close关闭。
在流操作规律讲解时：
源设备：
键盘System.in，硬盘FileStream，内存ArrayStream。
目的设备：
控制台System.out，硬盘FileStream，内存ArrayStream。
用流的读写思想来操作数组。

import java.io.*;
class ByteArrayStream 
{
	public static void main(String[] args) 
	{
		//数据源。
		ByteArrayInputStream bis = new ByteArrayInputStream("ABCDEF".getBytes());

		//数据目的。
		ByteArrayOutputStream bos = new ByteArrayOutputStream();

		int by = 0;

		while((by=bis.read())!=-1)
		{
			bos.write(by);
		}

		System.out.println(bos.size());
		System.out.println(bos.toString());

		//bos.writeTo(new FileOutputStream("a.txt"));只这一句设计异常。
	}

}

四，字节编码

字符流的出现为了方便操作字符，更重要的是加入了编码转换，通过子类转换流完成，InputStreamReader，OutputStreamWirter。在两个对象进行构造的时候可以加入字符集。

常见的编码：ASCII，ISO8859-1，GB2312，GBK，Unicode，UTF-8。

编码使用代码示例：

import java.io.*;

class EncodeStream 
{
	public static void main(String[] args) throws IOException
	{
		writeText();
		readText();
	}
	
	public static void readText()throws IOException
	{
		InputStreamReader isr = new InputStreamReader(new FileInputStream("gbk.txt"),"GBK");

		char[] buf = new char[10];
		int len = isr.read(buf);

		String str = new String(buf,0,len);

		System.out.println(str);

		isr.close();
	}

	public static void writeText()throws IOException
	{
		OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("gbk.txt"),"GBK");

		osw.write("你好");

		osw.close();
	}
}

字符编码：编码：字符串编程数组。解码：字节数组编程字符串。

代码示例：

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

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

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


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


*/

import java.util.*;
class EncodeDemo 
{
	public static void main(String[] args) throws Exception
	{
		String s = "你好";
		
		byte[] b1 = s.getBytes("GBK");//可能出现错误编码异常。
		
		System.out.println(Arrays.toString(b1));
		String s1 = new String(b1,"utf-8");
		System.out.println("s1="+s1);

		//对s1进行iso8859-1编码。
		byte[] b2 = s.getBytes("utf-8");
		System.out.println(Arrays.toString(b2));
		
		/*
		String s2 = new String(b2,"utf-8");
		
		byte[] b3 = s.getBytes("gbk");
		String s3 = new String(b3,"gbk");
		System.out.println("s3="+s3);
		*/

		String s2 = new String(b2,"GBK");
		System.out.println("s2="+s2);
		
		//System.out.println("s1="+s1);
		//System.out.println(Arrays.toString(b1));
	}
}

练习：强行反转比较器。学生成绩按成绩总和排序放入txt文件中。

代码示例：

/*
有五个学生，每个学生有3门课的成绩，
从键盘输入以上数据(包括姓名，三门课成绩)，
输入的格式：如：zhangsan,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);
	}
}