java基礎專欄—ArrayFrame（1）

ArrayFrame

ArrayList回顧

• 集合與數組的區別：
  • 集合是長度可變的
  • 集合存儲的是引用類型（自動裝箱）

ArrayList<Integer> array = new ArrayList<Integer>();
array.add(123);

• 對對象的存儲
  • 打印一個對象都會調用toString()方法

集合目標

• 使用集合存儲對象
• 遍歷集合，取出對象
• 集合特性
  • 選擇容器的類型

集合框架繼承目錄

|--`java.util` 

|-- `java.lang.Object`
  |-- `java.util.AbstractCollection<E>`
    |-- `java.util.AbstractList<E>`
      |-- `java.util.ArrayList<E>`
      |-- Iterable<E>,<u>Collection<E></u>,List<E>,RandomAccess
      
      
|--Collection:root
	|--List:可重複，有序
		|--ArrayList
		|--LinkedList
	|--Set:不可重複，無序
		|--HashSet
		|--LinkedHasSet

Collection接口方法

• public void clear()

• public boolean add()

• public boolean remove(Object object)

• public boolean contains(Object object)

  • 是否存在

• Collection<String> coll = new ArrayList<String>();
  //接頭多態

• public int size()

  • 三種長度表現形式
    • 數組.length 返回值int
    • 字符串.length(),返回值int
    • 集合.size,返回值int

• pulblic Object[] toArray()

  • 集合中的元素轉換成數組,應用於IO流

• public Iterator iterator()

• public static boolean isEmpty()

Collection轉型問題

Collection coll = new ArrayList()
  //在不用泛型指定存什麼的狀況下什麼均可以往裏面存
  //既自動向上提型，可是隻有強轉以後纔可調用對應的特性

Iterator

其前身是向量枚舉

Iterator接口方法

iterator存在乎義 集合的存儲方法不同，存取的步驟方式都不同，對於使用者來講不須要學習每一種集合的方法，Iterator來封裝全部的容器的存取方法。

• public boolean hasNext()
• public E next()
• public void remove()

在接口中沒有關於Iterator的方法體，實在實現了Collection的實現類中有public Iterator Iterator

面向接口編程：

​ 接口（interface是一組規則，規定實現該接口的類的方法的規則）

​ 之關心這個方法，可是具體的實現類在那個位置不關心

Iterable接口——高級for循環

實現了Iterable 的類均可以使用高級for循環

for(數據類型 變量名：數組或者集合){
  
}

弊端： 沒有index 不能對容器裏面的內容作修改

Iterator併發修改異常

既在迭代器在工做的時候，集合發生了變化

**例:**對集合使用迭代器方式進行獲取，同時判斷集合中是否存在某個對象，若是有，在添加一個對象。

List<String> list = new ArrayList<String>();
list.add("ABC1");
list.add("ABC2");
list.add("ABC3");
list.add("ABC4");

Iterator it = list.Iterator();
while(it.hasNext()){
  String s = it.next();
  //String不是基礎數據類型，他是引用類型
  //ConcurrentModificationException
  if(s.equals("ABC3")){
      list.add("ABC5");
  }
}

泛型

定義： 明確集合的數據類型，避免安全隱患。

java中的泛型——僞泛型

java經過編譯階段來控制存儲，不符合泛型的數據就不讓存儲

在.class中是沒有泛型的

泛型類，接口，方法

ArrayList<E>，Iterator<E> ,帶<E>就是泛型類或者接口

<T> T[] toArray(T[] a)

public interface List<E>{
    abstract boolean add(E e);
}
//實現接口一種是先實現接口，無論泛型
public class ArrayList<E> implements List<E>{
    
}
//好處是能夠在建立對象的時候去實例是什麼類型的
new ArrayList<String>();
//對於調用者能夠自行建立類型

public class XXX<String> implements List<E>{
    
}

泛型的優勢

• 讓運行時期的錯誤提早到了編譯時期
• 防止在運行時期的轉換異常
• 能夠提早預知發生的錯誤
• 高級 for的使用
• 減小代碼量

泛型的通配符

?就是泛型的通配符

//實現一個方法來讀取不一樣的集合的數據
ArrayList<String> array = new ArrayList<String>();
HashSet<Integer> set = new HashSet<Integer>();

//因爲要實現不一樣的集合的遍歷，將集合當作參數傳進去
//要麼填入他們共同的父類
//要麼填入他們共同的接口
//因爲不一樣的集合都有不一樣的泛型，因此以?來通配全部的泛型
public static void iterator(Collection<?> colle){
	Iterator<?> it = coll.iterator();
  	while(it.hasNext()){
      	//因爲類型不肯定，因此不能強轉
        System.out.print(it.next());
    }
}

泛型實例講解—泛型的限定

將酒店員工(Employee)，廚師(cooker)，服務員(waiter)，經理(managaner)分別存儲到三個集合當中去

定義方法，同時遍歷三個集合，同時能夠代用方法

public class GenericTest{
  public static void main(String[] args){
    ArrayList<cooker> c = new ArrayList<cooker>();
    ArrayList<Waiter> w = new ArrayList<Waiter>();
    ArrayList<Managener> m = new ArrayList<Managener>();
    
    c.add(new Cooker());
    c.add(new Cooker());
    
    w.add(new Waiter());
    w.add(new Waiter());
    
    m.add(new Managener());
    m.add(new Managener());
  }
  
  //？通配符取出來的是Object對象，存在了強制類型轉換（安全隱患）
  //多態思想：強制類型轉換轉換成共同的父類或者共同父接口（employee）
  //泛型的限定：<? extends Employee>
  public static void iterator(ArrayList<? extends Employee> array){
      Iterator<? extends Employee> it = array.iterator();
  }
}

<? extends XXX>父類限定，上限限定，能夠傳入子類

<? super XXX>下限限定，能夠傳入父類和自己

List

• 有序
• 可重複
• 有索引

ArrayList

List接口的大小可變的**數組**的實現，不一樣步的

是最常使用的集合

private transient Object[] elementDate;
private static final Object[] EMPTY_ELEMENTDATE = [];
public ArrayList(){  
  super();
  this.elementDate = EMPTY_ELEMENTDATE;

LinkedList

List接口的隊列實現，單向列，不一樣步的（線程不安全）

提供了大量的首尾操做

• public static void addFirst()

• public static void addLast()

• public static E removeFirst()

• public static E removeLast()

  ​從上面集合框架中可知，LinkedList是Collection的實現類，全部有Collection的方法，咱們只關注他本身的特性方法既帶有索引的方法要研究子類的特有功能就不能使用多態調用

• add(int index, E)

  • 將元素插入到指定的索引上,注意數組越界 IndexOutOfBoundException

• public static E remove(int index)

  • Collection的重載，public static boolean remove(Object obj)
  • E是泛型的知識，表示被刪除的元素

• public static E set(int index, E)

  • 返回被修改的元素

LinkedList<String> link = new LinkedList<String>();

List數據結構

• 堆棧
  • 先進後出：最早存入的元素，最後取出
  • 棧的入口，出口都是棧的頂部
  • 壓棧：在入口處壓入一個元素
  • 彈棧：從入口處取出一個元素
• 隊列
  • 先進先出
  • 隊列的入口，出口各站一側
• 數組
  • 查找快，經過索引能夠快速訪問
  • 增刪慢，因爲地址連續
• 鏈表
  • 查找慢，經過鏈接的節點來查找
  • 增刪快

Vector集合

​ Vector實現了可增加的數組，從java 1.2 以後改進實現了List接口，成爲<u>collection framwork</u>的一部分，可是他是線程同步的，同時也致使了速度慢。

Set

• 元素不可重複

  • 經過查詢equals，來判斷是否爲重複元素

• 能夠採用迭代器，高價for遍歷

• 沒有索引

• 這個接口的方法與Collection中的方法同樣

• 底層數據結構：哈希表（散列）--鏈表數組結合體

  初始容量：默認16，加載因子：0.75

  對象的Hash值：一個普通的十進制數，來自Object的public int hashCode()

  public static void main(String[] args){
    Person p = new Person();
    int i = p.hashCode();
    System.out.println(i);
  }

  結果是不可預知的,hash值是存儲到HashSet中的依據。

hash的存儲過程

1. 調用對象的hash值，而後找有沒有一樣hash值的對象
2. 若是有相同hash值，就去調用對象的equals方法
3. 出現相同的hash值，可是equals不相同，採用桶的存儲方式

存儲自定義對象

對於自定義對象，須要根據不一樣的需求去重寫hashCode()和equals()

參考String類的hash算法：

public int hashCode(){
  int h = hash;//default to 0  
  if(h == 0 && value.length > 0){
    char val[] = value;
    for(int i = 0; i < value.length; i++){
        h = 31 * h + val[i];
    }
    hash = h;
  }
  return hash;
}

若是出現了相同的hash值，就會一直去調用equals方法，就會下降程序的效率

<u>怎樣下降相同hash值出現的機率？</u>

​ 給數據乘一個數，固然這種方法只能是下降機率，並不能解決這個問題

HashSet

​ 由哈希表支持（實質HashMap）

public HashSet(){
  map = new HashMap();
}

LinkedHashSet extends HashSet

​ 具備可預知的迭代順序的set接口，維護着一個運行於全部條目的雙向鏈表,他也是線程不安全的。可是也不容許存儲相同的元素

Map--雙列集合

​ 雙列集合，在繼承關係中，Map和Collection是沒有關係的

1. 不包含重複的key,可是能夠value重複
2. 是一個接口，其實現類是HashMap，LinkedHashMap,HashTable線程安全
3. Entry--關係映射對象實