java 集合总结

1.综述

在java 1.2 之前，java中提供了四种类型的“集合类”：Vector（矢量），BitSet(位集)，Stack(堆栈)以及HashTable（散列表）。

     在java 1.2时，推出新的集合，即现在我们常用的一些集合。包括Collections，Lists,Sets,Maps。下面是其关系脑图。

                                                                          图 1

首先看到源码中public interface Collection<E> extends Iterable<E> {}；所以简单的介绍一下Iterable，

         public interface Iterable<T> {

                   Iterator<T> iterator(); // 返回一个T类型元素的迭代器

                   /**

对可迭代的每个元素执行给定的操作(action)，直到所有元素都被处理或操作抛出异常为止。除非实现类另有规定，否则操作将按照迭代顺序执行(如果指定了迭代顺序)。由动作抛出的异常被转发给调用者，accept（）属于Consumer接口中的函数。
                     */

                  default void forEach(Consumer<? super T> action) {
                                    Objects.requireNonNull(action);
                                         for (T t : this) {
                                               action.accept(t);
                                          }
                     }

      //  since 1.8  在这个可迭代的元素上创建一个Spliterator，关于Spliterator可查看博客https://blog.csdn.net/lh513828570/article/details/56673804

       default Spliterator<T> spliterator() {
              return Spliterators.spliteratorUnknownSize(iterator(), 0);
       }

} 可以简单的认为：extends Iterator就是使collections拥有迭代器功能（Iterator<E> iterator();）。

2. 详解collection接口

      collection本身拥有众多方法，包括：

                                                                                      图 2

retainAll(Collection<?> c)功能是保留执行retainAll的原始集合中重叠部分，改变了原集合的数据。

      collection中主要有List和Set两个集合下面将详细介绍：

       List集合：部分函数及描述

   list主要有2个子类：list 有序，而且元素可以重复。

     Arraylist:底层实现是数组结构，数组长度可变，特点 查询效率高，增删较慢，而且线程不同步

     LinkedList：底层实现是链表结构，特点查询效率低，增删较快。

   set主要有2个类和1个接口。set 存储无序（存入和取出的顺序不一定相同），值不能重复。

      HashSet:HashSet存储元素的顺序并不是按照存入时的顺序是按照hash值存储，取也是按照hash值取，所以hashset存取速度快，set通过hashcode()和equals方法进行判断元素是否重复，只能去重，不能排序。

      TreeSet:只能存放引用类型，不能用于基本数据类型，去重并排序。TreeSet支持两种排序方法：自然排序和定制排序，默认采用自然排序。TreeSet是非同步的，线程不安全。

      自然排序：TreeSet调用compare To比较元素之间的大小关系，然后按照升序排序。下面是源码部分

public class TreeSet<E> extends AbstractSet<E>
implements NavigableSet<E>, Cloneable, java.io.Serializable {
//存放元素的map对象
private transient NavigableMap<E,Object> m;
//key-value ,不同的键都会对象相同的value, value = PRESENT
private static final Object PRESENT = new Object();
//指定的map对象
TreeSet(NavigableMap<E,Object> m) {
this.m = m;
}
//无参构造方法，初始化一个TreeMap对象
public TreeSet() {
this(new TreeMap<E,Object>());
}
//构造方法，指定比较器
public TreeSet(Comparator<? super E> comparator) {
this(new TreeMap<>(comparator));
}
//将集合中的元素转化为TreeSet存储
public TreeSet(Collection<? extends E> c) {
this();
addAll(c);
}
//构造方法，SortedSet转化为TreeSet存储，并使用SortedSet的比较器
public TreeSet(SortedSet<E> s) {
this(s.comparator());
addAll(s);
}
//遍历方法，返回m.keyset集合
public Iterator<E> iterator() {
return m.navigableKeySet().iterator();
}
//逆序排序的迭代器
public Iterator<E> descendingIterator() {
return m.descendingKeySet().iterator();
}
/**
* @since 1.6
*/
public NavigableSet<E> descendingSet() {
return new TreeSet<>(m.descendingMap());
}
//返回 m 包含的键值对的数量
public int size() {
return m.size();
}
//是否为空
public boolean isEmpty() {
return m.isEmpty();
}
//是否包含指定的key
public boolean contains(Object o) {
return m.containsKey(o);
}
//添加元素，调用m.put方法实现
public boolean add(E e) {
return m.put(e, PRESENT)==null;
}
//删除方法，调用m.remove()方法实现
public boolean remove(Object o) {
return m.remove(o)==PRESENT;
}
//清除集合
public void clear() {
m.clear();
}
//将一个集合中的所有元素添加到TreeSet中
public
boolean addAll(Collection<? extends E> c) {
// Use linear-time version if applicable
if (m.size()==0 && c.size() > 0 &&
c instanceof SortedSet &&
m instanceof TreeMap) {
SortedSet<? extends E> set = (SortedSet<? extends E>) c;
TreeMap<E,Object> map = (TreeMap<E, Object>) m;
Comparator<? super E> cc = (Comparator<? super E>) set.comparator();
Comparator<? super E> mc = map.comparator();
if (cc==mc || (cc != null && cc.equals(mc))) {
map.addAllForTreeSet(set, PRESENT);
return true;
}
}
return super.addAll(c);
}
//返回子集合，通过 m.subMap()方法实现
public NavigableSet<E> subSet(E fromElement, boolean fromInclusive,
E toElement,
boolean toInclusive) {
return new TreeSet<>(m.subMap(fromElement, fromInclusive,
toElement,
toInclusive));
}
//返回set的头部
public NavigableSet<E> headSet(E toElement, boolean inclusive) {
return new TreeSet<>(m.headMap(toElement, inclusive));
}
//返回尾部
public NavigableSet<E> tailSet(E fromElement, boolean inclusive) {
return new TreeSet<>(m.tailMap(fromElement, inclusive));
}
//返回子Set
public SortedSet<E> subSet(E fromElement, E toElement) {
return subSet(fromElement, true, toElement, false);
}
//返回set的头部
public SortedSet<E> headSet(E toElement) {
return headSet(toElement, false);
}
//返回set的尾部
public SortedSet<E> tailSet(E fromElement) {
return tailSet(fromElement, true);
}
//返回m使用的比较器
public Comparator<? super E> comparator() {
return m.comparator();
}
//返回第一个元素
public E first() {
return m.firstKey();
}
//返回最后一个元素
public E last() {
return m.lastKey();
}
//返回set中小于e的最大的元素
public E lower(E e) {
return m.lowerKey(e);
}
//返回set中小于/等于e的最大元素
public E floor(E e) {
return m.floorKey(e);
}
//返回set中大于/等于e的最大元素
public E ceiling(E e) {
return m.ceilingKey(e);
}
//返回set中大于e的最小元素
public E higher(E e) {
return m.higherKey(e);
}
//获取TreeSet中第一个元素，并从Set中删除该元素
public E pollFirst() {
Map.Entry<E,?> e = m.pollFirstEntry();
return (e == null) ? null : e.getKey();
}
//获取TreeSet中最后一个元素，并从Set中删除该元素
public E pollLast() {
Map.Entry<E,?> e = m.pollLastEntry();
return (e == null) ? null : e.getKey();
}
//克隆方法
public Object clone() {
TreeSet<E> clone = null;
try {
clone = (TreeSet<E>) super.clone();
} catch (CloneNotSupportedException e) {
throw new InternalError();
}
clone.m = new TreeMap<>(m);
return clone;
}
//将对象写入到输出流中。
private void writeObject(java.io.ObjectOutputStream s)
throws java.io.IOException {
// Write out any hidden stuff
s.defaultWriteObject();
// Write out Comparator
s.writeObject(m.comparator());
// Write out size
s.writeInt(m.size());
// Write out all elements in the proper order.
for (E e : m.keySet())
s.writeObject(e);
}
//从输入流中读取对象的信息
private void readObject(java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException {
// Read in any hidden stuff
s.defaultReadObject();
// Read in Comparator
Comparator<? super E> c = (Comparator<? super E>) s.readObject();
// Create backing TreeMap
TreeMap<E,Object> tm;
if (c==null)
tm = new TreeMap<>();
else
tm = new TreeMap<>(c);
m = tm;
// Read in size
int size = s.readInt();
tm.readTreeSet(size, s, PRESENT);
}
//序列化版本号
private static final long serialVersionUID = -2479143000061671589L;
}

       LinkedHashSet：去重并保留插入顺序，去重是由set(集)实现的。

Map详见下一篇：

最后

以上就是无奈小蜜蜂为你收集整理的java 集合总结的全部内容，希望文章能够帮你解决java 集合总结所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。