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

import java.io.*;
/*
RandomAccessFile 该类不是算是IO体系中子类。
而是直接继承自Object。但是它是IO包中成员。因为它具备读和写功能。
内部封装了一个数组，而且通过指针对数组的元素进行操作。
可以通过getFilePointer获取指针位置，
同时可以通过seek改变指针的位置。
其实完成读写的原理就是内部封装了字节输入流和输出流。通过构造函数可以看出，该类只能操作文件。
而且操作文件还有模式：只读r，，读写rw等。如果模式为只读 r。不会创建文件。会去读取一个已存在文件，如果该文件不存在，则会出现异常。
如果模式rw。操作的文件不存在，会自动创建。如果存则不会覆盖。 */
class RandomAccessFileDemo
{
public static void main(String[] args) throws IOException
{
//writeFile_2();
//readFile(); //System.out.println(Integer.toBinaryString(258)); } public static void readFile()throws IOException
{
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();
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*0);
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.writeInt(97);
raf.write("王五".getBytes());
raf.writeInt(99); raf.close();
}
}

/*
DataInputStream与DataOutputStream 可以用于操作基本数据类型的数据的流对象。 */
import java.io.*;
class DataStreamDemo
{
public static void main(String[] args) throws IOException
{
//writeData();
//readData(); //writeUTFDemo(); // OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("gbk.txt"),"gbk");
//
// osw.write("你好");
// osw.close(); // readUTFDemo(); }
public static void readUTFDemo()throws IOException
{
DataInputStream dis = new DataInputStream(new FileInputStream("utf.txt")); String s = dis.readUTF(); System.out.println(s);
dis.close();
} public static void writeUTFDemo()throws IOException
{
DataOutputStream dos = new DataOutputStream(new FileOutputStream("utfdate.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); dis.close();
}
public static void writeData()throws IOException
{
DataOutputStream dos = new DataOutputStream(new FileOutputStream("data.txt")); dos.writeInt(234);
dos.writeBoolean(true);
dos.writeDouble(9887.543); dos.close(); ObjectOutputStream oos = null;
oos.writeObject(new O());
}
}

/*
用于操作字节数组的流对象。 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("ABCDEFD".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")); }
}

/*
编码：字符串变成字节数组。
解码：字节数组变成字符串。 String-->byte[]; str.getBytes(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 = s1.getBytes("utf-8");
System.out.println(Arrays.toString(b2)); String s2 = new String(b2,"gbk"); System.out.println("s2="+s2); }
}

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("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();
}
public static void writeText()throws IOException
{
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("utf.txt"),"UTF-8"); osw.write("你好"); osw.close();
} }

有五个stu，每个stu有3门课的成绩，
从键盘输入以上数据（包括姓名，三门课成绩），
输入的格式：如：zhagnsan，30，40，60计算出总成绩，
并把stu的信息和计算出的总分数高低顺序存放在磁盘文件"stud.txt"中。 1，描述stu对象。
2，定义一个可操作stu对象的工具类。思想：
1，通过获取键盘录入一行数据，并将该行中的信息取出封装成stu对象。
2，因为stu有很多，那么就需要存储，使用到集合。因为要对STU的总分排序。
所以可以使用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 bu = new BufferedWriter(new FileWriter("stuinfo.txt"));

bu.write(stu.getSum()+"");
bu.newLine();
bu.flush();
} bu.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);
}
}