你的位置:首页 > Java教程

[Java教程]java常用集合小结


List

public interface List<E>extends Collection<E>
有序的 collection(也称为序列),允许重复的元素。
常用实现类:

  • ArrayList:
    底层使用的是数组结构,特点:查询速度快,增删操作较慢,而且线程不同步.
    要保证同步,可以使用:List list = Collections.synchronizedList(new ArrayList());进行包装,默认容量为10.
    常用方法:add,addAll,remove,indexOf,subList,contains,isEmpty

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    List<String> list = new ArrayList<String>();
    list.add("0");
    list.add("1");
    list.add("2");
    list.add("3");
    list.add("4");
    for (int i = 0; i < list.size(); i++) {
    list.remove(i);
    }
    System.out.println(list); //1,3

    容易忽略的方法:trimToSize()//修正容量大小,用多少,给多少,ensureCapacity(int minCapacity)//预设大小
    自定义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
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    /**
    * 简单模拟ArrayList
    * @author admol
    */
    public class MyArrayList {
    private Object[] data;
    private int size;

    public MyArrayList() {
    this(10);
    }

    public MyArrayList(int i) {
    data = new Object[i];
    }

    /**
    * 返回拥有的元素数
    * @return
    */
    public int size() {
    return size;
    }

    /**
    * 获取指定位置上的元素
    * @param i
    * @return
    */
    public Object get(int i) {
    return data[i];
    }

    /**
    * 添加元素
    * @param obj
    */
    public void add(Object obj) {
    //存储空间已满,需要扩容
    if (data.length == size) {
    Object[] temp = new Object[size + (size >> 1)];
    //数组复制:(被复制的数组,从第几个元素开始复制,复制到的目标数组,粘贴的开始位置,需要复制元素个数)
    System.arraycopy(data, 0, temp, 0, size);
    data = temp;
    }
    //存储空间未满
    data[size++] = obj;
    }

    /**
    * 删除指定位置的元素
    * @param i
    */
    public void remove(int i) {
    //例:共10个元素,要删除的元素下标为3,实际上是从下标4开始向下标3复制粘贴(10-3-1)元素
    System.arraycopy(data, i + 1, data, i, size - i - 1);
    size--;
    }

    /**
    * 删除指定元素
    * @param obj
    */
    public void remove(Object obj) {
    for (int i = 0; i < size; i++) {
    if (data[i].equals(obj)) {
    remove(i);
    return;
    }
    }
    }
    }
  • LinkedList
    使用双向链表实现存储,允许所有元素(包括 null)。非线程安全,要保证同步,可以使用List list = Collections.synchronizedList(new LinkedList());进行包装,可以被当作堆栈和队列来使用。

  • Vector
    也是一个有序集合,允许重复元素,并且线程安全.

Map

  • HashMap
    基于哈希表的 Map 接口的实现,存储键值对,键是唯一的,允许使用 null 值和 null 键,非同步(除了非同步和允许使用 null 之外,HashMap 类与 Hashtable 大致相同),同步可以使用Map m = Collections.synchronizedMap(new HashMap(...));
    常用方法:
    1. 添加。 put(key,value):当存储的键相同时,新的值会替换老的值,并将老值返回。如果键没有重复,返回null。 void putAll(Map);
    2. 删除。 void clear():清空 value remove(key) :删除指定键。
    3. 判断。 boolean isEmpty(): boolean containsKey(key):是否包含key boolean containsValue(value) :是否包含value
    4. 取出。 int size():返回长度 value get(key) :通过指定键获取对应的值。如果返回null,可以判断该键不存在。 当然有特殊情况,就是在hashmap集合中,是可以存储null键null值的。
      Collection values():获取map集合中的所有的值。
  • HashTable
    底层是哈希表数据结构,不可以存入null键null值,是线程同步的.
    Hashtable 的实例有两个参数影响其性能:初始容量 和加载因子(默认.75)

Set

  • HashSet
    底层数据结构是哈希表(实际上是一个 HashMap 实例),允许使用 null 元素,唯一且无序,非线程安全.通过元素的hashcode和equals来保证元素的唯一性。如果元素的hashcode值相同,才会判断equals是否为true; 如果元素的hashcode的值不同,不会调用equals。

Collections

提供对集合进行操作的一个包装器,实现对集合的查找、排序、替换、 线程安全化(将非同步的集合转换成同步的)等操作。常用方法:
Collections.max(list);//返回list中字典顺序最大的元素。
int index = Collections.binarySearch(list,”zz”);//二分查找,返回角标。必须是有序的
Collections.fill();//可以将list集合中的所有元素替换成指定元素。
Collections.repalceAll(list,”要被替换的”,”替换的值”);//可以将list集合中的指定元素替换成指定元素。 Collections.reverse(); 反转
Collections.reverseOrder(参数是比较器);//逆向反转排序。倒序。。
Collections.shuffle(list);//随机对list中的元素进行位置的置换。
synchronizedXXX(XXX);非同步集合转成同步集合的方法:

Arrays

用于操作数组对象的工具类,里面都是静态方法。
Arrays.asList:可以从 Array 转换成 List。可以作为其他集合类型构造器的参数。
Arrays.binarySearch:在一个已排序的或者其中一段中快速查找。
Arrays.copyOf:如果你想扩大数组容量又不想改变它的内容的时候可以使用这个方法。
Arrays.copyOfRange:可以复制整个数组或其中的一部分。
Arrays.deepEquals、Arrays.deepHashCode:Arrays.equals/hashCode的高级版本,支持子数组的操作。
Arrays.equals:如果你想要比较两个数组是否相等,应该调用这个方法而不是数组对象中的 equals方法(数组对象中没有重写equals()方法,所以这个方法之比较引用而不比较内容)。
Arrays.fill:用一个给定的值填充整个数组或其中的一部分。
Arrays.hashCode:用来根据数组的内容计算其哈希值(数组对象的hashCode()不可用)。
Arrays.sort:对整个数组或者数组的一部分进行排序。也可以使用此方法用给定的比较器对对象数组进行排序。
Arrays.toString:打印数组的内容。

关系图

a