JS的直覺方案：
對於陣列去重，只要寫過程式的，立刻就能得到第一個解法：

function unique(arr) {
  var ret = []

  for (var i = 0; i < arr.length; i++) {
    var item = arr[i]
    if (ret.indexOf(item) === -1) {
      ret.push(item)
    }
  }

  return ret
}

優化方案：

核心是構建了一個 hash 物件來替代 indexOf. 注意在 JavaScript 裡，物件的鍵值只能是字串，因此需要 var key = typeof(item) + item 來區分數值 1 和字串 ‘1’ 等情況

function unique(arr) {
  var ret = []
  var hash = {}

  for (var i = 0; i < arr.length; i++) {
    var item = arr[i]
    var key = typeof(item) + item
    if (hash[key] !== 1) {
      ret.push(item)
      hash[key] = 1
    }
  }

  return ret
}

靈活應用：

totalIncomeList =[]; //模擬資料
        totalIncomeList.push({tranDate:'20180023'
 
,tranAmt:'1100'})
        totalIncomeList.push({tranDate:'20171122',tranAmt:'1100'})
        totalIncomeList.push({tranDate:'20190345',tranAmt:'300'})
        totalIncomeList.push({tranDate:'20171232',tranAmt:'1540'})
        totalIncomeList.push({tranDate:'20171230',tranAmt:'1540'})

        //排序演算法.
        if(totalIncomeList && totalIncomeList.length>0
 
){
            for(let i = 0 ; i<totalIncomeList.length; i++){
                for(let j = 0; j <totalIncomeList.length-i-1; j++){
                    let firtStr = totalIncomeList[j].tranDate.substring(0,4);
                    let lastStr = totalIncomeList[j+1].tranDate.substring(0,4);
                    if(firtStr < lastStr){
                        let temp = totalIncomeList[j + 1];
                        totalIncomeList[j+ 1] = totalIncomeList[j];
                        totalIncomeList[j] = temp;
                    }
                }
            }
            //去重演算法
            var ret = [];
            for(let y=0;y<totalIncomeList.length;y++) {
                let item = totalIncomeList[y].tranDate.substring(0,4);;
                if (ret.indexOf(item) === -1) {
                    ret.push(item)
                    totalIncomeList[y].isHeader =true;
                }else{
                    totalIncomeList[y].isHeader =false;
                }
            }

ReactNative做的app的顯示效果：

===========完美分割線=====================

贅述：JAVA中的陣列去重。

• 方式1

package com.panda;

import java.util.Arrays;

public class Test3 {

        public int removeDuplicates(int[] nums) {
            if (nums == null)
                return 0;
            if (nums.length == 1)
                return 1;
            int current = 0;
            int next = 1;
            int len = nums.length;
            while (next < len) {
                if (nums[next] == nums[current]) {
                    for (int j = next; j < len - 1; j++) {
                        nums[j] = nums[j + 1];
                    }
                    len--;
                }
                if (nums[next] != nums[current]) {
                    next++;
                    current++;
                }
            }

            return len;
        }
    public static void main(String[] args) {
        int [] rows ={3,5,3,5,1,2,7,2};
            int removeDuplicates = new Test3().removeDuplicates(rows);
            System.out.println(removeDuplicates);
    }
}

• 方式2

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Set;


public class TestList {

    public static void main(String[] args) {
        /**
         *List: 可以按順序存放你存入的資料,當你刪除第 N 個元素後, N 後邊的元素會逐個向前移
         *Set：是無序存放你存入的資料, 需要使用鍵值對
         *
         * 你可以通過使用下邊的方式 去除一個 List 內重複的資料
         */
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 1, 2, 3 );
        Set set = new HashSet<Integer>(list);    
        list = new ArrayList<Integer>(set);

        System.out.println(list);

    }

}

• 方式N …