本文参考：JavaSE-集合 - Zh1z3ven - 博客园 (cnblogs.com)

集合类提供一种存储空间可变的存储模型，存储数据的容量可以随时发生改变，比如ArrayList。

集合按照存储的结构可以分为两类，分别是单列集合java.util.Collection和双列集合java.util.Map，这里就先来讲讲collection集合。

Collection

1
2
3
4
5
6
7
public boolean add(E e)     // 把给定的对象添加到当前集合中 。
public void clear()         // 清空集合中所有的元素。
public boolean remove(E e)  // 把给定的对象在当前集合中删除。
public boolean contains(E e)// 判断当前集合中是否包含给定的对象。
public boolean isEmpty()    // 判断当前集合是否为空。
public int size()           // 返回集合中元素的个数。
public Object[] toArray()   // 把集合中的元素，存储到数组中。

Iterator迭代器

java给我们提供了Iterator接口，也就是迭代器，该接口也是集合的一种。也是集合专用的一种遍历方式。

1
Iterator<String> it = col.iterator();

集合的iterator()方法返回该集合元素的一个迭代器对象，之后就可以通过此对象的hashNext()和next()遍历这个集合。

next():返回迭代的下一个元素。

hasNext():如果仍有元素可以迭代，则返回 true，否则返回false。

List

List接口是Collection的子接口，
List接口里面允许出现重复元素得，在程序中可以通过索引来访问。
List接口存储的数据是有序的。

List的特有方法

1
2
3
4
add(int index, Element) // 在指定位置插入指定的元素
remove(int index)       // 删除指定位置处的元素，返回被删除的元素
set(int index, Element) // 修改指定位置处的元素，返回被修改的元素
get(int index)          // 返回指定位置处的元素

例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public static void main(String[] args) {
      List<String> list = new ArrayList<>();

      list.add("JavaSE");
      list.add("JS");
      list.add("Java");

      System.out.println(list);

      list.add(1,"java");
      System.out.println(list);

      list.remove(1);
      System.out.println(list);
    }

LinkedList

LinkedList集合特有方法

1
2
3
4
5
6
public void addFirst(E e)	在该列表开头插入指定的元素
public void addLast(E e)	将指定元素追加到此列表末尾
public E getFirst()	返回此列表第一个元素
public E getLast()	返回次列表末尾元素
public E removeFirst() 删除并返回此列表第一个元素
public E removeLast() 删除并返回此列表最后一个元素

Set

set接口也是继承了Collection接口，也是单列集合。
set接口中元素无序，并且都会以某种规则保证存入的元素不出现重复。

HashSet

无序，不保证元素的迭代顺序

不包含重复元素的集合

1
HashSet<String> hashSet = new HashSet<>();

LinkedHashSet

上面提到HashSet是无序的，如果想要有序，就需要用到LinkedHashSet

Collections类

conections是集合的工具类。

1
2
3
4
5
6
7
8
// 往集合中添加一些元素
public static <T> boolean addAll(Collection<T> c, T... elements)
// 打乱集合顺序
public static void shuffle(List<?> list) 
// 将集合中元素按照默认规则排序
public static <T> void sort(List<T> list)
// 将集合中元素按照指定规则排序。
public static <T> void sort(List<T> list,Comparator<? super T> )

Map

在Collection中，元素都是单个存在的。
而map中的集合，元素是成对存在的（类似于python中的字典）

每个元素都由键和值组成，通过键可以找到对应的值。

Map接口中的方法

Map接口中的集合都有两个泛型变量,在使用时，要为两个泛型变量赋予数据类型。

两个泛型变量的数据类型可以相同，也可以不同

1
2
3
4
5
6
7
8
9
10
// 把指定的键与指定的值添加到Map集合中
public V put(K key, V value)
// 把指定的键 所对应的键值对元素 在Map集合中删除，返回被删除元素的值
public V remove(Object key)
//  根据指定的键，在Map集合中获取对应的值
public V get(Object key)
// 获取Map集合中所有的键，存储到Set集合中
public Set<K> keySet()
// 获取到Map集合中所有的键值对对象的集合(Set集合)
public Set<Map.Entry<K,V>> entrySet()

HashMap

HashMap循环遍历value

map里面提供了一个获取所以键值的方法keyset。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class HashMapKeySetDemo {
    public static void main(String[] args) {

        HashMap<Integer, String> integerStringHashMap = new HashMap<>();

        integerStringHashMap.put(1,"xiao");
        integerStringHashMap.put(2,"a");
        integerStringHashMap.put(3,"gou");

        Set<Integer> integers = integerStringHashMap.keySet();
      
        for (int key : integers
             ) {
            String value = integerStringHashMap.get(key);
            System.out.println(value);
        }
    }
}

HashMap循环遍历Key,Value

1
Set<Map.Entry<String, String>> entries = map.entrySet();

Entry将键值对的对应关系封装成了对象。即键值对对象，这样我们在遍历Map集合时，就可以从每一个键值对（Entry）对象中获取对应的键与对应的值。

1
2
public K getKey()   // 获取Entry对象中的键
public V getValue() // 获取Entry对象中的值

HashMap遍历举例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class HashMapEntrySetDemo {
    public static void main(String[] args) {

        HashMap<Integer, String> integerStringHashMap = new HashMap<>();

        integerStringHashMap.put(1,"joker");
        integerStringHashMap.put(2,"jokerdig");
        integerStringHashMap.put(3,"jokerdig.com");

        Set<Map.Entry<Integer, String>> entries = integerStringHashMap.entrySet();

        for (Map.Entry<Integer, String> entry : entries) {

            int key = entry.getKey();
            String value = entry.getValue();
            System.out.println("Key:" + key + " " + "Value:" + value);
        }
    }
}

Hashmap的存放是无序的，如果需要有序存储数据的话，就需要用到LinkedHashMap。