Java容器_Collection基本使用(1)

Collection
Collection

List

ArrayList

add、remove、get、set、clear、contains、size、isEmpty 方法

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
public class Test {
  public static void main(String[] args) {
    ArrayList<Integer> list = new ArrayList<>();
    list.add(123); //自动装箱
    list.add(456);
    //父类已经重写了toString方法
    System.out.println(list); //[123, 456]
    list.remove(0);
    System.out.println(list); //[456]
    list.set(0, 123);
    System.out.println(list.get(0)); //123
    System.out.println(list.contains(123)); //true
    System.out.println(list.size()); //1
    list.clear();
    System.out.println(list); //[]
    System.out.println(list.isEmpty()); //true
  }
}

addAll、removeAll 方法

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
public class Test {
  public static void main(String[] args) {
    ArrayList<String> list1 = new ArrayList<>();
    list1.add("a");
    ArrayList<String> list2 = new ArrayList<>();
    list2.add("b");
    //for (int i = 0; i < list2.size(); i++) {
    //    list1.add(list2.get(i));
    //}
    list1.addAll(list2);
    System.out.println(list1); //[a, b]
    list2.add("c");
    System.out.println(list2); //[b, c]
    list2.removeAll(list1);
    System.out.println(list2); //[c]
  }
}

containsAll、retainAll 方法

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
public class Test {
  public static void main(String[] args) {
    ArrayList<String> list1 = new ArrayList<>();
    list1.add("a");
    list1.add("b");
    ArrayList<String> list2 = new ArrayList<>();
    list2.add("a");
    list2.add("c");
    //containsAll判断交集
    System.out.println(list1.containsAll(list2)); //false
    //retainAll取交集,调用的集合改变了返回true,不变返回false
    System.out.println(list1.retainAll(list2)); //true
    System.out.println(list1); //[a]
  }
}

LinkedList

addFirst、addLast、get、getFirst、getLast、removeFirst、removeLast 方法

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
public class Test {
  public static void main(String[] args) {
    LinkedList<String> list = new LinkedList<>();
    list.addFirst("a");
    list.addFirst("b"); 
    list.addLast("c");  
    System.out.println(list); //[b, a, c]
    System.out.println(list.get(1)); //a
    System.out.println(list.getFirst()); //b
    System.out.println(list.getLast()); //c
    list.removeFirst();
    System.out.println(list); //[a, c]
    list.removeLast();
    System.out.println(list); //[a]
  }
}

Set

Set 内部使用 Map 实现,Map的 Key 作为 Set,value 为假值,与 List 主要功能区别是元素不重复

HashSet

内部是 HashMap,会丢失元素插入的顺序

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
public class Test {
  public static void main(String[] args) {
    HashSet<String> set = new HashSet<>();
    set.add("c");
    set.add("b");
    set.add("a");
    //丢失元素插入的顺序,但底层会根据hash值排序
    System.out.println(set); //[a, b ,c]
    //元素不重复
    System.out.println(set.add("a")); //false
  }
}

Set 在进行 add 方法添加元素之前,会先调用元素的 hashCode 方法得到哈希值,然后在容器中查找是否有相同哈希值的元素,如果没有则直接存入,如果有则再调用 equals 方法进行比较,结果为 false 才会存入,所以对于自定义的类,需要重写 hashCode 和 equals 方法来设置判重逻辑

 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
public class Test {
  public static void main(String[] args) {
    HashSet<Student> hs = new HashSet<>();
    hs.add(new Student("张三"));
    hs.add(new Student("张三"));
    hs.add(new Student("李四"));
    System.out.println(hs); //[李四, 张三]
  }
}
class Student {
  String name;
  public Student(String name) {
    this.name = name;
  }
  @Override
  public String toString() {
    return this.name;
  }
  @Override
  public int hashCode() {
    //重写hashCode,定义的规则是name相同的对象返回相同的hashCode
    //因为String重写了hashCode方法,字符串值相同hashCode就相同
    //所以可以直接返回name的hashCode值
    return name.hashCode();
  }
  @Override
  public boolean equals(Object o) {
    if (this == o) return true;
    if (o == null || getClass() != o.getClass()) return false;
    //重写equals方法,定义的规则是name相同则返回true
    Student stu = (Student)o;
    //String类已经重写的equals方法,用于比较两个字符串是否为相同
    //所以可以直接返回name的equals方法返回的值
    return name.equals(stu.name);
  }
}

LinkedHashSet

内部是 LinkedHashMap,通过双向链表保存元素的插入顺序

1
2
3
4
5
6
7
8
9
public class Test {
  public static void main(String[] args) {
    LinkedHashSet<String> set = new LinkedHashSet<>();
    set.add("c");
    set.add("a");
    set.add("b");
    System.out.println(set); //[c, a, b] 保存了元素插入的顺序
  }
}

TreeSet

基于红黑树,内部是 TreeMap 的 SortedSet

查找元素,HashSet 的时间复杂度为 O(1),而 TreeSet 为 O(logN)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
public class Test {
  public static void main(String[] args) {
    TreeSet<String> set = new TreeSet<>();
    set.add("c");
    set.add("b");
    set.add("a");
    //默认按照字典顺序排序
    System.out.println(set); //[a, b, c]
  }
}

Queue

LinkedList

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
public class Test {
  public static void main(String[] args) {
    LinkedList<String> list = new LinkedList<>();
    list.addLast("a"); //模拟进栈
    list.addLast("b");
    while(!list.isEmpty()) {
      System.out.print(list.removeLast()); //ba
    }
    list.addLast("a"); //模拟进队列
    list.addLast("b");
    while(!list.isEmpty()) {
      System.out.print(list.removeFirst()); //ab
    }
  }
}

可将 LinkedList 向上转型为 Queue,使用 Queue 提供的方法

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
public class Test {
  public static void main(String[] args){
    Queue<String> queue = new LinkedList<>();
    //成功返回true,失败时抛出异常
    //添加元素
    queue.add("a"); //在队尾添加
    queue.add("b");
    queue.add("c");
    //返回第一个元素并在队列中删除
    System.out.println(queue.remove()); //a
    //返回第一个元素不在队列中删除
    System.out.println(queue.element()); //b
    for(String q : queue){
      System.out.println(q); //b c
    }
    System.out.println(queue.size()); //2
  }
}
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
public class Test {
  public static void main(String[] args){
    Queue<String> queue = new LinkedList<>();
    //成功返回true,失败时返回NULL或false,
    //offer()用于往容量受限的队列添加元素
    queue.offer("a"); //在队尾添加,如果队列满了则返回fasle
    queue.offer("b");
    queue.offer("c");
    //返回第一个元素并在队列中删除,如果队列为空则返回null
    System.out.println(queue.poll()); //a
    //返回第一个元素不在队列中删除,如果队列为空则返回null
    System.out.println(queue.peek()); //b
    for(String q : queue){
      System.out.println(q); //b c
    }
  }
}

PriorityQueue

基于平衡二叉小顶堆,通过数组实现,保存的元素必须是可比较的对象,保证每次取出的元素都是队列中权值最小的

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
public class Test {
  public static void main(String[] args) {
    PriorityQueue<String> queue = new PriorityQueue<>();
    queue.add("bb");
    queue.add("c");
    queue.add("b");
    queue.add("c");
    queue.add("aa");
    System.out.println(queue); //[aa, b, bb, c, c]
    System.out.println(queue.poll()); //aa
    System.out.println(queue.poll()); //b
    System.out.println(queue.poll()); //bb
    System.out.println(queue.poll()); //c
    System.out.println(queue.poll()); //c
    for (String s : queue) {
      System.out.println(s); //aa b bb c c
    }
  }
}

以上内容是玉山整理的笔记,如有错误还请指出