本文介绍了ArrayList类、LinkedList类、HashSet类、TreeSet类、HashMap类、Collection工具类常用的成员方法。

ArrayList类：

  1. 集合是一种存储空间可变的存储模型，存储的数据容量可以发生改变。
  2. ArrayList集合的底层是数组实现的。
  3. ArrayList的长度可以变化。

常用方法：

方法名 说明
public boolean remove(Object o) 删除指定的元素，返回删除是否成功
public E remove(int index) 删除指定索引处的元素，返回被删除的元素
public E set(int index,E element) 修改指定索引处的元素，返回被修改的元素
public E get(int index) 返回指定索引处的元素
public int size() 返回集合中的元素的个数
public boolean add(E e) 将指定的元素追加到此集合的末尾
public void add(int index,E element) 在此集合中的指定位置插入指定的元素

代码演示：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;

public class ArrayListDemo {
    public static void main(String[] args) {
        // List<String> list = new ArrayList<>(); 泛型
        // ArrayList arrayList1 = new ArrayList<>(); 可以添加不同类型元素
        ArrayList<String> arrayList = new ArrayList<>();
        arrayList.add("Tom");
        arrayList.add("Lucy");
        arrayList.add("Jack");
        arrayList.add("Mike");
        arrayList.add("aabyte");
        System.out.println(arrayList); // [Tom, Lucy, Jack, Mike, aabyte]
        // public boolean remove(Object o)：删除指定的元素，返回删除是否成功
        System.out.println(arrayList.remove("Lucy")); // true
        System.out.println(arrayList); // [Tom, Jack, Mike, aabyte]
        // public E remove(int index)：删除指定索引处的元素，返回被删除的元素
        System.out.println(arrayList.remove(2)); // Mike
        System.out.println(arrayList); // [Tom, Jack, aabyte]
        // public E set(int index,E element)：修改指定索引处的元素，返回被修改的元素
        System.out.println(arrayList.set(2,"AaByte")); // aabyte
        System.out.println(arrayList); // [Tom, Jack, AaByte]
        // public E get(int index)：返回指定索引处的元素
        System.out.println(arrayList.get(1)); // Jack
        // 排序
        Collections.sort(arrayList); //自然排序规则 从小到大排序
        arrayList.forEach(System.out::println);
        // 自定义排序规则
        Collections.sort(arrayList, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o1.compareTo(o2);
            }
        });
        //简写为lambda表达式
        Collections.sort(arrayList, String::compareTo);
        // 遍历集合的3种方式
        // 1.普通遍历
        for(int i = 0; i < arrayList.size(); ++i){
            System.out.println(arrayList.get(i));
        }
        // 2.增强for遍历
        for(String s : arrayList){
            System.out.println(s);
        }
        // 3.迭代器遍历
        Iterator<String> iterator = arrayList.iterator();
        while(iterator.hasNext()){
            String str = iterator.next();
            System.out.println(str);
            iterator.remove(); // 遍历的同时删除
        }
    }
}

Vector和ArrayList的成员方法类似，不同之处在于：Vector线程安全、ArrayList非线程安全，但ArrayList性能更佳，所以单线程情况下推荐使用ArrayList。


LinkedList类：

LinkedList底层由双向链表实现，增删效率比ArrayList高，改查效率不及ArrayList。

代码演示：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
import java.util.Iterator;
import java.util.LinkedList;

public class LinkedListDemo {
    public static void main(String[] args) {
        LinkedList<String> linkedList = new LinkedList<>();
        linkedList.add("Tom");
        linkedList.add("Lucy");
        linkedList.add("Mike");
        linkedList.add("Jane");
        linkedList.add("aabyte");

        System.out.println(linkedList);
        //默认删除第一个
        System.out.println(linkedList.remove());
        System.out.println(linkedList);
        //删除指定元素
        System.out.println(linkedList.remove("aabyte")); // true
        System.out.println(linkedList);
        //修改
        linkedList.set(1,"Java");
        System.out.println(linkedList);
        //查询
        System.out.println(linkedList.get(1));
        //遍历 增强for
        for (String s : linkedList) {
            System.out.println(s);
        }
        //遍历 迭代器
        Iterator<String> iterator= linkedList.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }
}

HashSet类：

代码演示：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
import java.util.HashSet;
import java.util.Iterator;

public class SetDemo {
    public static void main(String[] args) {
        //Set<String> set = new HashSet<>();
        HashSet<String> hashSet = new HashSet<>();
        hashSet.add("Tom");
        hashSet.add("Lucy");
        hashSet.add("Jane");
        hashSet.add("Mike");
        hashSet.add("Tom");
        System.out.println(hashSet); // [Tom, Lucy, Jane] 不能存放重复元素
        hashSet.remove("Jane");
        //增强for遍历
        for(String s : hashSet){
            System.out.println(s);
        }
        //迭代器遍历
        Iterator<String> iterator = hashSet.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }
        HashSet<String> hashSet1 = new HashSet<>();
        hashSet1.add("Tom");
        hashSet1.add("Lucy");
        hashSet1.add("Java");
        hashSet1.add("Python");

        hashSet.addAll(hashSet1); //并集
        System.out.println(hashSet);
        hashSet.removeAll(hashSet1); //差集
        System.out.println(hashSet);
        HashSet<String> hashSet2 = new HashSet<>();
        hashSet2.add("Tom");
        hashSet2.add("Mike");
        hashSet2.retainAll(hashSet); //交集
        System.out.println(hashSet2);
    }
}

TreeSet类：

其构造器可以传入比较器，所以TreeSet常用来排序。

代码演示：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
import java.util.Comparator;
import java.util.TreeSet;

public class TreeSetDemo {
    public static void main(String[] args) {
        TreeSet<String> treeSet = new TreeSet<>();
        treeSet.add("Tom");
        treeSet.add("Lucy");
        treeSet.add("Jack");
        treeSet.add("aabyte");
        treeSet.add("Jane");
        System.out.println(treeSet); //默认排序 字典序 [Jack, Jane, Lucy, Tom, aabyte]

        //降序
        treeSet = new TreeSet<>(new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o2.compareTo(o1);
            }
        });
        // treeSet = new TreeSet<>(Comparator.reverseOrder()); lambda等价写法
        treeSet.add("Tom");
        treeSet.add("Lucy");
        treeSet.add("Jack");
        treeSet.add("aabyte");
        treeSet.add("Jane");
        System.out.println(treeSet); // [aabyte, Tom, Lucy, Jane, Jack]
    }
}

HashMap类：

双列集合，以键值对的形式存储，key不可重复，value可重复。

代码演示：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Map;

public class CollentionDemo3 {
    public static void main(String[] args) {
        //以键值对的形式存储 key value  key不可重复
        HashMap<String, String> hashMap = new HashMap<>(); //非线程安全
        Hashtable<String, Integer> hashtable= new Hashtable<>(); //线程安全
        Map<Integer,Student> studentMap = new HashMap<>();
        studentMap.put(1, new Student("Jack","2011050721"));
        studentMap.put(2, new Student("Tom","2011050722"));
        studentMap.put(3, new Student("Jerry","2011050723"));
        studentMap.put(4, new Student("Lucy","2011050724"));
        System.out.println(studentMap.size());
        for(Integer key: studentMap.keySet()){
            Student s = studentMap.get(key);
            System.out.println(s.getName());
        }
        //遍历
        for(Map.Entry<Integer,Student> entry:studentMap.entrySet()){
            Integer i = entry.getKey(); //获取key
            Student s = entry.getValue(); //获取value
        }
        System.out.println(studentMap.get(0));
        int k = 1;
        if(!studentMap.containsKey(1)){
            studentMap.put(k, new Student());
        }
        studentMap.remove(1); //按key删除元素
    }
}

Student类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
public class Student {
    String name;
    String id;
    public Student() {
    }
    public Student(String name, String id) {
        this.name = name;
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", id='" + id + '\'' +
                '}';
    }
}

Collections工具类：

  1. Collections 是一个操作 Set、List 和 Map 等集合的工具类。
  2. Collections 中提供了一系列静态方法对集合元素进行排序、查询和修改操作。

排序：

均为static方法。

  1. reverse （List）：反转 List 中元素的排序；
  2. shuffle （List） ： 对 List 集合元素进行随机排序；
  3. sort （List） ： 根据元素的自然顺序对指定的 List 集合元素按升序排序；
  4. sort （List，Comparator） ：根据指定的 Comparator 产生的顺序对 List 集合元素进行排序；
  5. swap （List ，int，int） ：将指定 List 集合中的 i 处元素 和 j 处元素进行交换；

查找、替换：

  1. Object max ( Collection ) ：根据元素的自然顺序，返回给定集合中的最大元素。
  2. Object max ( Collection , Comparator ) ：根据 Comparator 指定的顺序，返回给定集合中的最大元素。
  3. Object min ( Collection ) ：根据元素的自然顺序，返回给定集合中的最小元素。
  4. Object min ( Collection , Comparator ) ：根据 Comparator 指定的顺序，返回给定集合中的最小元素。
  5. int frequency ( Collection , Object ) ： 返回指定集合中指定元素的出现次数。
  6. void copy ( List dest , List src ) ： 将 src 中的内容复制到 dest 中。
  7. boolean replaceAll ( List list , Object oldVal , Object newVal ) ： 使用新值替换List对象的所有旧值。