我們有這麼一個場景，給你一個列表，可以動態的新增，但是最終要求列表升序，要求長度小於20，可以怎麼做？

這個還不簡單，幾行程式碼就可以了

public List<Integer> trimList(List<Integer> list, int add) {
    list.add(add);
    list.sort(null);
    if (list.size() > 20) {
        list = list.subList(0, 20);
    }
    return list;
}

<!-- more -->

1. 測試驗證

上面的程式碼先不考慮效能的優化方面，有沒有問題？

寫了個簡單的測試case，我們來看下會出現什麼情況

@Test
public void testTri() throws InterruptedException {
    List<Integer> list = new ArrayList<>(30);
    Random random = new Random();
    int cnt = 0;
    while (true) {
        list = trimList(list, random.nextInt(100000));

        Thread.sleep(1);
        ++cnt;
        System.out.println(list + " >> " + cnt);
    }
}
 

啟動引數修改下，新增jvm最大記憶體條件 -Xmx3m， 然後跑上面程式碼，一段時間之後居然出現stack over flow

有意思的問題來了，從邏輯上看，這個陣列固定長度為20，頂多有21條資料，怎麼就會記憶體溢位呢？

2. SubList 方法揭祕

我們看下ArrayList#sublis方法的實現邏輯，就可以發現獲取子列表，居然只是重置了一下內部陣列的索引

public List<E> subList(int fromIndex, int toIndex) {
    subListRangeCheck(fromIndex, toIndex, size);
    return new SubList(this, 0, fromIndex, toIndex);
}

private class SubList extends AbstractList<E> implements RandomAccess {
    private final AbstractList<E> parent;
    private final int parentOffset;
    private final int offset;
    int size;
  
    SubList(AbstractList<E> parent,
            int offset, int fromIndex, int toIndex) {
        this.parent = parent;
        this.parentOffset = fromIndex;
        this.offset = offset + fromIndex;
        this.size = toIndex - fromIndex;
        this.modCount = ArrayList.this.modCount;
    }
    ...
}
 

返回的是一個SubList型別物件，這個物件和原來的List公用一個儲存資料的陣列，但是多了兩個記錄子列表起始的偏移;

然後再看下SubList的add方法，也是直接在原來的陣列中新增資料，想到與原來的列表在指定位置插入資料

public void add(int index, E e) {
    rangeCheckForAdd(index);
    checkForComodification();
    parent.add(parentOffset + index, e);
    this.modCount = parent.modCount;
    this.size++;
}

所以上面實現的程式碼中 list = list.subList(0, 20); 這一行，有記憶體洩露，貌似是隻返回了一個20長度大小的列表，但是這個列表中的陣列長度，可能遠遠不止20

為了驗證上面的說法，debug下上面的測試用例

動圖演示如下

3. 正確使用姿勢

上面知道sublist並不會新建立一個列表，舊的資料依然還在，只是我們用不了而已，所以改動也很簡單，根據sublist的結果建立一個新的陣列就好了

public List<Integer> trimList(List<Integer> list, int add) {
    list.add(add);
    list.sort(null);
    if (list.size() > 20) {
        list = new ArrayList<>(list.subList(0, 20));
    }
    return list;
}

再次測試，程式碼一直在順利的執行，看下後面的計數，都已經5w多，前面1w多久報錯了

雖然上面解決了記憶體洩露，但是gc也很頻繁了，本篇的重點主要是指出sublist的錯誤使用姿勢，所以上面演算法的優化就不詳細展開了

4. 知識點擴充套件

看下下面的測試程式碼輸出應該是什麼

@ToString
public static class InnerC {
    private String name;
    private Integer id;

    public InnerC(String name, Integer id) {
        this.name = name;
        this.id = id;
    }
}

@Test
public void subList() {
    List<Integer> list = new ArrayList<>();
    for (int i = 0; i < 20; i++) {
        list.add(i);
    }

    // case 1
    List<Integer> sub = list.subList(10, 15);
    sub.add(100);
    System.out.println("list: " + list);
    System.out.println("sub: " + sub);

    // case 2
    list.set(11, 200);
    System.out.println("list: " + list);
    System.out.println("sub: " + sub);

    // case 3
    list = new ArrayList<>(sub);
    sub.set(0, 999);
    System.out.println("list: " + list);
    System.out.println("sub: " + sub);

    // case 4
    List<InnerC> cl = new ArrayList<>();
    cl.add(new InnerC("a", 1));
    cl.add(new InnerC("a2", 2));
    cl.add(new InnerC("a3", 3));
    cl.add(new InnerC("a4", 4));

    List<InnerC> cl2 = new ArrayList<>(cl.subList(1, 3));
    cl2.get(0).name = "a5";
    cl2.get(0).id = 5;
    System.out.println("list cl: " + cl);
    System.out.println("list cl2: " + cl2);
}

再看具體的答案之前，先分析一下

針對case1/2，我們知道sublist返回的列表和原列表公用一個底層陣列，所以這兩個列表的增刪，都是相互影響的

• case1 執行之後相當於在list陣列的下標15這裡，插入資料100
• case2 執行之後，list的下標11，相當於sub的下標1，也就是說sub[1] 變成了200

對於case3/4 而言，根據sub建立了一個新的列表，這個時候修改新的列表中的值，會影響到原來的列表中的值麼？

分析這個場景，就需要看一下原始碼了

public ArrayList(Collection<? extends E> c) {
    elementData = c.toArray();
    if ((size = elementData.length) != 0) {
        // c.toArray might (incorrectly) not return Object[] (see 6260652)
        if (elementData.getClass() != Object[].class)
            elementData = Arrays.copyOf(elementData, size, Object[].class);
    } else {
        // replace with empty array.
        this.elementData = EMPTY_ELEMENTDATA;
    }
}

// 對應的核心邏輯就在 Arrays.copyOf，而這個方法主要呼叫的是native方法`System.arraycopy`

public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
    @SuppressWarnings("unchecked")
    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;
}

從上面的原始碼分析，會不會相互影響就看這個陣列拷貝是怎麼實現的了（深拷貝？淺拷貝？）

---

接下來看下實際的輸出結果

list: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 100, 15, 16, 17, 18, 19]
sub: [10, 11, 12, 13, 14, 100]
list: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 200, 12, 13, 14, 100, 15, 16, 17, 18, 19]
sub: [10, 200, 12, 13, 14, 100]
list: [10, 200, 12, 13, 14, 100]
sub: [999, 200, 12, 13, 14, 100]
list cl: [BasicTest.InnerC(name=a, id=1), BasicTest.InnerC(name=a5, id=5), BasicTest.InnerC(name=a3, id=3), BasicTest.InnerC(name=a4, id=4)]
list cl2: [BasicTest.InnerC(name=a5, id=5), BasicTest.InnerC(name=a3, id=3)]

從上面可以知道，case1/2的分析沒啥問題，case3、4的輸出有點意思了

• 陣列內為Integer時，兩者互不影響
• 陣列內為普通物件時，修改其中一個，會影響另外一個

關從輸出結果來看 System.arraycopy 是淺拷貝，至於為什麼int不影響呢，這個就和方法呼叫傳參是基本資料型別時，在方法內部修改引數不會影響到外部一個道理了

II. 其他

盡信書則不如，已上內容，純屬一家之言，因個人能力有限，難免有疏漏和錯誤之處，如發現bug或者有更好的建議，歡迎批評指正，不吝感激

• 微博地址: 小灰灰Blog
• QQ： 一灰灰/3302797840
• 個人部落格站點 一灰灰Blog： https://liuyueyi.github.io/hexblog

一灰灰blog

相關推薦