java去重的方法（java高并发解决方案）

介绍了arraylist集合去重的三种方式，以及排序的两种方式，以及反射获取arraylist的容量，以及array和arraylist的区别。

---

1 array和arraylist的区别以及使用条件

array 和 arraylist都是存放数据的容器.array是代表的是数组，arraylist是一个集合，arraylist底层使用的封装了一个object数组。它的可变就是数组扩容。

区别:

1. array可以包含基本类型和对象类型，arraylist只能包含对象类型，jdk1.5之后传入基本类型会自动装箱。
2. array数组在存放的时候一定是同种类型的元素。arraylist就不一定了，因为arraylist可以存储object。
3. array大小是固定的，arraylist的大小是动态变化的。
4. arraylist作为array的增强版，当然是在方法上比array更多样化，比如添加全部addall()、删除全部removeall()、返回迭代器iterator()等。

使用条件：

1. 当存放的内容数量不固定，不确定，有限时采用arraylist。
2. 如果想要保存一些在整个程序运行期间都会存在而且不变的数据，可以放在数组里。
3. 如果我们需要对元素进行频繁的移动或删除，或者是处理的是超大量的数据，那么，使用arraylist的效率很低，使用数组进行这样的容量调整动作很麻烦，我们可以选择linkedlist。

2 list去重

2.1 借助辅助集合

借助辅助集合

arraylist<string> al = new arraylist<string>();
al.add("aa");
al.add("bb");
al.add("aa");
al.add("dd");
al.add("dd");
al.add("dd");
al.add(null);
al.add("ee");
al.add("ee");
//去重思路一  借助辅助集合
arraylist<string> al2 = new arraylist<string>();
for (string s : al) {
    if (!al2.contains(s))
    {
        al2.add(s);
    }
}
al.clear();
al.addall(al2);
system.out.println(al);   //[aa, bb, dd, null, ee]

2.2 利用迭代器

直接利用列表迭代器，无需借助辅助集合（打乱顺序）

listiterator<string> sli = al.listiterator();
while (sli.hasnext()) {
    string next =  sli.next();   //获得下一个元素
    sli.remove();   //移除获得的元素
    if (!al.contains(next))  //判断源集合是否包含被移除的元素
    {
        sli.add(next);  //没包含就再添加进来
    }
}
system.out.println(al);

注意： contains(obj); remove(object obj);

以上两个方法底层是依据equals方法：根据equals方法返回的值，判断是否移除/或者是判断是否存在。因此对对象去重时，需要重写equals方法，使得equals比较的是具体值而不是地址。

2.3 利用java8的lambda

使用java8的lambda表达式轻松实现集合去重

al = al.stream().collect(collectors.collectingandthen(collectors.tocollection(hashset::new), arraylist::new));
system.out.println(al);

3 list排序

clooections的sort方法快速实现排序：

public static <t extends comparable<? super t>> void sort(list list) –自然排序 public static void sort(list list,comparator<? super t> c) –自定义排序

4 反射获取arraylist的容量

明显我们无法直接通过可用方法获取arraylist的容量，因此只有使用反射获取：

// 获取list容量
public static integer getcapacity(arraylist list) {
    integer length = null;
    class clazz = list.getclass();
    field field;
    try {
        field = clazz.getdeclaredfield("elementdata");
        field.setaccessible(true);
        object[] object = (object[]) field.get(list);
        length = object.length;
        return length;
    } catch (exception e) {
        // todo auto-generated catch block
        e.printstacktrace();
    }
    return length;
}

5 迭代器和for循环速度测试

public class arraylisttest {
    static list<integer> list = new arraylist<integer>();

    static {
        for (int i = 1; i <= 100000000; i++) {
            list.add(i);
        }
    }
​
    public static long arrayfor() {
        //开始时间
        long starttime = system.currenttimemillis();
        for (int j = 0; j < list.size(); j++) {
            object num = list.get(j);
        }
        //结束时间
        long endtime = system.currenttimemillis();
        //返回所用时间
        return endtime - starttime;
    }
​
    public static long arrayiterator() {
        long starttime = system.currenttimemillis();
        iterator iterator = list.iterator();
        while (iterator.hasnext()) {
            object next = iterator.next();
        }
        long endtime = system.currenttimemillis();
        return endtime - starttime;
    }
​
    public static void main(string[] args) {
        long time1 = arrayfor();
        long time2 = arrayiterator();
​
        system.out.println("arraylist for循环所用时间==" + time1);
        system.out.println("arraylist 迭代器所用时间==" + time2);
    }
}