天天看點
傳回

03.Java資料結構問題

目錄介紹

  • 3.0.0.1 在arrayList中System.arraycopy()和Arrays.copyOf()方法差別聯系？System.arraycopy()和Arrays.copyOf()代碼說明？
  • 3.0.0.2 SparseArray基本介紹，相比HashMap為什麼性能會好？
  • 3.0.0.3 Arrays和Collections 對于sort的不同實作原理？說一說它們的差別……
  • 3.0.0.4 Java集合架構中有哪些類？都有什麼特點？Java集合的快速失敗機制 “fail-fast”？
  • 3.0.0.5 ArrayList，Vector和LinkList的差別，底層分别是怎麼實作的，存儲空間是如何擴容的？什麼是加載因子？
  • 3.0.0.6 如何了解ArrayList的擴容消耗？Arrays.asList方法後的List可以擴容嗎？ArrayList如何序列化？
  • 3.0.0.7 如何了解list集合讀寫機制和讀寫效率？什麼是CopyOnWriteArrayList，它與ArrayList有何不同？
  • 3.0.1.0 HashSet和TreeSet的差別？是如何保證唯一值的，底層怎麼做到的？
  • 3.0.1.5 HashMap和Hashtable的差別？HashMap在put、get元素的過程？展現了什麼資料結構？
  • 3.0.1.6 如何保證HashMap線程安全？底層怎麼實作的？HashMap是有序的嗎？如何實作有序？
  • 3.0.1.7 HashMap存儲兩個對象的hashcode相同會發生什麼？如果兩個鍵的hashcode相同，你如何擷取值對象？
  • 3.0.1.8 HashMap為什麼不直接使用hashCode()處理後的哈希值直接作為table的下标？
  • 3.0.1.9 為什麼HashMap中String、Integer這樣的包裝類适合作為K？為啥不用其他作key值？
  • 3.0.2.0 HashMap是如何擴容的？如何了解HashMap的大小超過了負載因子定義的容量？重新調整HashMap大小存在什麼問題嗎？

好消息

  • 部落格筆記大彙總【15年10月到至今】，包括Java基礎及深入知識點，Android技術部落格，Python學習筆記等等，還包括平時開發中遇到的bug彙總，當然也在工作之餘收集了大量的面試題，長期更新維護并且修正，持續完善……開源的檔案是markdown格式的！同時也開源了生活部落格，從12年起，積累共計500篇[近100萬字]，将會陸續發表到網上，轉載請注明出處，謝謝！
  • 連結位址： https://github.com/yangchong211/YCBlogs
  • 如果覺得好，可以star一下，謝謝！當然也歡迎提出建議，萬事起于忽微，量變引起質變！所有部落格将陸續開源到GitHub！

  • System.arraycopy()和Arrays.copyOf()方法差別？
    • 比如下面add(int index, E element)方法就很巧妙的用到了arraycopy()方法讓數組自己複制自己實作讓index開始之後的所有成員後移一個位置: 
      /**
 * 在此清單中的指定位置插入指定的元素。 
 * 先調用 rangeCheckForAdd 對index進行界限檢查；然後調用 ensureCapacityInternal 方法保證capacity足夠大；
 * 再将從index開始之後的所有成員後移一個位置；将element插入index位置；最後size加1。
 */
public void add(int index, E element) {
    rangeCheckForAdd(index);
    ensureCapacityInternal(size + 1); 
    //arraycopy()方法實作數組自己複制自己
    //elementData:源數組;index:源數組中的起始位置;elementData：目标數組；index + 1：目标數組中的起始位置； size - index：要複制的數組元素的數量；
    System.arraycopy(elementData, index, elementData, index + 1, size - index);
    elementData[index] = element;
    size++;
}
    • 如toArray()方法中用到了copyOf()方法 
      /**
 *以正确的順序（從第一個到最後一個元素）傳回一個包含此清單中所有元素的數組。 
 *傳回的數組将是“安全的”，因為該清單不保留對它的引用。 （換句話說，這個方法必須配置設定一個新的數組）。
 *是以，調用者可以自由地修改傳回的數組。 此方法充當基于陣列和基于集合的API之間的橋梁。
 */
public Object[] toArray() {
//elementData：要複制的數組；size：要複制的長度
    return Arrays.copyOf(elementData, size);
}
    • 兩者聯系與差別
      • 看了上面的兩者源代碼可以發現

        copyOf()

         内部調用了

        System.arraycopy()

         方法
      • 技術部落格大總結
      • 差別：
        • 1.arraycopy()需要目标數組，将原數組拷貝到你自己定義的數組裡，而且可以選擇拷貝的起點和長度以及放入新數組中的位置
        • 2.copyOf()是系統自動在内部建立一個數組，并傳回該數組。
  • System.arraycopy()和Arrays.copyOf()代碼說明？
    • 使用System.arraycopy()方法 
      public static void main(String[] args) {
    // TODO Auto-generated method stub
    int[] a = new int[10];
    a[0] = 0;
    a[1] = 1;
    a[2] = 2;
    a[3] = 3;
    System.arraycopy(a, 2, a, 3, 3);
    a[2]=99;
    for (int i = 0; i < a.length; i++) {
        System.out.println(a[i]);
    }
}

//結果：
//0 1 99 2 3 0 0 0 0 0
    • 使用Arrays.copyOf()方法。 
      public static void main(String[] args) {
    int[] a = new int[3];
    a[0] = 0;
    a[1] = 1;
    a[2] = 2;
    int[] b = Arrays.copyOf(a, 10);
    System.out.println("b.length"+b.length);
    //結果：
    //10
}
    • 得出結論

      • arraycopy()

         需要目标數組，将原數組拷貝到你自己定義的數組裡或者原數組，而且可以選擇拷貝的起點和長度以及放入新數組中的位置

        copyOf()

         是系統自動在内部建立一個數組，并傳回該數組。

  • 位于android.util，Android 中的資料結構，針對移動端做了優化，在資料量比較少的情況下，性能會好過 HashMap，類似于 HashMap，key:int ,value:object 。
  • 1.key 和 value 采用數組進行存儲。存儲 key 的數組是 int 類型，不需要進行裝箱操作。提供了速度。
  • 2.采用二分查找法，在插入進行了排序，是以兩個數組是按照從小到大進行排序的。
  • 3.在查找的時候，進行二分查找，資料量少的情況下，速度比較快。

  • 1、Arrays.sort()
    • 該算法是一個經過調優的快速排序，此算法在很多資料集上提供N*log(N)的性能，這導緻其他快速排序會降低二次型性能。
  • 2、Collections.sort()
    • 該算法是一個經過修改的合并排序算法（其中，如果低子清單中的最高元素效益高子清單中的最低元素，則忽略合并）。此算法可提供保證的N*log(N)的性能，此實作将指定清單轉儲到一個數組中，然後再對數組進行排序，在重置數組中相應位置處每個元素的清單上進行疊代。
  • 它們的差別

  • 可将Java集合架構大緻可分為Set、List、Queue 和Map四種體系
    • Set：代表無序、不可重複的集合，常見的類如HashSet、TreeSet
    • List：代表有序、可重複的集合，常見的類如動态數組ArrayList、雙向連結清單LinkedList、可變數組Vector
    • Map：代表具有映射關系的集合，常見的類如HashMap、LinkedHashMap、TreeMap
    • Queue：代表一種隊列集合
  • Java集合的快速失敗機制 “fail-fast”
    • java集合的一種錯誤檢測機制，當多個線程對集合進行結構上的改變的操作時，有可能會産生 fail-fast 機制。
      • 例如：假設存在兩個線程（線程1、線程2），線程1通過Iterator在周遊集合A中的元素，在某個時候線程2修改了集合A的結構（是結構上面的修改，而不是簡單的修改集合元素的内容），那麼這個時候程式就會抛出 ConcurrentModificationException 異常，進而産生fail-fast機制。
    • 原因：
      • 疊代器在周遊時直接通路集合中的内容，并且在周遊過程中使用一個 modCount 變量。集合在被周遊期間如果内容發生變化，就會改變modCount的值。每當疊代器使用hashNext()/next()周遊下一個元素之前，都會檢測modCount變量是否為expectedmodCount值，是的話就傳回周遊；否則抛出異常，終止周遊。
    • 解決辦法：
      • 1.在周遊過程中，所有涉及到改變modCount值得地方全部加上synchronized。
      • 2.使用CopyOnWriteArrayList來替換ArrayList

3.0.0.5 ArrayList，Vector和LinkList的差別，底層分别是怎麼實作的？存儲空間是如何擴容的？什麼是加載因子？

  • ArrayList
    • ArrayList的底層結構是數組，可用索引實作快速查找；是動态數組，相比于數組容量可實作動态增長。
    • ArrayList非線程安全，建議在單線程中才使用ArrayList，而在多線程中可以選擇Vector或者CopyOnWriteArrayList；預設初始容量為10，每次擴容為原來的1.5倍
  • Vector
    • 和ArrayList幾乎是一樣的，Vector使用了synchronized關鍵字，是線程安全的，比ArrayList開銷更大，通路更慢；預設初始容量為10，預設每次擴容為原來的2倍，可通過capacityIncrement屬性設定
  • LinkList
    • LinkedList底層結構是連結清單，增删速度快；是一個雙向循環連結清單，也可以被當作堆棧、隊列或雙端隊列

  • 如何了解ArrayList的擴容消耗
    • 由于ArrayList使用elementData = Arrays.copyOf(elementData, newCapacity);進行擴容，而每次都會重新建立一個newLength長度的數組，是以擴容的空間複雜度為O(n),時間複雜度為O(n) 
    public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
    T[] copy = ((Object)newType == (Object)Object[].class)
        ? (T[]) new Object[newLength]
        : (T[]) Array.newInstance(newType.getComponentType(), newLength);
    System.arraycopy(original, 0, copy, 0,
                     Math.min(original.length, newLength));
    return copy;
}
  • Arrays.asList方法後的List可以擴容嗎？
    • 不能，asList傳回的List為隻讀的。其原因為：asList方法傳回的ArrayList是Arrays的一個内部類，并且沒有實作add，remove等操作
  • List怎麼實作排序？
    • 實作排序，可以使用自定義排序：list.sort(new Comparator(){...})
    • 或者使用Collections進行快速排序：Collections.sort(list)
  • ArrayList如何序列化？
    • ArrayList 基于數組實作，并且具有動态擴容特性，是以儲存元素的數組不一定都會被使用，那麼就沒必要全部進行序列化。
    • 儲存元素的數組 elementData 使用 transient 修飾，該關鍵字聲明數組預設不會被序列化。 
    transient Object[] elementData; // non-private to simplify nested class access
    • ArrayList 實作了 writeObject() 和 readObject() 來控制隻序列化數組中有元素填充那部分内容。 
    private void readObject(java.io.ObjectInputStream s)
    throws java.io.IOException, ClassNotFoundException {
    elementData = EMPTY_ELEMENTDATA;
    s.defaultReadObject();
    s.readInt(); // ignored
    if (size > 0) {
        ensureCapacityInternal(size);
        Object[] a = elementData;
        for (int i=0; i<size; i++) {
            a[i] = s.readObject();
        }
    }
}

private void writeObject(java.io.ObjectOutputStream s)
    throws java.io.IOException{
    int expectedModCount = modCount;
    s.defaultWriteObject();
    s.writeInt(size);
    for (int i=0; i<size; i++) {
        s.writeObject(elementData[i]);
    }
    if (modCount != expectedModCount) {
        throw new ConcurrentModificationException();
    }
}
    • 序列化時需要使用 ObjectOutputStream 的 writeObject() 将對象轉換為位元組流并輸出。而 writeObject() 方法在傳入的對象存在 writeObject() 的時候會去反射調用該對象的 writeObject() 來實作序列化。反序列化使用的是 ObjectInputStream 的 readObject() 方法，原理類似。 
    ArrayList list = new ArrayList();
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(file));
oos.writeObject(list);

  • 讀寫機制
    • ArrayList在執行插入元素是超過目前數組預定義的最大值時，數組需要擴容，擴容過程需要調用底層System.arraycopy()方法進行大量的數組複制操作；在删除元素時并不會減少數組的容量（如果需要縮小數組容量，可以調用trimToSize()方法）；在查找元素時要周遊數組，對于非null的元素采取equals的方式尋找。
    • LinkedList在插入元素時，須建立一個新的Entry對象，并更新相應元素的前後元素的引用；在查找元素時，需周遊連結清單；在删除元素時，要周遊連結清單，找到要删除的元素，然後從連結清單上将此元素删除即可。
    • Vector與ArrayList僅在插入元素時容量擴充機制不一緻。對于Vector，預設建立一個大小為10的Object數組，并将capacityIncrement設定為0；當插入元素數組大小不夠時，如果capacityIncrement大于0，則将Object數組的大小擴大為現有size+capacityIncrement；如果capacityIncrement<=0,則将Object數組的大小擴大為現有大小的2倍。
  • 讀寫效率
    • ArrayList對元素的增加和删除都會引起數組的記憶體配置設定空間動态發生變化。是以，對其進行插入和删除速度較慢，但檢索速度很快。
    • LinkedList由于基于連結清單方式存放資料，增加和删除元素的速度較快，但是檢索速度較慢。
  • 什麼是CopyOnWriteArrayList，它與ArrayList有何不同？
    • CopyOnWriteArrayList是ArrayList的一個線程安全的變體，其中所有可變操作（add、set等等）都是通過對底層數組進行一次新的複制來實作的。相比較于ArrayList它的寫操作要慢一些，因為它需要執行個體的快照。
    • CopyOnWriteArrayList中寫操作需要大面積複制數組，是以性能肯定很差，但是讀操作因為操作的對象和寫操作不是同一個對象，讀之間也不需要加鎖，讀和寫之間的同步處理隻是在寫完後通過一個簡單的"="将引用指向新的數組對象上來，這個幾乎不需要時間，這樣讀操作就很快很安全，适合在多線程裡使用，絕對不會發生ConcurrentModificationException ，是以CopyOnWriteArrayList适合使用在讀操作遠遠大于寫操作的場景裡，比如緩存。

  • HashSet
    • 不能保證元素的排列順序；使用Hash算法來存儲集合中的元素，有良好的存取和查找性能；通過equal()判斷兩個元素是否相等，并兩個元素的hashCode()傳回值也相等
  • TreeSet
    • 是SortedSet接口的實作類，根據元素實際值的大小進行排序；采用紅黑樹的資料結構來存儲集合元素；支援兩種排序方法：自然排序（預設情況）和定制排序。前者通過實作Comparable接口中的compareTo()比較兩個元素之間大小關系，然後按升序排列；後者通過實作Comparator接口中的compare()比較兩個元素之間大小關系，實作定制排列

  • HashMap
    • 基于AbstractMap類，實作了Map、Cloneable（能被克隆）、Serializable（支援序列化）接口； 非線程安全；允許存在一個為null的key和任意個為null的value；采用連結清單散列的資料結構，即數組和連結清單的結合；初始容量為16，填充因子預設為0.75，擴容時是目前容量翻倍，即2capacity
  • Hashtable
    • 基于Map接口和Dictionary類；線程安全，開銷比HashMap大，如果多線程通路一個Map對象，使用Hashtable更好；不允許使用null作為key和value；底層基于哈希表結構；初始容量為11，填充因子預設為0.75，擴容時是容量翻倍+1，即2capacity+1
    • HashTable裡使用的是synchronized關鍵字，這其實是對對象加鎖，鎖住的都是對象整體，當Hashtable的大小增加到一定的時候，性能會急劇下降，因為疊代時需要被鎖定很長的時間。
  • HashMap在put、get元素的過程
    • 向Hashmap中put元素時，首先判斷key是否為空，為空則直接調用putForNullKey()，不為空則計算key的hash值得到該元素在數組中的下标值；如果數組在該位置處沒有元素，就直接儲存；如果有，還要比較是否存在相同的key，存在的話就覆寫原來key的value，否則将該元素儲存在鍊頭，先儲存的在鍊尾。
    • 從Hashmap中get元素時，計算key的hash值找到在數組中的對應的下标值，傳回該key對應的value即可，如果有沖突就周遊該位置連結清單尋找key相同的元素并傳回對應的value
  • 展現了什麼資料結構
    • HashMap采用連結清單散列的資料結構，即數組和連結清單的結合，在Java8後又結合了紅黑樹，當連結清單元素超過8個将連結清單轉換為紅黑樹

  • 使用ConcurrentHashMap可保證線程安全
    • ConcurrentHashMap是線程安全的HashMap，它采取鎖分段技術，将資料分成一段一段的存儲，然後給每一段資料配一把鎖，當一個線程占用鎖通路其中一個段資料的時候，其他段的資料也能被其他線程通路。在JDK1.8中對ConcurrentHashmap做了兩個改進：
      • 取消segments字段，直接采用transient volatile HashEntry[] table儲存資料，将數組元素作為鎖，對每一行資料進行加鎖，可減少并發沖突的機率
      • 資料結構由“數組＋單向連結清單”變為“數組＋單向連結清單＋紅黑樹”，使得查詢的時間複雜度可以降低到O(logN)，改進一定的性能。
    • 通俗一點解釋：ConcurrentHashMap引入了分割(Segment)，可以了解為把一個大的Map拆分成N個小的HashTable，在put方法中，會根據hash(paramK.hashCode())來決定具體存放進哪個Segment，如果檢視Segment的put操作，我們會發現内部使用的同步機制是基于lock操作的，這樣就可以對Map的一部分（Segment）進行上鎖，這樣影響的隻是将要放入同一個Segment的元素的put操作，保證同步的時候，鎖住的不是整個Map（HashTable就是這麼做的），相對于HashTable提高了多線程環境下的性能，是以HashTable已經被淘汰了。
  • 使用LinkedHashMap可實作有序
    • HashMap是無序的，而LinkedHashMap是有序的HashMap，預設為插入順序，還可以是通路順序，基本原理是其内部通過Entry維護了一個雙向連結清單，負責維護Map的疊代順序

  • HashMap存儲兩個對象的hashcode相同會發生什麼？
    • 錯誤回答：因為hashcode相同，是以兩個對象是相等的，HashMap将會抛出異常，或者不會存儲它們。
    • 正确回答：兩個對象就算hashcode相同，但是它們可能并不相等。如果不明白，可以先看看我的這篇部落格： Hash和HashCode深入了解 。回答“因為hashcode相同，是以它們的bucket位置相同，‘碰撞’會發生。因為HashMap使用連結清單存儲對象，這個Entry(包含有鍵值對的Map.Entry對象)會存儲在連結清單中。
  • HashMap1.7和1.8的差別
    • 在JDK1.6，JDK1.7中，HashMap采用數組+連結清單實作，即使用連結清單處理沖突，同一hash值的連結清單都存儲在一個連結清單裡。但是當位于一個連結清單中的元素較多，即hash值相等的元素較多時，通過key值依次查找的效率較低。
    • JDK1.8中，HashMap采用位數組+連結清單+紅黑樹實作，當連結清單長度超過門檻值（8）時，将連結清單轉換為紅黑樹，這樣大大減少了查找時間。
  • 如果兩個鍵的hashcode相同，你如何擷取值對象？
    • 當調用get()方法，HashMap會使用鍵對象的hashcode找到bucket位置，然後擷取值對象。當然如果有兩個值對象儲存在同一個bucket，将會周遊連結清單直到找到值對象。
    • 在沒有值對象去比較，如何确定确定找到值對象的？因為HashMap在連結清單中存儲的是鍵值對，找到bucket位置之後，會調用keys.equals()方法去找到連結清單中正确的節點，最終找到要找的值對象。

  • 不直接使用hashCode()處理後的哈希值
    • hashCode()方法傳回的是int整數類型，其範圍為-(2^31)~(2^31-1)，約有40億個映射空間，而HashMap的容量範圍是在16（初始化預設值）~2 ^ 30，HashMap通常情況下是取不到最大值的，并且裝置上也難以提供這麼多的存儲空間，進而導緻通過hashCode()計算出的哈希值可能不在數組大小範圍内，進而無法比對存儲位置；
  • HashMap是使用了哪些方法來有效解決哈希沖突的
    • 1.使用鍊位址法（使用散清單）來連結擁有相同hash值的資料；
    • 2.使用2次擾動函數（hash函數）來降低哈希沖突的機率，使得資料分布更平均；
    • 3.引入紅黑樹進一步降低周遊的時間複雜度，使得周遊更快；
  • 如何解決比對存儲位置問題
    • HashMap自己實作了自己的hash()方法，通過兩次擾動使得它自己的哈希值高低位自行進行異或運算，降低哈希碰撞機率也使得資料分布更平均；
    • 在保證數組長度為2的幂次方的時候，使用hash()運算之後的值與運算（&）（數組長度 - 1）來擷取數組下标的方式進行存儲，這樣一來是比取餘操作更加有效率，二來也是因為隻有當數組長度為2的幂次方時，h&(length-1)才等價于h%length，三來解決了“哈希值與數組大小範圍不比對”的問題；
  • 為什麼數組長度要保證為2的幂次方呢？
    • 隻有當數組長度為2的幂次方時，h&(length-1)才等價于h%length，即實作了key的定位，2的幂次方也可以減少沖突次數，提高HashMap的查詢效率；
    • 如果 length 為 2 的次幂 則 length-1 轉化為二進制必定是 11111……的形式，在于 h 的二進制與操作效率會非常的快，而且空間不浪費；如果 length 不是 2 的次幂，比如 length 為 15，則 length - 1 為 14，對應的二進制為 1110，在于 h 與操作，最後一位都為 0 ，而 0001，0011，0101，1001，1011，0111，1101 這幾個位置永遠都不能存放元素了，空間浪費相當大，更糟的是這種情況中，數組可以使用的位置比數組長度小了很多，這意味着進一步增加了碰撞的幾率，減慢了查詢的效率！這樣就會造成空間的浪費。

  • 為什麼HashMap中String、Integer這樣的包裝類适合作為K？
    • String、Integer等包裝類的特性能夠保證Hash值的不可更改性和計算準确性，能夠有效的減少Hash碰撞的幾率
      • 都是final類型，即不可變性，保證key的不可更改性，不會存在擷取hash值不同的情況
      • 内部已重寫了equals()、hashCode()等方法，遵守了HashMap内部的規範（不清楚可以去上面看看putValue的過程），不容易出現Hash值計算錯誤的情況；
  • 想要讓自己的Object作為K應該怎麼辦呢？
    • 重寫hashCode()和equals()方法
      • 重寫hashCode()是因為需要計算存儲資料的存儲位置，需要注意不要試圖從散列碼計算中排除掉一個對象的關鍵部分來提高性能，這樣雖然能更快但可能會導緻更多的Hash碰撞；
      • 重寫equals()方法，需要遵守自反性、對稱性、傳遞性、一緻性以及對于任何非null的引用值x，x.equals(null)必須傳回false的這幾個特性，目的是為了保證key在哈希表中的唯一性；
  • 總結
    • 采用合适的equals()和hashCode()方法的話，将會減少碰撞的發生，提高效率。不可變性使得能夠緩存不同鍵的hashcode，這将提高整個擷取對象的速度，使用String，Interger這樣的wrapper類作為鍵是非常好的選擇。

  • HashMap是為啥要擴容
    • 當連結清單數組的容量超過初始容量*加載因子（預設0.75）時，再散列将連結清單數組擴大2倍，把原連結清單數組的搬移到新的數組中。為什麼需要使用加載因子？為什麼需要擴容呢？因為如果填充比很大，說明利用的空間很多，如果一直不進行擴容的話，連結清單就會越來越長，這樣查找的效率很低，擴容之後，将原來連結清單數組的每一個連結清單分成奇偶兩個子連結清單分别挂在新連結清單數組的散列位置，這樣就減少了每個連結清單的長度，增加查找效率。
  • 如何了解HashMap的大小超過了負載因子(load factor)定義的容量？
    • 預設的負載因子大小為0.75，也就是說，當一個map填滿了75%的bucket時候，和其它集合類(如ArrayList等)一樣，将會建立原來HashMap大小的兩倍的bucket數組，來重新調整map的大小，并将原來的對象放入新的bucket數組中。這個過程叫作rehashing，因為它調用hash方法找到新的bucket位置。
  • 重新調整HashMap大小存在什麼問題嗎？
    • 當多線程的情況下，可能産生條件競争。當重新調整HashMap大小的時候，确實存在條件競争，因為如果兩個線程都發現HashMap需要重新調整大小了，它們會同時試着調整大小。在調整大小的過程中，存儲在連結清單中的元素的次序會反過來，因為移動到新的bucket位置的時候，HashMap并不會将元素放在連結清單的尾部，而是放在頭部，這是為了避免尾部周遊(tail traversing)。如果條件競争發生了，那麼就死循環了。

其他介紹

01.關于部落格彙總連結

02.關于我的部落格

存儲 安全 算法 java 索引 android開發 人工智能 緩存 Python api java資料結構問題 java什麼資料結構 java元件資料 java資料結構說明 java資料問題
上一篇: SLS機器學習介紹（04）：規則模式挖掘
下一篇: 車蘿蔔CEO馬斌斌：真正自動駕駛的時候你更需要HUD和ARHUD

繼續閱讀