Java基础<十六>---> IO之其他流对象

第一  File类

一、概述：File类是有文件或文件件封装而来的对象，可以操作其属性信息，这个类的出现弥补了流的不足，流只能操作数据

1、特点：

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

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

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

2、File类常见方法：
1、创建。
boolean createNewFile():在指定位置创建文件，如果该文件已经存在，则不创建，返回false。
和输出流不一样，输出流对象一建立创建文件。而且文件已经存在，会覆盖。
boolean mkdir():创建文件夹。
boolean mkdirs():创建多级文件夹。
2、删除。
boolean delete()：删除失败返回false。如果文件正在被使用，则删除不了返回false。
void deleteOnExit();在程序退出时删除指定文件。
3、判断。
boolean exists() :文件是否存在.
isFile():是否是文件
isDirectory();是否是目录
isHidden();是否是隐藏的对象
isAbsolute();//判断是否是绝对路径
4、获取信息。
getName():获取对象名字
getPath():获取路径，存的是什么路径就是什么路径
getParent():文件夹路径
getAbsolutePath() 获取绝对路径getpath()+getparent();
long lastModified() 文件最后一次被修改的时间
long length() 返回文件的长度

实例：

public class FileDemo {public static void main(String[] args) {//consMethod();//method();//listFilesDemo();//File dir = new File("E:\\develop\\eclipse space\\android workspace\\Test_java\\src");//showDir(dir);//method_1();//method_2(100);}/** * 获取指定文件名称的文件名 */public static void method(){File dir = new File("C:\\");String[] names = dir.list(new FilenameFilter() {@Overridepublic boolean accept(File dir, String name) {//System.out.println("dir:" + dir + ".....name::" + name);return name.endsWith(".txt");}});System.out.println("list.len:::" + names.length);for(String name : names){System.out.println(name);}}/** * listFiles()方法返回File对象 */public static void listFilesDemo(){File dir = new File("C:\\");File[] files = dir.listFiles();for(File f : files){System.out.println(f.getName() + "..." + f.length());}}/** * 构造方法演示 */public static void consMethod(){//创建file对象，可以将已有的和未出现的文件或目录封装成对象File f1 = new File("C:" + File.separator + "a.txt");//File.separator跨平台的目录分隔符File f2 = new File("c:\\abc","b.txt");//C:\\abc\\b.txt一样，但是两个参数更灵活，可以目录不变，文件变File d = new File("c:\\abc");File f3 = new File(d,"c.txt");System.out.println("f1: " + f1);System.out.println("f2: " + f2);System.out.println("f3: " + f3);}/** * 演示File类的一些常用方法 */public static void method_1(){File f = new File("file.txt");//exists()方法查看文件或目录是否存在System.out.println("exists:" + f.exists());//测试应用程序是否可以执行此抽象路径名表示的文件。System.out.println("canExecute:" + f.canExecute());//创建文件夹//File dir = new File("C:\\ab\\c\\v\\g");//System.out.println("mkdir:" + dir.mkdir());//最多只能创建两级目录,已经存在或失败返回false//System.out.println("mkdirs:" + dir.mkdirs());//创建多级目录File f1 = new File("c:\\ab\\d.java");try {f1.createNewFile();//createNewFile创建新文件} catch (IOException e) {e.printStackTrace();}//判断文件对象是否是文件或目录时，必须要先判断文件对象封装内容是否存在//通过exists方法System.out.println("isDir:" + f1.isDirectory());//是否是目录System.out.println("isFile:" + f1.isFile());//是否是文件//获取路径System.out.println("path: " + f1.getPath());System.out.println("abspath: " + f1.getAbsolutePath());System.out.println("parent: " + f1.getParent());//该方法返回的是绝对路径中的父目录。如果获取的是相对路径，返回null。//如果相对路径中有上一层目录那么该目录就是返回结果。//重命名，其实就是远文件再创建一个新文件，再把内容写入文件File f2 = new File("c:\\ab\\d.java");File f3 = new File("c:\\d.java");System.out.println("rename:" + f2.renameTo(f3));}}

二、递归：对于每次循环都是用同一个功能的函数，即函数自身调用自身，这种表现形式或手法，称为递归。

注意：

1、限定条件，是作为结束循环用的，否则是死循环

2、注意递归的次数，尽量避免内存溢出。因为每次调用自身的时候都会先执行下一次调用自己的发那个发，所以会不断在栈内存中开辟新空间，次数过多，会导致内存溢出。

实例一：求和和求二进制

/** * 递归方法演示 */public static int method_2(int num){////求和//if(num == 1){//return 1;//}//return num + method_2(num - 1);//求二进制StringBuilder sb = new StringBuilder();if(num > 0){method_2(num/2);int i = num%2;sb.append(i);}System.out.println(sb.toString());return -1;}

实例二：显示所有目录下的文件，也就是说只要是目录就被循环

思路：既然要显示所有文件，就是要循环每一个文件夹，找出所有文件，这里操作文件夹的动作都是一样的，所有需要用到递归：

/** * 显示所有目录下的文件，也就是说只要是目录就被循环 * 这里用到了递归调用 */public static void showDir(File dir){System.out.println(dir);File[] files = dir.listFiles();for(File f : files){if(f.isDirectory()){showDir(f);}else{System.out.println(f);}}}

实例三：将一个指定目录下的java文件的绝对路径，存储到一个文本文件中。

思路：
  1、对指定目录进行递归
  2、获取递归过程中所有的java文件
  3、把路径存放在集合中
  4、把集合中的数据写入文件

/* * 将一个指定目录下的java文件的绝对路径，存储到一个文本文件中。 *  * 思路： * 1、对指定目录进行递归 * 2、获取递归过程中所有的java文件 * 3、把路径存放在集合中 * 4、把集合中的数据写入文件 */public class JavaFileList {public static void main(String[] args) {// 指定查找路径File dir = new File("E:\\develop\\eclipse space\\android workspace\\Test_java");// 定义集合用于存储取到的java路径List<File> list = new ArrayList<File>();fileToList(dir, list);// 调用查找文件方法// System.out.println(list.size());// 指定写入文件路径File file = new File("c:\\", "javalist.txt");writeToFile(list, file.toString());// 调用写入文件的方法}/* * 获取指定目录下的java文件 */public static void fileToList(File dir, List<File> list) {File[] files = dir.listFiles();// 返回该目录下的文件对象for (File f : files) {if (f.isDirectory()) {fileToList(f, list);} else {if (f.getName().endsWith(".java"));// 找出java文件list.add(f);}}}/* * 将数据写入文件中 */public static void writeToFile(List<File> list, String filepath) {BufferedWriter bfw = null;try {bfw = new BufferedWriter(new FileWriter(filepath));for (File f : list) {String path = f.getAbsolutePath();// 获取文件绝对路径bfw.write(path);bfw.newLine();bfw.flush();}} catch (IOException e) {e.printStackTrace();} finally {if (bfw != null) {try {bfw.close();} catch (IOException e) {e.printStackTrace();}}}}}

第二  Properties类

一、概述：

1、Properties是Hashtable的子类，也就是map集合的子类，所有具备Map集合的特点，而且它里面还有存储的键值对，都是字符串，无泛型定义。是集合中和IO技术相结合的集合容器。

2、特点：

1）可用于键值对形式的配置文件

2）在加载时，需要数据有固定的格式，常用的是：键=值

二、特有方法：

1、设置和获取元素：

Object setProperty(String key,String value)调用Hashtable 的方法put，将键和值存入到properties对象中

String getProperty(String key)用指定的键在此属性列表中搜索属性

Set<String> stringPropertyName()返回此属性列表中的键集

void load(InputStream ism)从输入流中读取属性列表（键和元素对）。

void load(Reader reader)按简单的面向行的格式从输入字符流中读取属性列表（键和元素对）。

实例：

/* * Properties是hashtable的子类 * 也就是说它具备map集合的特点，而且它里面存放的键值对都是字符串 * 是集合和IO技术相结合的集合容器 * 该对象的特点可以用于键值对形式的配置文件 * 那么在加载时需要数据有固定的格式：键=值 *  */public class ProPertiesDemo {public static void main(String[] args) {getAndSet();//method();loadDemo();}/* * 设置和获取元素。 */public static void getAndSet(){Properties pro = new Properties();pro.setProperty("zhangsan", "20");pro.setProperty("lisi", "30");System.out.println(pro);String value = pro.getProperty("lisi");System.out.println("getProperty: " + value);pro.setProperty("lisi", "90");Set<String> names = pro.stringPropertyNames();for(String name : names){System.out.println(name + "::" + pro.getProperty(name));}}/* * 演示如何将流中的数据存储到集合中 * 想要将info.txt中的数据存放在集合中进行操作 *  * 思路： * 1、用流关联info.txt文件 * 2、读取一行数据，将改行数据用“=”切割 * 3、将等号左边作为键，右边作为值存放到properties集合中 */public static void method(){BufferedReader bfr = null;Properties pro = null;try {bfr = new BufferedReader(new FileReader("info.txt"));pro = new Properties();String line = null;while((line=bfr.readLine()) != null){//System.out.println(line);String[] arr = line.split("=");pro.setProperty(arr[0], arr[1]);}} catch (FileNotFoundException e) {e.printStackTrace();} catch (IOException e) {e.printStackTrace();}finally{if(bfr != null){try {bfr.close();System.out.println(pro);} catch (IOException e) {e.printStackTrace();}}}}/* * 用Properties对象提供的方法加载文件中的键值对 */public static void loadDemo(){Properties pro = new Properties();FileInputStream fis = null;FileOutputStream fos = null;try {fis = new FileInputStream("info.txt");//用properties的load方法把流中的数据加载进集合pro.load(fis);System.out.println(pro);//修改pro.setProperty("wangwu", "90");//这里修改只是在内存中，而没有修改文件fos = new FileOutputStream("info.txt");//通过store方法将修改的数据修改到文件中区pro.store(fos, "change comments");pro.list(System.out);} catch (FileNotFoundException e) {e.printStackTrace();} catch (IOException e) {e.printStackTrace();}finally{if(fis != null){try {fis.close();} catch (IOException e) {e.printStackTrace();}}}}}

练习：限制程序运行次数。当运行次数到达5次时，给出，请您注册的提示。并不再让该程序执行。

/* * 练习：限制程序运行次数。当运行次数到达5次时，给出，请您注册的提示。并不再让该程序执行。 */public class RunCountTest {public static void main(String[] args) {// method();tMethod();}/* * 我的思路： 程序没运行一次，就在相应的文件中写入一次记录，每次运行都去读取文件记录， 当文件中的记录达到五条是，就限制程序再运行 */public static void method() {Properties pro = new Properties();FileOutputStream fos = null;FileInputStream fis = null;int i = 0;try {// 读取数据fis = new FileInputStream("info.txt");pro.load(fis);Set<String> names = pro.stringPropertyNames();i = names.size() + 1;System.out.println(names.size());if (names.size() == 5) {throw new RuntimeException("请您注册");}// 写入数据i++;fos = new FileOutputStream("info.txt", true);pro.setProperty(i + "", "key");pro.store(fos, "comments");} catch (FileNotFoundException e) {e.printStackTrace();} catch (IOException e) {e.printStackTrace();}}/* * 老师的思路 很容易想到的是:计数器。 可是该计数器定义在程序中，随着程序的运行而在内存中存在，并进行自增。 * 可是随着该应用程序的退出，该计数器也在内存中消失了。 *  * 下一次在启动该程序，又重新开始从0计数。 这样不是我们想要的。 *  * 程序即使结束，该计数器的值也存在。 下次程序启动在会先加载该计数器的值并加1后在重新存储起来。 *  * 所以要建立一个配置文件。用于记录该软件的使用次数。 *  * 该配置文件使用键值对的形式。 这样便于阅读数据，并操作数据。 *  * 键值对数据是map集合。 数据是以文件形式存储，使用io技术。 那么map+io -->properties. *  * 配置文件可以实现应用程序数据的共享。 */public static void tMethod() {Properties pro = new Properties();// 需要操作文件，用File对象判断文件是否存在File file = new File("count.ini");FileInputStream fis = null;FileOutputStream fos = null;if (!file.exists()) {try {file.createNewFile();// 不存在就创建一个} catch (IOException e) {e.printStackTrace();}}try {fis = new FileInputStream(file);pro.load(fis);// 将流中的数据加载进文件// 定义计数器int count = 0;// 获取计数器String value = pro.getProperty("time");if (value != null) {count = Integer.parseInt(value);if (count >= 5) {System.out.println("请您注册");return;}}count++;pro.setProperty("time", count + "");fos = new FileOutputStream(file);pro.store(fos, null);// 写入文件} catch (IOException e) {e.printStackTrace();} finally {if(fis != null){try {fis.close();} catch (IOException e) {e.printStackTrace();}}if(fos != null){try {fos.close();} catch (IOException e) {e.printStackTrace();}}}}}

第三  打印流

一、概述：

该流提供了打印方法，可以将各种数据类型的数据都原样打印。

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

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

实例：

public class PrintStreamDemo {public static void main(String[] args) {method();}public static void method() {BufferedReader bfr = new BufferedReader(new InputStreamReader(System.in));// PrintWriter out = new// PrintWriter(System.out);//PrintStream(OutputStream out)// PrintStream(OutputStream out, boolean autoFlush)// autoFlush - boolean 变量；如果为 true，则每当写入 byte 数组、调用其中一个 println// 方法或写入换行符或字节 ('\n') 时都会刷新缓冲区// PrintWriter out = new PrintWriter(System.out, true);//输出到控制台// 输出到文件PrintWriter out = null;try {// PrintStream(File file)和PrintStream(OutputStream out, boolean// autoFlush)结合out = new PrintWriter(new BufferedWriter(new FileWriter("a.txt")),true);} catch (IOException e1) {e1.printStackTrace();}String line = null;try {while ((line = bfr.readLine()) != null) {if (line.equals("over")) {break;}out.println(line.toUpperCase());// out.flush();}} catch (IOException e) {e.printStackTrace();} finally {if (bfr != null) {try {bfr.close();} catch (IOException e) {e.printStackTrace();}}if (out != null) {out.close();}}}}

第四  合并流

一、概述：

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

二、如何合并多个文件：

1、创建集合，并将流对象添加进集合或者SequenceInputStream(InputStream s1,InputStream s2)加入两个输入流

2、创建Enumeration对象，将集合元素加入。

3、创建SequenceInputStream对象，合并流对象

4、创建写入流对象，FileOutputStream，将数据写入流资源

5、定义数组，将读取流数据存入数组，并将数组中元素写入文件中。

实例：

/* * SequenceInputStream 表示其他输入流的逻辑串联。它从输入流的有序集合开始，并从第一个输入流开始读取， * 直到到达文件末尾，接着从第二个输入流读取，依次类推，直到到达包含的最后一个输入流的文件末尾为止。  */public class SequenceInputStreamDemo {public static void main(String[] args) {Vector<FileInputStream> vector = new Vector<FileInputStream>();//sequenceinputstream操作多个对象SequenceInputStream sequence = null;BufferedOutputStream bfos = null;try {vector.add(new FileInputStream("1.txt"));vector.add(new FileInputStream("2.txt"));vector.add(new FileInputStream("3.txt"));//通过vector获取枚举EnumerationEnumeration<FileInputStream> enumeration = vector.elements();sequence = new SequenceInputStream(enumeration);FileOutputStream fos = new FileOutputStream("4.txt");bfos = new BufferedOutputStream(fos);byte[] byf = new byte[1024];int len = 0;while((len = sequence.read(byf)) != -1){bfos.write(byf,0,len);}} catch (FileNotFoundException e) {e.printStackTrace();} catch (IOException e) {e.printStackTrace();}finally{if(sequence != null){try {sequence.close();} catch (IOException e) {e.printStackTrace();}}if(bfos != null){try {bfos.close();} catch (IOException e) {e.printStackTrace();}}}}}

6、切割文件

重点，定义一个你需要把文件切成多大的数组，然后把数据读到数组中，读满后写出到文件中，这样就完成了切割：

/* * 文件的切割和合并 */public class SplitFile {public static void main(String[] args) throws IOException {//splitFile();sequence();}/* * 切割文件 */public static void splitFile() throws IOException{FileInputStream fis = new FileInputStream("0.jpg");FileOutputStream fos = null;byte[] byf = new byte[1024*1024];//定义需要切割大小的空间int len = 0;int count = 1;//为文件取名用的数字while((len=fis.read(byf)) != -1){fos = new FileOutputStream((count++) + ".patch");//创建指定的文件fos.write(byf,0,len);//把读取到的数据写入指定的文件中fos.close();//关闭资源}fis.close();//关闭资源}/* * 合并文件 */public static void sequence() throws IOException{ArrayList<FileInputStream> list = new ArrayList<FileInputStream>();list.add(new FileInputStream("1.patch"));list.add(new FileInputStream("2.patch"));list.add(new FileInputStream("3.patch"));//通过迭代器方法获取枚举final Iterator<FileInputStream> it = list.iterator();//内部类使用的成员变量必须是final修饰的//通过内部类实现枚举Enumeration<FileInputStream> en = new Enumeration<FileInputStream>() {@Overridepublic FileInputStream nextElement() {return it.next();}@Overridepublic boolean hasMoreElements() {return it.hasNext();}};SequenceInputStream sequence = new SequenceInputStream(en);FileOutputStream fos = new FileOutputStream("10.jpg");byte[] byf = new byte[1024];int len = 0;while((len=sequence.read(byf)) != -1){fos.write(byf,0,len);}sequence.close();fos.close();}}

第五  Objectstream

一、概述：

ObjectStream是可以操作对象的流。它的写方法是ObjectOutputStream，读方法是ObjectInputStream。它主要操作的是对象，而对象中也能封装数据，所以它也具备操作基本数据类型的方法。被它操作的对象必须是实现了序列化的对象也就是Serializable接口，但是输入流还多支持一种Externalizable 接口的对象。

实例：

/* * 对对象进行读写操作 */public class ObjectstreamDemo {public static void main(String[] args) throws Exception {//writeObj();readObj();}/* * 写对象 */public static void writeObj() throws Exception{ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("obj.object"));oos.writeObject(new Person("zhangsan", 23, "ASC"));oos.close();}/* * 读取对象 */public static void readObj() throws Exception{ObjectInputStream ois = new ObjectInputStream(new FileInputStream("obj.object"));Person p = (Person) ois.readObject();System.out.println(p);ois.close();}}

用作被操作的类：

/* * 用作对象的持久化存储，也就是用流存放到硬盘上 *  * 静态不能被序列化 * transient关键字修饰的不能被序列化 */public class Person implements Serializable//实现这个接口，让该类被序列化{//给类指定一个序列化标识，方便序列化，不定义会自动生成一个private static final long serialVersionUID = 42L;private String name;private int age;private static String country = "cn";Person(String name, int age, String country){this.name = name;this.age = age;Person.country = country;}public String toString(){return name+":"+age+":"+country;}}

第六  管道流

一、概述：

可以将管道输出流连接到管道输入流来创建通信管道。管道输出流是管道的发送端。通常，数据由某个线程写入PipedOutputStream 对象，并由其他线程从连接的PipedInputStream 读取。不建议对这两个对象尝试使用单个线程，因为这样可能会造成该线程死锁。如果某个线程正从连接的管道输入流中读取数据字节，但该线程不再处于活动状态，则该管道被视为处于毁坏状态

二、使用步骤：

1、要先创建一个读和写的两个类，实现Runnable接口，因为是两个不同的线程，覆盖run方法，注意，需要在内部处理异常，因为重写run方法

2、创建两个管道流，并用connect()方法将两个流连接

3、创建读写对象，并传入两个线程内，并start执行

实例：

/* * 管道流 * 用多线操作，单线程容易造成死锁 */public 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();}}class Write implements Runnable {private PipedOutputStream out;Write(PipedOutputStream out) {this.out = out;}@Overridepublic void run() {try {Thread.sleep(4000);out.write("piped stream come".getBytes());out.close();} catch (IOException e) {e.printStackTrace();} catch (InterruptedException e) {e.printStackTrace();}}}class Read implements Runnable {private PipedInputStream in;Read(PipedInputStream in) {this.in = in;}@Overridepublic void run() {byte[] byf = new byte[1024];int len = 0;try {while ((len = in.read(byf)) != -1) {String str = new String(byf, 0, len);System.out.println(str);}} catch (IOException e) {e.printStackTrace();}}}

第七  RandomAccessFile

一、概述：

1、RandomAccessFile称之为随机访问文件的类，自身具备读写方法。

2、该类不算是IO体系中的子类，而是直接继承Object，但是它是IO包成员，因为它具备读写功能，内部封装了一个数组，且通过指针对数组的元素进行操作，同时可通过seek改变指针的位置。

3、可以完成读写的原理：内部封装了字节输入流

4、构造函数：RandomAccessFile(File file,String mode)，可已从它的构造函数中看出，该类只能操作文件（也有字符串），而且操作文件还有模式。

模式传入值：”r“：以只读方式打开；”rw“：打开以便读写

如果模式为只读，则不会创建文件，会去读一个已存在的文件，若文件不存在，则会出现异常，如果模式为rw，且该对象的构造函数要操作的文件不存在，会自动创建，如果存在，则不会覆盖，也可通过seek方法修改。

二、特有方法：

1、seek(int n)：设置指针，可以将指针设置到前面或后面

2、skipBytes(int n)：跳过指定字节数，不可往前跳

实例：

/* * 随机访问文件的类 * 该类不算是IO体系中子类。而是直接继承自Object。 * 但是它是IO包中成员。因为它具备读和写功能。 * 内部封装了一个数组，而且通过指针对数组的元素进行操作。 * 可以通过getFilePointer获取指针位置，同时可以通过seek改变指针的位置。 *  * 其实完成读写的原理就是内部封装了字节输入流和输出流。 * 通过构造函数可以看出，该类只能操作文件。而且操作文件还有模式：只读r，，读写rw等。 * 如果模式为只读 r。不会创建文件。会去读取一个已存在文件，如果该文件不存在，则会出现异常。 * 如果模式rw。操作的文件不存在，会自动创建。如果存则不会覆盖。 */public class RandomAccessFileDemo {public static void main(String[] args) throws IOException {writeFile();//readFile();}public static void writeFile() throws IOException{RandomAccessFile raf = new RandomAccessFile("random.txt","rw");raf.write("张三".getBytes());raf.writeInt(97);//write方法只读取最低8位raf.write("李四".getBytes());raf.writeInt(98);//********往指定位置上存储数据,也可以修改数据raf.seek(8*4);raf.write("王五".getBytes());raf.writeInt(103);raf.close();}public static void readFile() throws IOException{RandomAccessFile raf = new RandomAccessFile("random.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 + " : " + age);raf.close();}}

第八  DataStream

一、概述：

DataStream是可以用于操作基本数据类型的数据的流对象：DataInputStream与DataOutputStream，它主要的特点就是操作基本数据类型。

实例：

/* * DataInputStream与DataOutputStream *  * 可以用于操作基本数据类型的数据的流对象。 */public class DataStreamDemo {public static void main(String[] args) throws IOException {//write();//read();//writeUTF();readUTF();//一般加入编码的方法//OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("utf.txt"),"utf-8");//osw.write("你好");//osw.close();}public static void write() throws IOException{DataOutputStream dos = new DataOutputStream(new FileOutputStream("data.txt"));dos.writeInt(236);dos.writeBoolean(false);dos.writeDouble(2323.02154);dos.close();}public static void read() throws IOException{DataInputStream dis = new DataInputStream(new FileInputStream("data.txt"));int i = dis.readInt();boolean b = dis.readBoolean();double d = dis.readDouble();System.out.println("int: " + i);System.out.println("boolean: " + b);System.out.println("double: " + d);dis.close();}//加入了改编后的UTF-8编码，所以只有它自己能读public static void writeUTF() throws IOException{DataOutputStream dos = new DataOutputStream(new FileOutputStream("data.txt"));dos.writeUTF("你家婆");dos.close();}public static void readUTF() throws IOException{DataInputStream dis = new DataInputStream(new FileInputStream("utf.txt"));String s = dis.readUTF();System.out.println(s);dis.close();}}

第九  ByteArraytStream

一、概述：

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

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

注：因为这两个流对象都操作的数组，并没有使用系统资源。所以，不用进行close关闭，而且关闭也是无效的。

源设备，
  键盘 System.in，硬盘 FileStream，内存 ArrayStream
  目的设备：
   控制台 System.out，硬盘FileStream，内存 ArrayStream。

/* * ByteArrayInputStream ：在构造的时候，需要接收数据源，。而且数据源是一个字节数组。 * ByteArrayOutputStream： 在构造的时候，不用定义数据目的，因为该对象中已经内部封装了可变长度的字节数组。 * 这就是数据目的地。 *  * 因为这两个流对象都操作的数组，并没有使用系统资源。 * 所以，不用进行close关闭，而且关闭也是无效的。 *  * 源设备， * 键盘 System.in，硬盘 FileStream，内存 ArrayStream * 目的设备： * 控制台 System.out，硬盘FileStream，内存 ArrayStream。 */public class ByteArrayStreamDemo {public static void main(String[] args) {//数据源ByteArrayInputStream bis = new ByteArrayInputStream("defef".getBytes());//目的地ByteArrayOutputStream bos = new ByteArrayOutputStream();int ch = 0;while((ch=bis.read()) != -1){bos.write(ch);}System.out.println(bos.size());System.out.println(bos.toString());try {//将此 byte 数组输出流的全部内容写入到指定的输出流参数中bos.writeTo(new FileOutputStream("b.txt"));} catch (FileNotFoundException e) {e.printStackTrace();} catch (IOException e) {e.printStackTrace();}}}

第十  字符编码

一、‘常见的编码表：

1、ASCII：美国标准信息交换码表。用一个字节的7位表示

2、IOS8859-1：拉丁码表；欧洲码表。用一个字节的8位表示

3、GB2312：中国的中文编码表

4、GBK：中国的中文编码表升级，融合了更多的中文文字字符。打头的是两个高位为1的两个字节编码。为负数

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

6、UTF-8：升级版国际码表，是可变长度的码表。最多用三个字节表示一个字符的编码表，包括：一位、两位、三位表示的字符

      UTF-8有自己的字节码：

一个字节：0开头

两个字节：字节一  ---> 110     位数：10 ~ 6

                    字节二  --->  10      位数：5 ~ 0

三个字节：字节一  ---> 1110     位数：15 ~ 12

                    字节二  --->  10      位数：11 ~ 6

                    字节三 --->  10       位数：5 ~ 0

二、编码和解码：

1、编码：字符串变成字节数组

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

2、转换：

1）默认字符集：

      String  --->  byte[]   ：srt.getBytes()

      byte[]   --->  String  ：new String(byte[])

2）指定字符集：

      String  --->  byte[]   ：srt.getBytes(charsetName)

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

三、对于编码和解码的字符集转换

1、如果编码失败，解码就没意义了。

2、如果编码成功，解码出来的是乱码，，则需对乱码通过再次编码（用解错码的编码表），然后再通过正确的编码表解码。针对于IOS8859-1是通用的。

3、如果用的是GBK编码，UTF-8解码，那么再通过2的方式，就不能成功了，因为UTF-8也支持中文，在UTF-8解的时候，会将对应的字节数改变，所以不会成功。

特别注意：对于中文的”联通“，这两个字比较特别，它的二进制位正好是和在UTF-8中两个字节打头的相同，可以找到对应的符号，但不再是”联通“了。但是只要他前面还有其他汉字就不会被被UTF-8解码了，也就不会出现乱码了。

实例：

/* * 编码：字符串变成字节数组。 *  解码：字节数组变成字符串。 *   String-->byte[];  str.getBytes(charsetName); *   byte[] -->String: new String(byte[],charsetName); */public class EncodeDemo {public static void main(String[] args) {method();}public static void show() {String s = "你好";try {byte[] b = s.getBytes("GBK");System.out.println(Arrays.toString(b));String str = new String(b, "iso8859-1");// 编码正确，解码错误System.out.println(str);// 对str进行iso8859-1编码。以这样的方式解决乱码byte[] b1 = str.getBytes("iso8859-1");System.out.println(Arrays.toString(b1));String str1 = new String(b1, "GBK");System.out.println(str1);} catch (UnsupportedEncodingException e) {e.printStackTrace();}}/* * 联通 */public static void method() {String s = "联通";try {byte[] bs = s.getBytes("GBK");for (byte b : bs) {// Integer.toBinaryString将其转换为二进制，&255取出前面多余的1，保留最低8位// 联通的二进制是110...10...110...10...这个刚好符合utf-8的读取两个字节的编码形式，// 所以当度存在会被默认为utf-8编码来解读，从而造成乱码/* * '\u0001' 到 '\u007F' 范围内的所有字符都是用单个字节表示的： *  * 位值 字节一 0 位 6-0 *  *  * null 字符 '\u0000' 以及从 '\u0080' 到 '\u07FF' 的范围内的字符用两个字节表示： *  * 位值 字节一 1 1 0 位 10-6 *  * 字节二 1 0 位 5-0 *  *  *  * '\u0800' 到 '\uFFFF' 范围内的 char 值用三个字节表示：  字节一  1 1 1 0 位 * 15-12 *  * 字节二 1 0 位 11-6 *  * 字节三 1 0 位 5-0 */System.out.println(Integer.toBinaryString(b & 255));}} catch (UnsupportedEncodingException e) {e.printStackTrace();}}}

练习

五个学生，每个学生有3门课程的成绩，从键盘输入以上数据（姓名，三门课成绩），

输入格式：如：zahngsan，30,40,60计算出总成绩，并把学生的信息和计算出的总分数高低按顺序存放在磁盘文件stud.txt中

步骤：
1、描述学生对象
2、定义一个可操作学生对象的工具类

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

public class StudentInfoTest {public static void main(String[] args) {try {Comparator<StudentInfo> cmp = Collections.reverseOrder();// 强行反正比较顺序// Set<StudentInfo> stus = StudentInfoTool.getStudents();//默认比较Set<StudentInfo> stus = StudentInfoTool.getStudents(cmp);// 自定义比较器StudentInfoTool.write2File(stus);//调用写方法，将数据写文件中去} catch (IOException e) {e.printStackTrace();}}}class StudentInfo implements Comparable<StudentInfo> {private String name;// 姓名private int ma, cn, en;// 数学、语文、英语成绩private int sum;// 总分//初始化就需要具备姓名，数学、语文、英语成绩StudentInfo(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 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;}@Overridepublic int compareTo(StudentInfo o) {//建立自己的比较方法int num = new Integer(this.sum).compareTo(new Integer(o.sum));//比较分数if (num == 0) {return this.name.compareTo(o.name);//主条件相同判定次要条件}return num;//返回比较的值，大于正数，相同0，小于负数}@Overridepublic int hashCode() {//重写hashcode方法是因为数据有可能存到hashtable中return name.hashCode() + sum * 23;//尽可能保证hashcode值不相同，减少比较次数}@Overridepublic boolean equals(Object obj) {//建立自己独有的判断相同方式if (!(obj instanceof StudentInfo)) {throw new ClassCastException("类型不匹配");}StudentInfo si = (StudentInfo) obj;return this.name.equals(si.name) && this.sum == si.sum;//姓名和总分相同视为同一人}@Overridepublic String toString() {//建立自己的toString方法return "studentinfo[" + name + ", " + ma + ", " + cn + ", " + en + "]";}}class StudentInfoTool {//定义默认比较顺序public static Set<StudentInfo> getStudents() throws IOException {return getStudents(null);}//定义自定义的比较顺序public static Set<StudentInfo> getStudents(Comparator<StudentInfo> cmp)throws IOException {BufferedReader bfr = new BufferedReader(new InputStreamReader(System.in));Set<StudentInfo> stus = null;if (cmp == null) {stus = new TreeSet<StudentInfo>();} else {stus = new TreeSet<StudentInfo>(cmp);}String line = null;while ((line = bfr.readLine()) != null) {if ("over".equals(line)) {break;}String[] info = line.split(",");//将数据以“，”切开，形成新的数据StudentInfo si = new StudentInfo(info[0],Integer.parseInt(info[1]), Integer.parseInt(info[2]),Integer.parseInt(info[3]));stus.add(si);}bfr.close();return stus;}public static void write2File(Set<StudentInfo> stus) throws IOException {BufferedWriter bfw = new BufferedWriter(new FileWriter("stuinfo.txt"));for (StudentInfo si : stus) {bfw.write(si.toString() + "\t");bfw.write(si.getSum() + "");bfw.newLine();bfw.flush();}bfw.close();}}