Java基础13-字符串缓冲流;字节流

作业解析

描述HashMap内部实现原理

HashMap是一种存储机制，存储的是key-value对，key用来保证元素的唯一性。通过hash算法将要存储的对象打散，分布在不同的区间中。
- 当添加对象时，先得到该对象的hashcode，通过hashcode定位到将要存储的区间上，然后将区间中原有的元素依次与该对象进行比对，比对原则有三个：hashcode是否相同、是否是同一对象、equals方法是否返回true。如果没有元素与之相同，则添加到该区间元素的末尾
- 通过key查询时，先得到key对应的hashcode, 然后定位到所在区间，简化了查询，最后按照上述的三个原则进行比对
List Set Map区别
- List
  
  ArrayList: 有序，可重复，线程不安全
  
  LinkedList: 手拉手，线程不安全
  
  Vector: 线程安全
- Set
  
  HashSet: 不可重复，无序，使用键值对存储机制
  
  TreeSet: 通过实现Comparable接口实现排序，或者包装一个对比器Comparator
- Map
  
  HashMap: 键值对，不可重复
  
  HashTable: 线程安全
描述HashSet和HashMap的区别

HashSet集合内部是通过HashMap进行实现的。使用的是HashMap中key部分。对象在添加进集合中时，首选会对hashcode进行处理(hashcode右移16位和自身做异或运算)得到一个经过处理的hash值，然后该值和集合的容量进行&运算，得到介于0和集合容量值之间一个数字。该数字表示着数组的下标。也就是该元素应该存放在哪个集合中。然后按照hashcode1()==hashcode2() && （是否同一对象 || equals() ）与集合中已有元素进行对比，如果没有相同的元素，则添加该元素。

编程实现文本文件的复制。合理设计程序，得到缓冲区的大小的高效区间。

提示缓冲区设置1k开始，不超过10M。

 public static void main(String[] args) throws Exception {

     FileWriter fw = new FileWriter("Test.txt");

     int count=0;

     for(int i=0;i<=10000000;i++) {

         if(count<=1000) {

             count++;

             fw.write(i+",");

         }

         else {

             fw.write("\r\n");

             count=0;

         }

     }

     fw.close();

     System.out.println("over");

     /*

      * 编程实现文本文件的复制。合理设计程序，得到缓冲区的大小的高效区间。

      * 提示：缓冲区设置1k开始，不超过10M。

      * */

     int bufSize=1024;//缓冲区1k开始

     long spendTime = 0;//耗费的时间

     long minTime = Long.MAX_VALUE;//记录最少耗时

     for(int i=1;i<=10*1024;i++) {

         long beginTime = System.currentTimeMillis();

         copyFile("Test.txt","Test2.txt",i*bufSize);

         spendTime = System.currentTimeMillis()-beginTime;

         if(spendTime<minTime) {

             minTime = spendTime;

             System.out.println(i);

         }

     }

     System.out.println(minTime);

     System.out.println("over");

 }

 /*

  * 按给定的缓冲区大小，复制文件src到des

  */

 public static void copyFile(String src,String des,int bufSize) throws Exception {

     FileReader fr = new FileReader(src);

     FileWriter fw = new FileWriter(des);

     char[] buf = new char[bufSize];

     int len = -1;

     while((len=fr.read(buf))!=-1) {

         fw.write(new String(buf,0,len));

     }

     fw.close();

     fr.close();

 }

使用FileWriter，将1-1000000写入到文本中

 package com.kokojia.io;

 import java.io.FileWriter;

 import java.io.IOException;

 public class FileWriterDemo {

     public static void main(String[] args) {

         /**

          * 使用FileWriter，将1-1000000写入到文本中

          */

         FileWriter fw = null;

         try {

             fw = new FileWriter("h1.txt");

             for(int i=1;i<=1000000;i++) {

                 fw.write(i+",");

             }

         } catch (IOException e) {

             e.printStackTrace();

         }

         finally {

             if(fw!=null) {

                 try {

                     fw.close();

                 } catch (IOException e) {

                     e.printStackTrace();

                 }

             }

         }

         System.out.println("over!");

     }

 }

变长参数 + 增强for循环

 package com.kokojia.io;

 public class AvgParAndForDemo {

     public static void main(String[] args) {

         /**

          * 变长参数 + 增强for循环练习

          */

         OutString("a","b","123","中国");

     }

     //变长参数只能有一个，且必须是最后一位形参

     private static void OutString(String...str) {

         for(String s: str) {

             System.out.println(s);

         }

     }

 }

行分隔符在java中可以通过方法得到

System.getProperty("line.separator"); //执行系统属性名

系统属性名是line.separator

windows: \r\n

macOS: \n

字符缓冲区

FileWriter没有缓冲区功能，本身没有新增任何功能，继承的OutputStreamWriter
- 等级树结构：Object ---> Writer ---> OutputStreamWriter ---> FileWriter
```
  writer(){

   //直接写入数据到文件中

  sun.nio.cs.StreamEncoder.write();

  }
```
FileReader
- 继承关系树：Object ---> Reader ---> InputStreamReader ---> FileReader
- read()
  
  读取一个字符
- read(char[])
  
  读取多个字符
```
  read(){

      InputStreamReader.read(){

          sun.nio.StreamDecoder.read();

      }

  }
```

BufferedReader

等级树结构：Object ---> Reader ---> BufferedReader ---> LineNumberReader

  read(){

      char[] cbuf = ... ;

      cbuf[xxx] = c;

      return c;

  }

避免对物理文件的频繁访问

  public static void main(String[] args) throws Exception {

          BufferedReader bufReader = new BufferedReader(new FileReader("d:/foo.txt"));

          String line = null;

          while((line = bufReader.readLine())!=null) {

              System.out.println(line);

          }

          System.out.println("over");

          bufReader.close();

          /*

           * 使用LineNumberReader读取文件的行号

           * 打印输出行号+"."+行内容

           */

          LineNumberReader lineNumReader = new LineNumberReader(new FileReader("d:/foo.txt"));

          while((line=lineNumReader.readLine())!=null) {

              int lineNo = lineNumReader.getLineNumber();

              System.out.println(lineNo+"."+line);

          }

          lineNumReader.close();

          System.out.println("------------");

          /**

           * 使用FileReader和BufferedReader读取文本文件，观察消耗时间

           */

          //非缓冲reader

          FileReader fr = new FileReader("d:\\1.txt");

          //缓冲reader

          BufferedReader br = new BufferedReader(new FileReader("d:\\1.txt"));

          //非缓冲循环读取

          int len = -1;

          //开始时间

          long beginTime = System.currentTimeMillis();

          while((len=fr.read())!=-1) {

          }

          //结束时间

          long endTime = System.currentTimeMillis();

          fr.close();

          System.out.println("reader over!花费了时间"+(endTime-beginTime));//42443

          //缓冲循环读取

          beginTime = System.currentTimeMillis();

          while((len=br.read())!=-1) {

          }

          //结束时间

          endTime = System.currentTimeMillis();

          br.close();

          System.out.println("bufreader over!花费了时间"+(endTime-beginTime));//18654

      }

BufferedWriter

对Writer进行包装，里面定义缓冲区，提供写入单个字符、char[]、String方法，提高写入效率
等级树结构：Object ---> Writer ---> BufferedWriter
flushBuffer(): 清理缓冲区，将缓冲区数据写入目的地

close()方法: 包含flushBuffer()动作

     static char[] buf = null;

     static {

            buf = new char[8192];

            for(int i=0;i<8192;i++) {

                   buf[i]='a';

            }

     }

     public static void main(String[] args) throws Exception {

            PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter("d:/foo.txt")));

            out.println("hello word");

            out.close();

            System.out.println("over");

            //非缓冲

            FileWriter fw = new FileWriter("d:/1.txt");

            //缓冲区

            BufferedWriter bw = new BufferedWriter(new FileWriter("d:/2.txt"),1024*1024);

            /**************非缓冲区writer操作*******/

            //最大次数

            int max = 100000;

            //开始时间

            long startTime = System.currentTimeMillis();

            for(int i=0;i<max;i++) {

                   fw.write(buf);

            }

            fw.close();

            long endTime = System.currentTimeMillis();

            System.out.println("wrtier over! 花费了时间:"+(endTime-startTime));

            /**************缓冲区writer操作*******/

            //开始时间

            startTime = System.currentTimeMillis();

            for(int i=0;i<max;i++) {

                   bw.write(buf);

            }

            bw.close();

            endTime = System.currentTimeMillis();

            System.out.println("bufwrtier over! 花费了时间:"+(endTime-startTime));

     }

内存回收机制

堆中的对象只有在没有引用时才会释放

byte[] bytes = new byte[1023][1024][1024];

byte[] b2 = bytes ;

.

.

.

.

bytes = null ;

几个重要的函数

flush() //清理
refresh() //刷新
clear() //清空

字节流

OutputStream
- 输出流
- FileOutputStream
- 等级树： Object ---> OutputStream --->FileOutputStream
InputStream
- 输入流
- FileInputStream
- 等级树：Object ---> InputStream --->FileInputStream

装饰模式：decorator

实现方式: Buffered 类继承Writer类，在类中添加Writer类型的成员变量，对象应方法进行重写时，调用成员变量的方法进行完成。

 class BufferedWriter extends Writer{

   Writer out;

   char[] cb = new char[8192];

   public void writer(String str){

     //1.先将数据写入缓冲区

     cb.xxx

     //2.如果cb已满，再写入到out中

   }

   public void close(){

     //1.清理cb

     //2.关闭out

   }

 }

时间单位换算：

1s=1000ms

1ms=1000us

1us=1000ns

juint

单元测试框架
方便进行测试时使用
方法签名

import org.juint.Text

@Test

public void  xxx(){

}

作业

阐述BufferedReader和BufferedWriter的工作原理，

是否缓冲区读写器的性能恒大于非缓冲区读写器的性能，为什么，请举例说明？
写入数据1~1000000数字到文件中，分别使用FileWriter和BufferedWriter实现，考察其效率的不同
文件切割：

把较大的文件切割成20k一个的小文件
文件合成：

把小文件合并成大文件
文件归档解档：

0=txt,1=jpg,2=avi,3=gif
Charset类操作: isSupport()
- 通过该类验证平台是否支持一下字符集:
  
  gb2312
  
  GB2312
  
  gbk
  
  GBK
  
  utf-8
  
  utf8
  
  iso8859-1
  
  iso-8859-1
- 取出平台默认的字符集
FileReader.getEncoding();

new String(,,,,,charset);
使用FileInputStream + FileOutputStream / BufferedInputStream + BufferedOuputStream

实现大文件复制，比较复制效率。
阐述对象回收的前提条件。