• 16.IO之其他流

    第一  打印流

    一、概述：

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

    原理将97先变成字符保持原样将数据打印到目的地

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

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


      PrintStream out = new PrintStream("print.txt");
    // int by = read();
    // write(by);
    // out.write(610);//只写最低8位，
    // out.print(97);//将97先变成字符保持原样将数据打印到目的地。
      out.close();
    从控制台写到控制台
    1. private static void controlToC() throws IOException {
    2. 		BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
    3. 		PrintWriter pw = new PrintWriter(System.out);
    4. 		String line = null;
    6. 		while ((line = bf.readLine()) != null) {
    7. 			if ("over".equals(line)) {
    8. 				break;
    9. 			}
    10. 			pw.println(line.toUpperCase());
    11. 			pw.flush();
    12. 		}
    13. 		pw.close();
    14. 		bf.close();
    15. 	}
    从控制台写到文件中
    1. public static void main(String[] args) throws IOException {
    3. 	  BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
    4. //特有构造器，turn就自动刷新，可是写到文件中不能自动刷新new FileWriter("out.txt")，所以写到一个输出流中，完成自动刷新
    5. 	  PrintWriter out = new PrintWriter(new FileWriter("out.txt"),true); 
    6. 	  String line =  null;
    7. 	  while((line=bufr.readLine())!=null){
    8. 	   if("over".equals(line))
    9. 	    break;
    10. 	   out.println(line.toUpperCase());
    11. //		 out.flush();
    12. 	  }
    13. 	  out.close();
    14. 	  bufr.close();
    15. 	 }
    16. 	}
    获取系统信息，并保存：
    步骤：
    1）获取系统信息：
    Properties getProperties()
    2）将信息输出到指定输出流中
    void  list(PrintStream out)
    3）将输出流中数据存入指定文件中
    new PrintStream("systeminfo.txt")

    1. public class SysInfo {  
    2.     public static void main(String[] args) {  
    3.         Properties pro = System.getProperties();  
    4.   
    5.         try {  
    6.             pro.list(new PrintStream("sysinfo.txt"));// list方法将属性列表输出到指定的输出流。  
    7.         } catch (FileNotFoundException e) {  
    8.             e.printStackTrace();  
    9.         }  
    10.     }  
    11. }

    第二  合并流（序列流）

    一、概述：

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

    二、如何合并多个文件：

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

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

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

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

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

    1. public class SequenceInputStreamDemo {
    2. 	  /*
    3. 	   * 需求：将1.txt 2.txt 3.txt文件中的数据合并到一个文件中。
    4. 	   */
    5. 	Vector（枚举）中才有Enumeration
    6. //		 Vector<FileInputStream> v = new Vector<FileInputStream>();
    7. //		 v.add(new FileInputStream("1.txt"));
    8. //		 v.add(new FileInputStream("2.txt"));
    9. //		 v.add(new FileInputStream("3.txt"));
    10. //		 Enumeration<FileInputStream> en = v.elements(); //这样就获取了枚举了
    12. 	  //枚举和迭代一样，枚举没过时，过时是编译器不认识了，不过  ArrayList有效率
    13. 	  ArrayList<FileInputStream> al = new ArrayList<FileInputStream>();
    14. 	  for(int x=1; x<=3; x++){
    15. 	   al.add(new FileInputStream(x+".txt"));
    16. 	  }
    17. 	  Enumeration<FileInputStream> en = Collections.enumeration(al); 
    18. 	  //有个返回枚举的方法，它的原理就是下边这个
    20. 	  /* 
    21. 	  final Iterator<FileInputStream> it = al.iterator(); //内部类访问局部变量用final
    22. 	  Enumeration<FileInputStream> en = new Enumeration<FileInputStream>(){ 
    23.          //new了个  Enumeration，匿名内部类
    24. 	//枚举接口的实现中利用迭代器，这样写比较麻烦，不懂，参见io流--51
    25. 	   @Override
    26. 	   public boolean hasMoreElements() {
    27. 	    return it.hasNext();
    28. 	   }
    29. 	   @Override
    30. 	   public FileInputStream nextElement() {
    31. 	    return it.next();
    32. 	   }
    33. 	  };*/
    34. 	  //合并
    35. 	  SequenceInputStream sis = new SequenceInputStream(en);
    36. 	  FileOutputStream fos = new FileOutputStream("1234.txt");
    37. 	  byte[] buf = new byte[1024];
    38. 	  int len = 0;
    39. 	  while((len=sis.read(buf))!=-1){
    40. 	   fos.write(buf,0,len);
    41. 	  }
    42. 	  fos.close();
    43. 	  sis.close();
    44. 	 } 
    45. 	}

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

    2.  * 文件的切割和合并  
    3.  */  
    4. public class SplitFile {  
    5.     public static void main(String[] args) throws IOException {  
    6. //      splitFile();  
    7.         sequence();  
    8.     }  
    9.       
    10.     /*  
    11.      * 切割文件  
    12.      */  
    13.     public static void splitFile() throws IOException  
    14.     {  
    15.         FileInputStream fis = new FileInputStream("0.jpg");  
    16.         FileOutputStream fos = null;  
    17.           
    18.         byte[] byf = new byte[1024*1024];//定义需要切割大小的空间  
    19.           
    20.         int len = 0;  
    21.         int count = 1;//为文件取名用的数字  
    22.         while((len=fis.read(byf)) != -1){  
    23.             fos = new FileOutputStream((count++) + ".patch");//创建指定的文件  
    24.             fos.write(byf,0,len);//把读取到的数据写入指定的文件中  
    25.             fos.close();//关闭资源  
    26.         }  
    27.         fis.close();//关闭资源  
    28.     }  
    29.       
    30.     /*  
    31.      * 合并文件  
    32.      */  
    33.     public static void sequence() throws IOException{  
    34.         ArrayList<FileInputStream> list = new ArrayList<FileInputStream>();  
    35.         list.add(new FileInputStream("1.patch"));  
    36.         list.add(new FileInputStream("2.patch"));  
    37.         list.add(new FileInputStream("3.patch"));  
    38.           
    39.         //通过迭代器方法获取枚举  
    40.         final Iterator<FileInputStream> it = list.iterator();//内部类使用的成员变量必须是final修饰的  
    41.           
    42.         //通过内部类实现枚举  
    43.         Enumeration<FileInputStream> en = new Enumeration<FileInputStream>() {  
    44.               
    45.             @Override  
    46.             public FileInputStream nextElement() {  
    47.                 return it.next();  
    48.             }  
    49.               
    50.             @Override  
    51.             public boolean hasMoreElements() {  
    52.                 return it.hasNext();  
    53.             }  
    54.         };  
    55.           
    56.         SequenceInputStream sequence = new SequenceInputStream(en);  
    57.           
    58.         FileOutputStream fos = new FileOutputStream("10.jpg");  
    59.           
    60.         byte[] byf = new byte[1024];  
    61.         int len = 0;  
    62.         while((len=sequence.read(byf)) != -1){  
    63.             fos.write(byf,0,len);  
    64.         }  
    65.         sequence.close();  
    66.         fos.close();  
    67.     }  
    68. }


    练习1：文件切割（按大小切）
    1. public class SplitFileDemo {
    2. 	private static final int SIZE = 1024 * 1024;
    4. 	public static void main(String[] args) throws Exception {
    5. 		File file = new File("c:\aa.mp3");
    6. 		splitFile_2(file);
    7. 	}
    9. 	// 修改后
    10. 	private static void splitFile_2(File file) throws IOException {
    11. 		// 用读取流关联源文件。
    12. 		FileInputStream fis = new FileInputStream(file);
    13. 		// 定义一个1M的缓冲区。
    14. 		byte[] buf = new byte[SIZE];
    15. 		// 创建目的。
    16. 		FileOutputStream fos = null;
    17. 		int len = 0;
    18. 		int count = 1;
    20. 		/*
    21. 		 * 切割文件时，必须记录住被切割文件的名称，以及切割出来碎片文件的个数。 以方便于合并。
    22. 		 * 这个信息为了进行描述，使用键值对的方式。用到了properties对象
    23. 		 */
    24. 		Properties prop = new Properties();
    26. 		File dir = new File("c:\partfiles");// 将碎片放到固定文件夹中，也可以不写
    27. 		if (!dir.exists())
    28. 			dir.mkdirs();
    29. 		while ((len = fis.read(buf)) != -1) {
    30. 			fos = new FileOutputStream(new File(dir, (count++) + ".part"));
    31. 			// 不能写new
    32. 			// FileOutputStream("1.txt")，问题1：第二次new把第一次new的覆盖了，所有1不能写死，还要合并。
    33. 			// 问题2：扩展名不能写死，碎片文件不能阅读
    34. 			fos.write(buf, 0, len);
    35. 			fos.close();
    36. 		}
    37. 		// 将被切割文件的信息保存到prop集合中。
    38. 		prop.setProperty("partcount", count + "");// 碎片文件的个数
    39. 		prop.setProperty("filename", file.getName());// 文件的名字
    41. 		fos = new FileOutputStream(new File(dir, count + ".properties"));
    42. 		// 将prop集合中的数据存储到文件中。
    43. 		prop.store(fos, "save file info");//
    44. 		fos.close();
    45. 		fis.close();
    46. 	}
    48. 	// 原始：
    49. 	public static void splitFile(File file) throws IOException {
    50. 		// 用读取流关联源文件。
    51. 		FileInputStream fis = new FileInputStream(file);
    52. 		// 定义一个1M的缓冲区。
    53. 		byte[] buf = new byte[SIZE];
    54. 		// 创建目的。
    55. 		FileOutputStream fos = null;
    56. 		int len = 0;
    57. 		int count = 1;
    58. 		File dir = new File("c:\partfiles");
    59. 		if (!dir.exists())
    60. 			dir.mkdirs();
    61. 		while ((len = fis.read(buf)) != -1) {
    62. 			fos = new FileOutputStream(new File(dir, (count++) + ".part"));
    63. 			fos.write(buf, 0, len);
    64. 		}
    65. 		fos.close();
    66. 		fis.close();
    67. 	}
    68. }

    练习2：合并
    1. public class MergeFile {
    2. 	public static void main(String[] args) throws IOException {
    3. 		File dir = new File("c:\partfiles");
    4. 		mergeFile_2(dir);
    5. 	}
    7. 	public static void mergeFile(File dir) throws IOException {
    9. 		ArrayList<FileInputStream> al = new ArrayList<FileInputStream>();
    11. 		for (int x = 1; x <= 3; x++) {
    12. 			al.add(new FileInputStream(new File(dir, x + ".part")));
    13. 		}
    15. 		Enumeration<FileInputStream> en = Collections.enumeration(al);
    16. 		SequenceInputStream sis = new SequenceInputStream(en);
    18. 		FileOutputStream fos = new FileOutputStream(new File(dir, "1.bmp"));// 合并到当前目录下
    20. 		byte[] buf = new byte[1024];
    22. 		int len = 0;
    23. 		while ((len = sis.read(buf)) != -1) {
    24. 			fos.write(buf, 0, len);
    25. 		}
    27. 		fos.close();
    28. 		sis.close();
    29. 	}
    30. }

    可是并知道有多少个碎片，也不知道碎片对应原来的名字是什么

     修改后

     
    1. public static void mergeFile_2(File dir) throws IOException {
    2. 	  /*
    3. 	   * 获取指定目录下的配置文件对象。
    4. 	   */
    5. 	  File[] files = dir.listFiles(new SuffixFilter(".properties"));//过滤器，过滤文件名
    6. 	  if(files.length!=1)
    7. 	   throw new RuntimeException(dir+",该目录下没有properties扩展名的文件或者不唯一");//自定义异常
    8. 	  //记录配置文件对象。
    9. 	  File confile = files[0];
    10. 	 
    11. 	  //获取该文件中的信息================================================。
    12. 	  Properties prop = new Properties();
    13. 	  FileInputStream fis = new FileInputStream(confile);
    14. 	  prop.load(fis);//流中信息加载进来
    15. 	  String filename = prop.getProperty("filename");
    16. 	  int count = Integer.parseInt(prop.getProperty("partcount"));
    17. 	 
    18. 	  //获取该目录下的所有碎片文件。 ==============================================
    19. 	  File[] partFiles = dir.listFiles(new SuffixFilter(".part"));
    20. 	  if(partFiles.length!=(count-1)){
    21. 	   throw new RuntimeException(" 碎片文件不符合要求，个数不对!应该"+count+"个");//如果少了一个
    22. 	  }
    23. 	   //将碎片文件和流对象关联 并存储到集合中。
    24. 	  ArrayList<FileInputStream> al = new ArrayList<FileInputStream>();
    25. 	  for(int x=0; x<partFiles.length; x++){
    26. 	   al.add(new FileInputStream(partFiles[x]));
    27. 	  }
    28. 	  
    29. 	  //将多个流合并成一个序列流。
    30. 	  Enumeration<FileInputStream> en = Collections.enumeration(al);
    31. 	  SequenceInputStream sis = new SequenceInputStream(en);
    32. 	  FileOutputStream fos = new FileOutputStream(new File(dir,filename));
    33. 	  byte[] buf = new byte[1024];
    34. 	  int len = 0;
    35. 	  while((len=sis.read(buf))!=-1){
    36. 	   fos.write(buf,0,len);
    37. 	  }
    38. 	  fos.close();
    39. 	  sis.close();
    40. 	} 
    41. }

    第三  Objectstream（对象流）

    一、概述：

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

              

    实例：

    1.  * 对对象进行读写操作  
    2. public class ObjectstreamDemo {  
    3.     public static void main(String[] args) throws Exception {  
    4. //      writeObj();  
    5.         readObj();  
    6.     }  
    7.       
    8.     /*  
    9.      * 写对象  
    10.      */  
    11.     public static void writeObj() throws Exception{  
    12.         ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("obj.object"));  
    13. //仅仅是把对内存的对象存在硬盘上，下次拿来用，不需要用记事本解析
    15.         oos.writeObject(new Person("zhangsan", 23, "ASC"));  
    16.         oos.close();  
    17.     }  
    18.       
    19.     /*  
    20.      * 读取对象  ，读出来不是一个组合的对象，读出是数据.注意：没class文件，取不出来
    21.      */  
    22.     public static void readObj() throws Exception{  
    23.         ObjectInputStream ois = new ObjectInputStream(new FileInputStream("obj.object"));  
    24.      //  他是person的属性
    25.         Person p = (Person) ois.readObject();  
    26.         System.out.println(p);  
    27.         ois.close();  
    28.     }  
    29. }

    用作被操作的类：
     * 用作对象的持久化存储，也就是用流存放到硬盘上  
     *

     * Serializable:用于给被序列化的类加入ID号。

     * 用于判断类和对象是否是同一个版本。

     * 静态不能被序列化  
     * transient关键字修饰的不能被序列化  
    2. public class Person implements Serializable///*标记接口*/实现这个接口，让该类被序列化  
    3. {  
    4.     //给类指定一个序列化标识，方便序列化，不定义会自动生成一个,如果不定义序列化，改变属性就会读不出来
    5.     private static final long serialVersionUID = 42L;  
    6.       
    7.     private String name;  //private transient String name;
    8.     private int age;  
    9.     private static String country = "cn";  
    10.       
    11.     Person(String name, int age, String country){  
    12.         this.name = name;  
    13.         this.age = age;  
    14.         Person.country = country;  
    15.     }  
    16.       
    17.     public String toString(){  
    18.         return name+":"+age+":"+country;  
    19.     }  
    20. }


    第四  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)：跳过指定字节数，不可往前跳

    实例：

    3. public class RandomAccessFileDemo {  
    4.     public static void main(String[] args) throws IOException {  
    5.         writeFile();  
    6. //      readFile();  
    7.     }  
    8.       
    9.     public static void writeFile() throws IOException{  
    10.         RandomAccessFile raf = new RandomAccessFile("random.txt","rw");  
    11.         //如果文件不存在，则创建，如果文件存在，不创建,把下边的代码注释掉，再读这些东西还在
    12.         raf.write("张三".getBytes());  //内部封装的是一个字节数组，转成字节数组
    13.         raf.writeInt(97);//write方法只读取最低8位，用writeint  
    14.         raf.write("李四".getBytes());  //不是覆盖，是接着写
    15.         raf.writeInt(98);   //不是覆盖，是接着写
    16.           
    17.         //********往指定位置上存储数据,也可以修改数据  
    18.         raf.seek(8*4);  
    19.         raf.write("王五".getBytes());  
    20.         raf.writeInt(103);  
    21.           
    22.         raf.close();  
    23.     }  
    24.       
    25.     public static void readFile() throws IOException{  
    26.         RandomAccessFile raf = new RandomAccessFile("random.txt","r");  
    27.           
    28.         //调整对象中的指针  
    29. //      raf.seek(8*1);//根据数组定，数组大小*跳几个  
    30.           
    31.         //跳过指定的字节数，只能向前不能向后  
    32.         raf.skipBytes(8);  
    33.           
    34.         byte[] buf = new byte[4];   
    35.         raf.read(buf);  
    36.           
    37.         String name = new String(buf);  
    38.         int age = raf.readInt();  
    39.         System.out.println(name + " : " + age);  
    40.         raf.close();  
    41.     }  
    42. }


    第五  管道流

    一、概述：

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

    二、使用步骤：

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

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

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

    实例：
    1.  /
    2.  * 管道流  
    3.  * 用多线操作，单线程容易造成死锁  
    4.  */  
    5. public class PipedStreamDemo {  
    6.     public static void main(String[] args) throws IOException {  
    7.         PipedInputStream in = new PipedInputStream();  
    8.         PipedOutputStream out = new PipedOutputStream();  
    9.         in.connect(out);  //将俩个线程连接起来，谁连谁都一样
    10.   
    11.         Read r = new Read(in);  
    12.         Write w = new Write(out);  
    13.   
    14.         new Thread(r).start();  
    15.         new Thread(w).start();  
    16.     }  
    17.   
    18. }  
    19.   
    20. class Write implements Runnable {  
    21.     private PipedOutputStream out;  
    22.   
    23.     Write(PipedOutputStream out) {  
    24.         this.out = out;  
    25.     }  
    26.   
    27.     @Override  
    28.     public void run() {  
    29.         try {  
    30.             Thread.sleep(4000);  
    31.             out.write("piped stream come".getBytes());  
    32.             out.close();  
    33.         } catch (IOException e) {  
    34.             e.printStackTrace();  
    35.         } catch (InterruptedException e) {  
    36.             e.printStackTrace();  
    37.         }  
    38.     }  
    39.   
    40. }  
    41.   
    42. class Read implements Runnable {  
    43.     private PipedInputStream in;  
    44.   
    45.     Read(PipedInputStream in) {  
    46.         this.in = in;  
    47.     }  
    48.   
    49.     @Override  
    50.     public void run() {  
    51.         byte[] byf = new byte[1024];  
    52.         int len = 0;  
    53.   
    54.         try {  
    55.             while ((len = in.read(byf)) != -1) {  
    56.                 String str = new String(byf, 0, len);  
    57.                 System.out.println(str);  
    58.             }  
    59.         } catch (IOException e) {  
    60.             e.printStackTrace();  
    61.         }  
    62.     }  
    63. }

    第六  DataStream（操作基本类型的流）

    一、概述：

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

    实例：

    2.  * DataInputStream与DataOutputStream  
    3.  *   
    4.  * 可以用于操作基本数据类型的数据的流对象。  
    5.  */  
    6. public class DataStreamDemo {  
    7.     public static void main(String[] args) throws IOException {  
    8. //      write();  
    9. //      read();  
    10. //      writeUTF();  
    11.         readUTF();  
    12.           
    13.         //一般加入编码的方法  
    14. //      OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("utf.txt"),"utf-8");  
    15. //      osw.write("你好");  
    16. //      osw.close();  
    17.     }  
    18.       
    19.     public static void write() throws IOException{  
    20.         DataOutputStream dos = new DataOutputStream(new FileOutputStream("data.txt"));  
    21.           
    22.         dos.writeInt(236);  
    23.         dos.writeBoolean(false);  
    24.         dos.writeDouble(2323.02154);  
    25.           
    26.         dos.close();  
    27.     }  
    28.       
    29.     public static void read() throws IOException{  
    30.         DataInputStream dis = new DataInputStream(new FileInputStream("data.txt"));  
    31.           
    32.         int i = dis.readInt();  
    33.         boolean b = dis.readBoolean();  
    34.         double d = dis.readDouble();  
    35.           
    36.         System.out.println("int: " + i);  
    37.         System.out.println("boolean: " + b);  
    38.         System.out.println("double: " + d);  
    39.           
    40.         dis.close();  
    41.     }  
    42.       
    43.     //加入了改编后的UTF-8编码，所以只有它自己能读  
    44.     public static void writeUTF() throws IOException{  
    45.         DataOutputStream dos = new DataOutputStream(new FileOutputStream("data.txt"));  
    46.           
    47.         dos.writeUTF("你家婆");  
    48.           
    49.         dos.close();  
    50.           
    51.     }  
    52.       
    53.     public static void readUTF() throws IOException{  
    54.         DataInputStream dis = new DataInputStream(new FileInputStream("utf.txt"));  
    55.           
    56.         String s = dis.readUTF();  
    57.         System.out.println(s);  
    58.           
    59.         dis.close();  
    60.           
    61.     }  
    62.       
    63. }


    第七  ByteArraytStream（操作数组的流）

    一、概述：

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

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

    参数是字节数组，访问网络写的是字节，需要new string（bos.tobyteArray）

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

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

    2. public class ByteArrayStreamDemo {  
    3.     public static void main(String[] args) {  
    4.         //数据源  
    5.         ByteArrayInputStream bis = new ByteArrayInputStream("defef".getBytes());  
    6.           
    7.         //目的地  
    8.         ByteArrayOutputStream bos = new ByteArrayOutputStream();  
    9.           
    10.         int ch = 0;  
    11.           
    12.         while((ch=bis.read()) != -1){  
    13.             bos.write(ch);  
    14.         }  
    15.           
    16.         System.out.println(bos.size());  
    17.         System.out.println(bos.toString());  
    18.           
    19.         try {  
    20.             //将此 byte 数组输出流的全部内容写入到指定的输出流参数中  
    21.             bos.writeTo(new FileOutputStream("b.txt"));  
    22.         } catch (FileNotFoundException e) {  
    23.             e.printStackTrace();  
    24.         } catch (IOException e) {  
    25.             e.printStackTrace();  
    26.         }  
    27.     }  
    28. }

    第八  字符编码

    一、‘常见的编码表：

    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解码了，也就不会出现乱码了。

      1.  * 编码：字符串变成字节数组。  
      2.  *  解码：字节数组变成字符串。  
      3.  *   String-->byte[];  str.getBytes(charsetName);  
      4.  *   byte[] -->String: new String(byte[],charsetName);  
      5.  */  
      6. public class EncodeDemo {  
      7.     public static void main(String[] args) {  
      8.   
      9.         method();  
      10.     }  
      11.   
      12.     public static void show() {  
      13.         String s = "你好";  
      14.         try {  
      15.             byte[] b = s.getBytes("GBK");  
      16.             System.out.println(Arrays.toString(b));  //	 printBytes(buf);
      17.             String str = new String(b, "iso8859-1");// 编码正确，解码错误  
      18.             System.out.println(str);  
      19.   
      20.             // 对str进行iso8859-1编码。以这样的方式解决乱码  
      21.             byte[] b1 = str.getBytes("iso8859-1");  
      22.             System.out.println(Arrays.toString(b1));  
      23.             String str1 = new String(b1, "GBK");  
      24.             System.out.println(str1);  
      25.         } catch (UnsupportedEncodingException e) {  
      26.             e.printStackTrace();  
      27.         }  
      28.     }

      
      1.     /*  
      2.      * 联通  
      3.      */  
      4.     public static void method() {  
      5.         String s = "联通";  
      6.         try {  
      7.             byte[] bs = s.getBytes("GBK");  
      8.   
      9.             for (byte b : bs) {  
      10.                 // Integer.toBinaryString将其转换为二进制，&255取出前面多余的1，保留最低8位  
      11.                 // 联通的二进制是110...10...110...10...这个刚好符合utf-8的读取两个字节的编码形式，  
      12.                 // 所以当度存在会被默认为utf-8编码来解读，从而造成乱码  
      13.                 /*  
      14.                  * 'u0001' 到 'u007F' 范围内的所有字符都是用单个字节表示的：  
      15.                  *   
      16.                  * 位值 字节一 0 位 6-0  
      17.                  *   
      18.                  *   
      19.                  * null 字符 'u0000' 以及从 'u0080' 到 'u07FF' 的范围内的字符用两个字节表示：  
      20.                  *   
      21.                  * 位值 字节一 1 1 0 位 10-6  
      22.                  *   
      23.                  * 字节二 1 0 位 5-0  
      24.                  *   
      25.                  * 'u0800' 到 'uFFFF' 范围内的 char 值用三个字节表示：  字节一  1 1 1 0 位  
      26.                  * 15-12  
      27.                  *   
      28.                  * 字节二 1 0 位 11-6  
      29.                  *   
      30.                  * 字节三 1 0 位 5-0  
      31.                  */  
      32.                 System.out.println(Integer.toBinaryString(b & 255));  
      33.             }  
      34.         } catch (UnsupportedEncodingException e) {  
      35.             e.printStackTrace();  
      36.         }  
      37.     }  
      38. }
    练习：
    1. public class Test {
    3. 	 public static void main(String[] args) throws IOException {
    4. 	  String str = "ab你好cd谢谢";
    5. //		 str = "ab琲琲cd琲琲";
    6. //		 int len = str.getBytes("gbk").length;
    7. //		 for(int x=0; x<len; x++){
    8. //		 System.out.println("截取"+(x+1)+"个字节结果是："+cutStringByByte(str, x+1));
    9. //		 }
    10. 	  int len = str.getBytes("utf-8").length;
    11. 	  for(int x=0; x<len; x++){
    12. 	   System.out.println("截取"+(x+1)+"个字节结果是："+cutStringByU8Byte(str, x+1));
    13. 	  }
    14. //		 String str = "琲"; 
    15. //		 byte[] buf = str.getBytes("gbk");
    16. //		 for(byte b : buf){
    17. //		 System.out.println(b);//-84  105
    18. //		 }
    19. 	 }
        在java中，字符串“abcd”与字符串“ab你好”的长度是一样，都是四个字符。
      但对应的字节数不同，一个汉字占两个字节。
      定义一个方法，按照最大的字节数来取子串。
      如：对于“ab你好”，如果取三个字节，那么子串就是ab与“你”字的半个，
      那么半个就要舍弃。如果去四个字节就是“ab你”，取五个字节还是“ab你”.
      
    1. public static String cutStringByU8Byte(String str, int len) throws IOException {
    2. 	  byte[] buf = str.getBytes("utf-8");
    3. 	  int count = 0;
    4. 	  for(int x=len-1; x>=0; x--){
    5. 	   if(buf[x]<0)
    6. 	    count++;
    7. 	   else
    8. 	    break;
    9. 	  }
    10. 	  if(count%3==0)
    11. 	   return new String(buf,0,len,"utf-8");
    12. 	  else if(count%3==1)
    13. 	   return new String(buf,0,len-1,"utf-8");
    14. 	  else
    15. 	   return new String(buf,0,len-2,"utf-8");
    16. 	 }
    17. 	 public static String cutStringByByte(String str,int len) throws IOException{
    18. 	  byte[] buf = str.getBytes("gbk");
    19. 	  int count = 0;
    20. 	  for(int x=len-1; x>=0; x--){
    21. 	   if(buf[x]<0)
    22. 	    count++;
    23. 	   else
    24. 	    break;
    25. 	  }
    26. 	  if(count%2==0)
    27. 	   return new String(buf,0,len,"gbk");
    28. 	  else
    29. 	   return new String(buf,0,len-1,"gbk");
    30. 	 
    31. 	 }
    32.  }
    33. }
    34.


    练习

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

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

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

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

    1. public class StudentInfoTest {  
    2.     public static void main(String[] args) {  
    3.         try {  
    4.             Comparator<StudentInfo> cmp = Collections.reverseOrder();// 强行反正比较顺序  
    5.             // Set<StudentInfo> stus = StudentInfoTool.getStudents();//默认比较  
    6.             Set<StudentInfo> stus = StudentInfoTool.getStudents(cmp);// 自定义比较器  
    7.             StudentInfoTool.write2File(stus);//调用写方法，将数据写文件中去  
    8.         } catch (IOException e) {  
    9.             e.printStackTrace();  
    10.         }  
    11.     }  
    12. }  
    13.   
    14. class StudentInfo implements Comparable<StudentInfo> {  
    15.   
    16.     private String name;// 姓名  
    17.     private int ma, cn, en;// 数学、语文、英语成绩  
    18.     private int sum;// 总分  
    19.   
    20.     //初始化就需要具备姓名，数学、语文、英语成绩  
    21.     StudentInfo(String name, int ma, int cn, int en) {  
    22.         this.name = name;  
    23.         this.ma = ma;  
    24.         this.cn = cn;  
    25.         this.en = en;  
    26.   
    27.         sum = ma + cn + en;//计算出总成绩  
    28.     }  
    29.   
    30.     public String getName() {  
    31.         return name;  
    32.     }  
    33.   
    34.     public void setName(String name) {  
    35.         this.name = name;  
    36.     }  
    37.   
    38.     public int getMa() {  
    39.         return ma;  
    40.     }  
    41.   
    42.     public void setMa(int ma) {  
    43.         this.ma = ma;  
    44.     }  
    45.   
    46.     public int getCn() {  
    47.         return cn;  
    48.     }  
    49.   
    50.     public void setCn(int cn) {  
    51.         this.cn = cn;  
    52.     }  
    53.   
    54.     public int getEn() {  
    55.         return en;  
    56.     }  
    57.   
    58.     public void setEn(int en) {  
    59.         this.en = en;  
    60.     }  
    61.   
    62.     public int getSum() {  
    63.         return sum;  
    64.     }  
    65.   
    66.     public void setSum(int sum) {  
    67.         this.sum = sum;  
    68.     }  
    69.   
    70.     @Override  
    71.     public int compareTo(StudentInfo o) {//建立自己的比较方法  
    72.         int num = new Integer(this.sum).compareTo(new Integer(o.sum));//比较分数  
    73.         if (num == 0) {  
    74.             return this.name.compareTo(o.name);//主条件相同判定次要条件  
    75.         }  
    76.         return num;//返回比较的值，大于正数，相同0，小于负数  
    77.     }  
    78.   
    79.     @Override  
    80.     public int hashCode() {//重写hashcode方法是因为数据有可能存到hashtable中  
    81.         return name.hashCode() + sum * 23;//尽可能保证hashcode值不相同，减少比较次数  
    82.     }  
    83.   
    84.     @Override  
    85.     public boolean equals(Object obj) {//建立自己独有的判断相同方式  
    86.         if (!(obj instanceof StudentInfo)) {  
    87.             throw new ClassCastException("类型不匹配");  
    88.         }  
    89.   
    90.         StudentInfo si = (StudentInfo) obj;  
    91.         return this.name.equals(si.name) && this.sum == si.sum;//姓名和总分相同视为同一人  
    92.     }  
    93.   
    94.     @Override  
    95.     public String toString() {//建立自己的toString方法  
    96.         return "studentinfo[" + name + ", " + ma + ", " + cn + ", " + en + "]";  
    97.     }  
    98. }  
    99.   
    100. class StudentInfoTool {  
    101.     //定义默认比较顺序  
    102.     public static Set<StudentInfo> getStudents() throws IOException {  
    103.   
    104.         return getStudents(null);  
    105.     }  
    106.   
    107.     //定义自定义的比较顺序  
    108.     public static Set<StudentInfo> getStudents(Comparator<StudentInfo> cmp)  
    109.             throws IOException {  
    110.         BufferedReader bfr = new BufferedReader(  
    111.                 new InputStreamReader(System.in));  
    112.   
    113.         Set<StudentInfo> stus = null;  
    114.         if (cmp == null) {  
    115.             stus = new TreeSet<StudentInfo>();  
    116.         } else {  
    117.             stus = new TreeSet<StudentInfo>(cmp);  
    118.         }  
    119.         String line = null;  
    120.         while ((line = bfr.readLine()) != null) {  
    121.             if ("over".equals(line)) {  
    122.                 break;  
    123.             }  
    124.             String[] info = line.split(",");//将数据以“，”切开，形成新的数据  
    125.   
    126.             StudentInfo si = new StudentInfo(info[0],  
    127.                     Integer.parseInt(info[1]), Integer.parseInt(info[2]),  
    128.                     Integer.parseInt(info[3]));  
    129.   
    130.             stus.add(si);  
    131.         }  
    132.   
    133.         bfr.close();  
    134.         return stus;  
    135.     }  
    136.   
    137.     public static void write2File(Set<StudentInfo> stus) throws IOException {  
    138.         BufferedWriter bfw = new BufferedWriter(new FileWriter("stuinfo.txt"));  
    139.   
    140.         for (StudentInfo si : stus) {  
    141.             bfw.write(si.toString() + "	");  
    142.             bfw.write(si.getSum() + "");  
    143.             bfw.newLine();  
    144.             bfw.flush();  
    145.         }  
    146.   
    147.         bfw.close();  
    148.     }  
    }  
  • 相关阅读:
    1.从Node.js链接到MongoDB
    2.mongoDB add user in v3.0 问题的解决（Property 'addUser' of object admin is not a func）
    汇编——模拟试卷二
    汇编——模拟试卷一
    汇编语言——数据处理的两个基本问题（处理的数据在什么地方 要处理的数据有多长）
    汇编语言——更灵活的定位内存地址的方法
    汇编语言——包含多个段的程序
    汇编语言——[bx]和loop指令
    汇编语言——汇编程序从写出到最终执行的过程
    汇编语言——编译器
  • 原文地址：https://www.cnblogs.com/sixrain/p/4912423.html
Copyright © 2020-2023  润新知