JAVASE----16----IO流_3-优快云博客

本文链接：https://blog.youkuaiyun.com/lc635408136/article/details/8894260

一,操作对象

package IO2;

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

public class ObjectStreamDemo {

	/**
	 * @param args
	 */
	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 Exception {
		ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("obj.txt"));
		oos.writeObject(new Person("lisi",339,"kr"));
		oos.close();
       
	}

}

package IO2;

import java.io.Serializable;

//序列化已实现对象的持久化
public class Person implements Serializable{
	private String name;
	transient int age;    //此属性不会被序列化
	static String country="cn"; //静态也不能被序列化
	public Person(String name, int age, String country) {
		super();
		this.name = name;
		this.age = age;
		this.country=country;
	}
	@Override
	public String toString() {
	return name+":"+age+":"+country;
	}
	
	

}

二，IO包中的其他类

1，管道流：

package IO2;

import java.io.IOException;
import java.io.PipedInputStream;
import java.io.PipedOutputStream;

public class PipedStreamDemo {

	/**
	 * @param args
	 * @throws IOException 
	 */
	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();
	}

}

class Read implements Runnable
{

	private  PipedInputStream in;
	
	Read( PipedInputStream in)
	{
		this.in=in;
	}
	@Override
	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) {
			
			e.printStackTrace();
		}
	
		
	}
	
	}

class Write implements Runnable
{

	private  PipedOutputStream out;
	
	Write( PipedOutputStream out)
	{
		this.out=out;
	}
	@Override
	public void run() {
		
		try {
			System.out.println("开始写入数据，等待5秒后");
			Thread.sleep(5000);
			out.write("piped come ".getBytes());
			out.close();
		} catch (Exception e) {
			e.printStackTrace();
		}
	
	}
	
	}

2，RandomAccessFile

该类不算是IO体系的子类，二是直接继承自Object。
但是他是IO包中成员，因为它具备读和写功能。内部封装了一个数组，而且通过指针对数组的元素进行操作。可以通过getFilePointer获取指针位置，同事可以根据seek改变指针位置。
其实完成读写的原理就是内部封装了字节输入流和输出流
从构造函数可以看出，该类只能操作文件。
而且操作文件还有模式。只读 r, 读写 rw 等，

如果模式为只读r，不会创建文件，回去读取一个已存在的文件，如果不存在，则会出现异常。
如果模式为rw，操作的文件不存在会自动创建，如果存在则不会覆盖。

package IO2;

import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.RandomAccessFile;

public class RandomAccessFileDemo {

	/**
	 * @param args
	 * @throws IOException 
	 */
	public static void main(String[] args) throws IOException {
		
		//writeFile();
		readFile();
	}
	
	public static void writeFile() throws IOException
	{
		
		RandomAccessFile raf=new RandomAccessFile("ran.txt", "rw");
		raf.write("李四".getBytes());
		raf.writeInt(97);
		raf.write("王五".getBytes());
		raf.writeInt(99);
		raf.close();
	}
	
	public static void readFile() throws IOException
	{
		//r: 只读
		RandomAccessFile raf=new RandomAccessFile("ran.txt","r");
		//调整对象中的指针
		raf.seek(8*1);
		 //跳过指定的字节数
		//raf.skipBytes(8);
		byte[] buf=new byte[4];
		raf.read(buf);
		String name=new String (buf);
		int age=raf.readInt(); //一次读4个字节
		System.out.println("name="+name);
		System.out.println("age="+age);
		raf.close();
	}
	
	

}

3，操作基本数据类型的流对象

DataInputStream 与DataOutputStream
可以用于操作基本数据类型的流对象

package IO2;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;

public class DataStreamDemo {

	/* 
	 * 
	 */
	public static void main(String[] args) throws Exception {
		readdata();
		//writedata();
	}
	public static void writedata() throws Exception {
		DataOutputStream dos=new DataOutputStream(new FileOutputStream("data.txt"));
		//写入13个字节
		dos.writeInt(234);
		dos.writeBoolean(true);
		dos.writeDouble(2343.234); 
		dos.close();
	}
	public static void readdata() throws Exception {
		
		DataInputStream dis=new DataInputStream(new FileInputStream("data.txt"));
		int num=dis.readInt();
		boolean b=dis.readBoolean();
		double d=dis.readDouble();
		System.out.print(num+","+b+","+d);
		dis.close();
	}
	

}

4，操作字节数组的流对象

ByteArrayInputStream: 在构造的时候，需要接受数据源，而且数据源是一个字节数组
ByteArrayOutputStream: 在构造的时候不用定义数据目的，因为该对象中已经封装了可变长度的字节数组，这就是数据目的。
因为这2个流对象都操作数组，并没有使用系统资源，所以不用进行close关闭。

在写流操作规律时，

源设备：

键盘：System.in 硬盘: FileStream 内存 ArrayStream
目的设备：

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

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

package IO2;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.FileOutputStream;

public class ByteArrayStream {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		  ByteArrayInputStream  bis=new ByteArrayInputStream("DFSDFSF".getBytes());
		  
          ByteArrayOutputStream  bos=new ByteArrayOutputStream();
          
          //System.out.println(bos.size());
          int by=0;
          while((by=bis.read())!=-1)
          {
        	  bos.write(by);
          }
          System.out.println(bos.toString());
          //bos.writeTo(new FileOutputStream("a.txt"));
	}

}

三，编码

1，转换流的编码

package IO2;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.UnsupportedEncodingException;

public class EncodeStream {

	/**
	 * @param args
	 */
	public static void main(String[] args) throws IOException {
		//writeText();
		readText();
	}
	
	public static void writeText() throws IOException {
	 OutputStreamWriter osw=new OutputStreamWriter(new FileOutputStream("utf.txt"),"UTF-8");
	 osw.write("你好");
	 osw.close();
	}
	public static void readText() throws IOException {
		InputStreamReader  isr=new InputStreamReader(new FileInputStream("utf.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();
		}

}

结果：

2，字符编码

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

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

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

package IO2;

import java.io.UnsupportedEncodingException;
import java.util.Arrays;

public class EncodeDemo {

	/**
	 * @param args
	 * @throws UnsupportedEncodingException 
	 */
	public static void main(String[] args) throws UnsupportedEncodingException {
		
           String s="你好";
           byte[] b1=s.getBytes("utf-8");
           System.out.println(Arrays.toString(b1));
           String s1=new String(b1,"gbk");
           System.out.println("s1="+s1);
	}

}

package IO2;

import java.io.UnsupportedEncodingException;
import java.util.Arrays;

public class EncodeDemo {

	/**
	 * @param args
	 * @throws UnsupportedEncodingException 
	 */
	public static void main(String[] args) throws UnsupportedEncodingException {
		
           String s="你好";
           byte[] b1=s.getBytes("GBK");
           System.out.println(Arrays.toString(b1));
           String s1=new String(b1,"ISO8859-1");
           System.out.println("s1="+s1);
           //对s1 进行iso8859-1编码
           byte[]b2=s1.getBytes("ISO8859-1");
           System.out.println(Arrays.toString(b2));
           //再解码
           String s2=new String(b2,"GBK");
           System.out.println("s2="+s2);
           
	}

}

值得注意的是，在GBK 和 UTF-8 转换的时候因为都能识别中文所以会出现问题。

package IO2;

import java.io.UnsupportedEncodingException;
import java.util.Arrays;

public class EncodeDemo {

	/**
	 * @param args
	 * @throws UnsupportedEncodingException 
	 */
	public static void main(String[] args) throws UnsupportedEncodingException {
		
         String  s="联通";
         byte[] by=s.getBytes("gbk");
         for(byte b :by)
         {
        	 System.out.println(Integer.toBinaryString(b&255));
         }
           //联通2进制形式跟U-8编码规律一致，所以记事本会查U-8编码表解，这是个非常特殊的词语
	}

}

练习：有5个学生，每个学生有3门课的成绩，从键盘输入以上数据（包括姓名，三门课成绩），输入的格式：如：zhangsan，60，70，80计算出总成绩，
并把学生的信息和计算出的总分数高低顺序存放在磁盘文件“stud.txt”中

1，描述学生对象
2，定义一个可以操作学生对象的工具类

思想：
1，通过获取键盘录入一行数据，并将该行中信息取出封装成学生对象。
2，因为学生有很多，那么就需要存储，使用到集合。因为要对学生的总分排序。
3，将集合的信息写入到一个文件中。

package IO2;

public class Student implements Comparable<Student> {

	private String name;
	private int ma, cn, en;
	private int sum;

	public Student(String name, int ma, int cn, int en) {
		super();
		this.name = name;
		this.ma = ma;
		this.cn = cn;
		this.en = en;
		sum = ma + cn + en;
	}

	public String getName() {
		return name;
	}

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

	public int getMa() {
		return ma;
	}

	public void setMa(int ma) {
		this.ma = ma;
	}

	public int getCn() {
		return cn;
	}

	public void setCn(int cn) {
		this.cn = cn;
	}

	public int getEn() {
		return en;
	}

	public void setEn(int en) {
		this.en = en;
	}

	public int getSum() {
		return sum;
	}

	public void setSum(int sum) {
		this.sum = sum;
	}

	@Override
	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;
	}

	@Override
	public int hashCode() {

		return name.hashCode() + sum * 78;
	}

	@Override
	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;
	}

	@Override
	public String toString() {
		return "Student [name=" + name + ", ma=" + ma + ", cn=" + cn + ", en="
				+ en + "]";
	}

}

package IO2;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Comparator;
import java.util.Set;
import java.util.TreeSet;

public class StudentInfoTool {
	public static Set<Student>getSutends() throws NumberFormatException, IOException
	{
		return getSutends(null); 
	}
	
	public static Set<Student>getSutends(Comparator<Student> cmp) throws NumberFormatException, 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 writefile(Set<Student> stus) throws IOException
	{
		BufferedWriter  bfw=new BufferedWriter(new FileWriter("stu.txt"));
		for(Student s:stus)
		{
			bfw.write(s.toString()+"\t");
			bfw.write(s.getSum()+"");
			bfw.newLine();
			bfw.flush();
		}
		bfw.close();
	}
	
}

package IO2;

import java.io.IOException;
import java.util.Collections;
import java.util.Comparator;
import java.util.Set;

public class StudentInfoTest {

	/**
	 * @param args
	 * @throws IOException 
	 * @throws NumberFormatException 
	 */
	public static void main(String[] args) throws NumberFormatException, IOException {
		Comparator<Student> cmp=Collections.reverseOrder();
		Set<Student> stus=StudentInfoTool.getSutends(cmp);
		 StudentInfoTool.writefile(stus);
	}

}