ArrayList的去重、排序以及其他应用

た入场券 2022-08-31 06:58 130阅读 0赞

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

### 文章目录 ###

*  1 Array和ArrayList的区别以及使用条件
 *  2 List去重
 *   *  2.1 借助辅助集合
     *  2.2 利用迭代器
     *  2.3 利用java8的lambda
 *  3 List排序
 *  4 反射获取ArrayList的容量
 *  5 迭代器和for循环速度测试

# 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循环速度测试 #

一般来说，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);
        }
    }

> 如果有什么不懂或者需要交流，可以留言。另外希望点赞、收藏、关注，我将不间断更新各种Java学习博客！