Java SE Day03

====================
1 ‘u0000′ 字符是編碼為0的字符, 是不可見字符
2 s+=”a”
集合框架(有哪些集合)
集合的迭代(集合元素的遍歷)
集合工具類
比較大小(自定義排序)
包裝類

1 'u0000' 字符是編碼為0的字符, 是不可見字符
   System.out.println('u0000');
   System.out.println((int)'u0000');//0

   'u0000'=0 PK '0'=48
   'u0000'字符的特殊作用: 在c中是字符串的結束標記(結束字符)
   Linux java VM 不輸出u0000 以後的字符
   Windows Java VM 輸出u0000 以後的字符

   *總之建議!: 不要輸出'u0000'

   char[] chs = {65,66,67,0,68};
   System.out.println(chs);//ABC
   System.out.println("A");

   char[] chs = new char[5];//{0,0,0,0,0}
   int size = 0;
   chs[size++]='A';//{'A',0,0,0,0}
   System.out.println(Arrays.copyOf(chs, size));//{'A'}
   System.out.println(chs);//{'A',0,0,0,0}

 2 s+="a"
   String s = a;
   s=s+"a"; //至少創建一個新String對象和新StringBuilder對象
   // s = new StringBuilder(s).append("a").toString();
   //     // new char[16]      append("a") copyOf(chs)



1 集合框架 (Collection and Map, 集合與映射, 容器類(cpp))
 1) List 元素有先後次序的集合, 元素有index位置, 元素可以重複
  繼承與Collection接口, 實現類: ArrayList, Vector, LinkedList
 2) Set 元素無續, 不能重複添加, 是數學意義上的集合, 繼承與
  Collection 接口, 實現類: HashSet(是一個只有Key的HashMap)

 3) Collection 集概念, 沒有說明元素是否重複和有序, 使用集合的
 跟接口, 很少直接使用, 其他集合都是實現類: ArrayList, HashSet
 4) Map 描述了:(key:value) 成對放置的集合, key不重複, Value
 可以重複. key重複算一個. 實現類: HashMap(散列表算法實現)
 TreeMap(二叉排序樹實現,利用Key排序). Map適合檢查查找.

4 Java泛型簡介
 1) Java5 以後提出的語法現象, 在編譯期間期檢查的類型約束.
   運行期不檢查泛型!
 2) 可以用來約束類中元素的類型

5 集合的迭代(遍歷算法)(模仿了數雞蛋的方式)
 1) 迭代操作: 播放列表 的 全部播放, 將撲克牌全部發放
 2) java使用Iterator 接口描述了迭代模式操作
  Iterator 中的方法模式化設計, 專門配合while循環操作
 3) Iterator 的實例可以從集合對象獲得, 是這個集合的一個元素序列
 視圖, 默認包含一個操作游標, 在第一個元素之前, hasNext() 方法
 可以檢查游標是否有下一個元素, next() 方法移動游標到下一個元素
 並且返回這個元素引用. 使用while配合這個兩個方法, 可以迭代處理
 集合的所有元素
 4) 迭代時候可以使用迭代器remove() 方法刪除剛剛迭代的元素
 在迭代過程中, 不能使用集合方法(add, remove, set) 更改集合
 元素

6 Collections 集合的工具類, Arrays 數組的工具類
 1) 排序, 二分查找, 打亂, 填充等操作

7 比較大小
 1) Comparable 可以比較的 用於類實現, 實現這個接口表示: 這個
  類的實例可以比較大小的. 可以進行自然排序.  Comparable
  的實現必須與equals() 的結果一致, 就是相等的對象比較結果一定
  是0!
 2) Comparator 比較工具, 用於臨時定義比較規則, 不是默認比較
    規則

8 java中的包裝類
 1) 包裝類可以把基本類型包裝為對象類型
 2) 有八種包裝類
     int  Integer
     long Long
     byte Byte
     short Short
     float Float
     double Double
     boolean Boolean
     char Character
  3 包裝類提供了 對應數據類型的工具方法
    Integer.toHexString()
    Integer.toString(int)
    Integer.toBinaryString()
    Integer.parseInt(String)
    "3f"->int
    Integer.parstInt(String, int)

    "2.718" -> 2.718
    Double.parseDouble(String str);

自動包裝(auto boxing / unboxing)(java5 以後可以):
  Integer i = 2;// i=new Integer(2);
  Object o = 3.5;
  System.out.println(o instanceof Double); //true
  int a = i+1;// a = i.intValue() + 1;

注意
  1 包裝類是final的類
  2 包裝類對象是不變的, 與字符串類似(不變模式)
    Integer a = 1;
    Integer b = 2;
    a = a+b;
    //a = new Integer(a.intValue() + b.intValue())
  3 包裝類覆蓋了 toString equals hashCode compareTo
注意
  1 包裝類是final的類
  2 包裝類對象是不變的, 與字符串類似(不變模式)
    Integer a = 1;
    Integer b = 2;
    a = a+b;
    //a = new Integer(a.intValue() + b.intValue())
  3 包裝類覆蓋了 toString equals hashCode compareTo



1 集合補遺
  1) 集合複製, 默認的複製規則是淺表(淺層)複製
   A clone() 方法

   B 使用複製構造器!
   Map map = new HashMap();
   Map map2 = new HashMap(map);

   List list1 = new ArrayList();
   List list2 = new LinkedList(list1);
  2) 同步化(線程安全的)
   List list = new ArrayList();
   //synchronizedList 可以將非線程安全的list包裝為線程安全的
   list = Collections.synchronizedList(list);
   轉換以後就相當於 Vector
   HashMap map = new HashMap();
   //synchronizedMap 可以將非線程安全的map包裝為線程安全的
   map = Collections.synchronizedMap(map);

 3) 數組與集合的轉換
  a 數組轉List(只讀的)
     String[] names = {"A","B","C"};
     List list = Arrays.asList(names);//只讀list
     list = new ArrayList(list);//複製為全功能List
     Set set = new HashSet(list);//複製為Set集合
  b 集合轉數組
     Object[] ary1 = list.toArray();//集合轉Object[]
     String[] ary2 = (String[])
     	list.toArray(new String[]{});//集合轉制定類型數組

 4) Collection 與 Collections
   Collection 抽象的集合概念,
   Collections 集合靜態工具類, 包含集合的工具方法
      (sort, 打亂(洗牌)等)

 5) Map的迭代, Map 是 [Key:Value] 組成的集合
  A 對key:value 進行迭代
    map.entrySet();
  B 對Key進行迭代
    map.keySet();
  C 對Value進行迭代
    map.values();
  案例: 統計每個字符出現的次數

2 內部類- 定義在類的內部 的類， 根據位置分為4類
  1) 靜態內部類：使用static修飾，聲明在類體中.
  靜態內部類中可以訪問外部類的靜態成員。

  2) 成員內部類: 聲明在類體中，不使用static，具有類的成員特徵
   也就是，必須有類的實例才能創建內部類實例。內部類實例
   可以訪問共享外部類的成員變量。很常用。
   如：鏈表的節點就可以定義為內部類
  3) 局部內部類：把類聲明在方法中，就是局部內部類，作用域
   類似局部變量。很少見。
  4) 匿名內部類，匿名類：非常常見，可以寫在任何地方,就像一般的語句。
    語法更象是創建對象：
    	Date d = new Date(){};
    匿名類是對原類的一個繼承，同時創建了實例，{} 就是繼承
    以後的類體。類體中可使用所有類的語法。
    匿名類不能寫構造器。
    匿名類可以從抽象類或者接口繼承，必須提供抽象方法的實現。
  5) 任何內部類都編譯成獨立的class文件
  6) 最大的作用：封裝！封裝內部概念:
    情侶間的土豆和菜市場的土豆是不一樣的
  7) 通過實例簡單理解記憶語法.在今後的案例中靈活練習內部類

預習: Java Date, Java 異常, Java IO

Code Package

课堂提纲教案