By zhpooer

更新日期:

文章目录
  1. 1. 集合初识
    1. 1.1. Iterator
    2. 1.2. Collection 的继承结构图
  2. 2. List 和 Set
    1. 2.1. java.util.List
      1. 2.1.1. Vector
      2. 2.1.2. ArrayList
      3. 2.1.3. LinkedList
    2. 2.2. Set
      1. 2.2.1. HashSet
        1. 2.2.1.1. LinkedHashSet
      2. 2.2.2. TreeSet
  3. 3. Map
    1. 3.1. Hashtable
    2. 3.2. HashMap
    3. 3.3. TreeMap
    4. 3.4. LinkedHashMap
  4. 4. 集合框架工具
    1. 4.1. Collections
    2. 4.2. Arrays
  5. 5. 静态导入

集合初识

集合类的由来:

对象用于封装特有的数据, 对象多了需要存储, 如果对象不确定. 存储就使用集合容器进行

集合特点:

  1. 用于存储对象的容器
  2. 集合长度是可变的
  3. 集合不可存储基本数据类型

集合体系的共同父类 java.util.Collection

1
2
3
4
5
6
7
8
9
10

boolean add(E e);
boolean contains(Object o);
void clear()
boolean containsAll(Collection<?> c);
boolean remove(Object o);
boolean removeAll(Collection<?> c);
int size();
Iterator<E> iterator(); // 迭代器
boolean retainAll(Collection coll); // 取交集
Object[] toArray(); // 集合转数组

Iterator

Iterator 对象必须依赖于具体容器, 因为每一个容器的数据结构都不同. 所以该迭代器对象在容器中进行内部实现的. Iterator用法

1
2
3

for(iterator it = coll.iterator(); it.hasNext();){
    it.next();
}

Collection 的继承结构图

Collection 的继承结构图

List 和 Set

List 和 Set 都从 Collection 继承

List: 有序,元素有索引, 元素可以重复

Set: 元素不能重复, 无序

java.util.List

1
2
3
4
5
6
7
8
9
10

void add(index, element);
void add(index, collection);

Object remove(index);
Object set(index, element);

Object get(index);
int indexOf(object);
int lastIndexOf(object);
List subList(from, to);

Iterator 接口在迭代过程中不能执行添加操作, 可以使用Iterator的子接口ListIterator进行操作.

1
2
3
4

ListIterator it = list.listIterator();
it.add("xx");
it.previous();
it.hasPrevious();//允许逆向便利

Vector

内部是是数组数据结构, 是线程安全的, 长度可变, 增删查询都慢

ArrayList

内部是是数组数据结构, 是线程不同步的, 长度可变, 查询速度快

LinkedList

内部是链表, 是不同步的, 增删元素的速度快

Set

Set接口中的方法和 Collection 接口的方法一致

HashSet

内部数据结构是哈希表, 是不同步的

使用元素的hashCode方法来确定位置, 如果位置相同, 在通过元素的equals来确定是否相同. 所以在使用一个新类时要重写类的方法 hashCode() 和 equals()

LinkedHashSet

有序的HashSet

TreeSet

可以对Set集合中的元素进行排序(从小到大), 是不同步的. 存储在里面的元素必须实现 java.lang.Comparable 接口, 他根本不看哈希码, 他判断元素的唯一性, 是看比较结果

1
2
3
4
5
6
7
8

import java.util.Comparator;
public class ComparatorByName implements Comparator {
   @Override public int compare(Object obj1, Object obj2){
       return 0;
   }
}

ThreeSet ts = new TreeSet(new ComparatorByName());

Map

Map: 一次添加一对元素. Collection 一次添加一个元素. Map集合中存储的是键值对, 必须保证键的唯一性.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

void clear();

V put(K key, V value); //返回前一个和key关联的值, 如果没为null
V remove(K key); // 删除键值对, 返回值

boolean containsKey(key);
boolean containsValue(value);
boolean isEmpty();

value get(key); // 如果没有则返回null
int size();

Set keySet();
Set<Map.Entry> entrySet();
Collection<V> values();

Hashtable

内部结构是哈希表, 是同步的, 不支持空键和空值.

Properties: 用来存储键值对型的配置文件信息, 可以和IO技术结合

HashMap

内部结构是哈希表, 不是同步的. 允许空值和空键.

TreeMap

内部是二叉树, 不是同步的. 可以对Map中的键进行排序.

LinkedHashMap

有序的存储Map中的键

集合框架工具

Collections

是集合框架的工具类, 里面的方法都是静态的.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

Collections.sort(list, comparator); //对list集合进行指定顺序的排序
Collections.sort(list); //对list集合进行指定顺序的排序
Collections.swap(list); //对list位置进行交换

Collections.binarySearch(list, comparator); // 二分法查找, 必须先排序
Collections.max(set);
Collections.min(set);

Collections.reverseOrder(); // 对排序进行逆转
new TreeSet<Sring>(Collections.reverseOrder());

Collections.replaceAll(list, old, new);
Collections.reverse(list);
Collections.fill(list, obj); // 替换成所有同一个元素

Collections.shuffle(list, obj); // 乱序排序

Collections.list(enumeration); // 转成Arraylist

Collections.synchronizedCollection(Collection|Set|Map); //返回一个同步的集合

Arrays

1
2
3
4
5
6
7
8
9
10
11
12
13
14

binarySearch();
copyOf();
copyOfRange();
fill();
equals(); // 比较两个数组
sort();
deepEquals();
toString(array);
/** 如果数组中的元素是对象, 那么转成集合时, 直接将数组中的元素作为集合中的元素进行集合存储
** 如果数组中的元素是基本类型, 那么会将该数组作为集合中的元素进行存储
**/
asList(array); // 将一个数组转换成固定长度的List
int [] a = {1,3,4}
List<int[]> x = Arrays.asList(a)

集合变数组

1
2
3
4
5
6
7

// 集合变成数组, 不能进行增删
List<String> list = new ArrayList<String>()
list.add("1")
list.add("2")
list.add("3")

String[] arr = list.toArray(new String[4]) // [1,2,3,null]

静态导入

1
2
3
4
5

import static java.util.Collections.*; // 导入类中的静态成员

impport static java.lang.System.*;

out.println("hello world");
文章目录
  1. 1. 集合初识
    1. 1.1. Iterator
    2. 1.2. Collection 的继承结构图
  2. 2. List 和 Set
    1. 2.1. java.util.List
      1. 2.1.1. Vector
      2. 2.1.2. ArrayList
      3. 2.1.3. LinkedList
    2. 2.2. Set
      1. 2.2.1. HashSet
        1. 2.2.1.1. LinkedHashSet
      2. 2.2.2. TreeSet
  3. 3. Map
    1. 3.1. Hashtable
    2. 3.2. HashMap
    3. 3.3. TreeMap
    4. 3.4. LinkedHashMap
  4. 4. 集合框架工具
    1. 4.1. Collections
    2. 4.2. Arrays
  5. 5. 静态导入