java中的集合体系

最新推荐文章于 2024-08-05 23:39:18 发布

upupday19

最新推荐文章于 2024-08-05 23:39:18 发布

阅读量476

点赞数 1

分类专栏：算法 Java基础文章标签： java Colleciton Map

本文链接：https://blog.csdn.net/upupday19/article/details/78077890

版权

算法同时被 2 个专栏收录

66 篇文章 1 订阅

订阅专栏

Java基础

20 篇文章 1 订阅

订阅专栏

集合体系

1、Collection

Collection<T>
    |--List<T>(Iterator、ListIterator、get)允许元素重复，因为有角标索引
        |--ArrayList<T>
        底层是数组，查询较快，增删较慢。
        |--LinkedList<T>
        底层是链表，查询较慢，增删较快。
        |--Vector<T>
        和ArrayList没有特别大的区别
        1）Vector是1.0出现，ArrayList是1.2出现。
        2）Vector支持线程同步，效率低，ArrayList不支持同步，效率高
        3）Vector提供了枚举的获取元素的方式。
        Vector<T> v = new Vector();
        v.add(...);
        for(Enumeration<T> e = v.elements(); e.hasMoreElement(); )
        {
            T t = e.nextElement();
        }
    |--Set<T>(Itertaor)不允许元素重复，没有角标索引
        |--HashSet<T>
        底层是hash表，保证元素唯一性的原理是hashCode()和equals()方法
        |--TreeSet<T>
        底层是二叉树结构，可以对元素进行排序，保证元素唯一性的原理是元素自身的比较方式或者自定义比较器。

2、Map

Map<K,V>
    |--TreeMap<K,V>
    底层二叉树，不支持线程同步，效率高
    通过键自身的比较方法或者比较器来保证键的唯一性，并且会对键进行排序
    允许null作为键和值
    |--HashTable<K,V>
    底层是hash表，支持线程同步，效率低，1.0出现
    不允许null的键和值
        |--Properties
    |--HashMap<K,V>
    底层是hash表，不支持线程同步，效率高，1.2出现
    允许null作为键和值
    和HashSet相同，通过hashCode和equals方法保证键的唯一性

集合体系方法

1、Collection<E>体系方法

1）共性方法

boolean add(E e)//成功添加就返回true
boolean addAll(Collection<? extends E> c)
void clear()//清除集合中的所有元素
boolean contains(Object obj)
boolean containsAll(Collection<?> c)
boolean equals(Object obj)
boolean isEmpty()
Iterator<E> iterator()//返回迭代器
boolean remove(Object o)//true表示有o元素并删除，false表示没有
boolean removeAll(Collection<?> c)//移除当前集合中的在也在c中的元素,如果该集合发生了改变就返回true，没有就返回false
boolean retainAll(Collection<?> c)//只保留两个集合中的共有元素，如果该集合发生了改变就返回true，如果没有就返回false
int size()//返回元素个数
Object[] toArray()

2）List<E>特有方法，涉及到角标

boolean add(int index, E e)//在index角标出添加元素e
boolean addAll(int index, Collection<? extends E> c)//将集合c添加到index处
E get(int index)//获取index处的元素
void set(int index, E e)
int indexOf(Object obj)//返回obj所在的角标，不包括返回-1
int lastIndexOf(Object obj)//倒序索引，返回obj第一次出现的角标，不包括返回-1
E remove(int index)//返回index位置的元素，如果没有就返回null
List<E> subList(int fromIndex, int toIndex)//返回子集合[fromIndex, toIndex-1]
ListIterator<E> listIterator()//返回ListIterator迭代器

3）LinkedList<E>特有方法

void addFirst(E e)//将e插入此列表的开头
void addLast(E e)//将e插入此列表的结尾
1.6开始后，变成了offerFirst(E e)和offerLast(E e)，返回值是boolean
E getFirst()//从列表开头获取元素而不删除
E getLast()//从列表结尾获取元素而不删除
1.6开始后，变成了peekFirst()和peekLast()
E removeFirst()//从列表开头获取元素并删除
E removeLast()//从列表结尾获取元素并删除
1.6开始后，变成了pollFirst()和pollLast()
对于栈，使用addFirst和removeFirst配合或者使用addLast和removeLast配合
对于堆，使用addFirst和removeLast配合或者使用addLast和removeFirst配合

3）Set<E>的方法和Collection<E>相同

2、Map<K,V>体系方法

1）添加

boolean put(K key, V value)//添加<key, value>映射关系，如果集合中没有该键就返回null，如果有就返回该键对应的旧值。
保证键唯一性的方法和具体的Map集合有关：
比如对于HashMap集合，判断键是否相同是根据hashCode和equals方法
对于TreeMap集合，判断键是否相同是根据键自身的比较性或者自定义比较器的比较方法进行

2）删除

void clear()//清除Map集合
V remove(Object key)//清除键key对应的键值对，并且返回值，如果没有该键，返回null

3）判断

boolean isEmpty()
boolean containsKey(Object obj)//判断是否包含键为obj的键值对
boolean containsValue(Object obj)//判断是否包含值为obj的键值对
boolean equals(Object obj)//判断集合和obj是否相同

4）获取大小、值

int size()//获取大小
Collection<V> values()//获取所有的值
V get(Object key)//获取key对应的value值，如果没有就返回null

5）获取元素

//Set<K> keySet()
//将Map集合的键存到Set集合中
for(Iterator<K> it = map.keySet().iterator(); it.hasNext();)
{
	K key = it.next();
	V value = map.get(key);
	sop(key+"---"+value);
}
//Set<Map.Entry<K,V>> entrySet()
//将映射关系存到Set集合中
for(Iterator<Map.Entry<K,V>> it = map.entrySet().iterator(); it.hasNext();)
{
	Map.Entry<K,V> me = it.next();
	K key = me.getKey();
	V value = me.getValue();
	sop(key+"---"+value);
}

3、迭代器Iterator及其子接口ListIterator方法

1）Iterator<E>

void remove()//将集合从元素中删除
boolean hasNext()//判断是否还有元素
E next()//获取元素

2） ListIterator<E>

boolean hasNext()
boolean hasPrevious()//判断前面是否有元素
E next()
E previous()//获取前一个的元素
void add(E e)//将元素e插入列表
void remove()
void set(E e)//将元素替换next或者previous返回是最后一个元素

4、Map.Entry<K,V>

Map.Entry<K,V>接口是Map接口中的内部静态接口。表示映射关系。

K getKey()//获取映射关系的键
V getValue()//获取映射关系的值
V setValue(V value)//使用value替换此项对应的值

5、Enumeration<E>枚举

和迭代器相同

boolean hasMoreElements()
E nextElement()

6、Properties

1）是HashTable的子类，获取元素有三种方式，keySet()和entrySet()以及Set<String> stringPropertyNames()

    //1）keySet()
    for(Object key: prop.keySet())
    {    
        sop(key+"---"+prop.get(key));
    }
    //2）entrySet()
    for(Map.Entry<Object, Object> me: prop.entrySet())
    {
        sop(me.getKey()+"---"+me.getValue());
    }
    //3）stringPropertyNames()
    for(String key: prop.stringPropertyNames())
    {
        sop(key+"---"+prop.get(key));
    }

2）系统类System的静态方法：public static Properties getProperties()

如果直接输出获取的系统属性，格式较复杂，不利于获取具体元素。因此可以使用Properties的方法list，将属性列表输出到输出字符流或者输出字节流。
void list(PrintStream out)
void list(PrintWriter out)

7、HashSet<E>和HashMap<K,V>保证元素唯一的原理：hashCode和equals

hs.add(E e);hs.contains(Object e);hs.remove(Object e)
首先调用e.hashCode()，看hs集合中是否有相同的hash值：
如果没有直接添加，add返回true，remove和contains返回false；
如果有就调用e.equals(obj)，obj是和e的hash值相同的元素，如果没有相同的，同上；
如果有相同的，就不添加，add返回false，contains和remove方法返回true，remove方法会将该元素删除。
HashMap<K,V>使用相同的方法是对键进行唯一性判定。

8、TreeSet<E>和TreeMap<K,V>保证元素唯一性并进行排序的原理：Comparable<T>或者Comparator<T>

1）如果集合元素自身具备比较性，并且没有比较器传入，按照元素比较方式进行排序
2）如果集合元素自身不具备比较性，或者集合的构造函数有比较器传入，按照比较器的比较方式进行排序。

9、比较器Comparator<T>以及比较方法接口Comparable<T>

1）Comparator<T> java.util包传入集合构造函数

int compare(T o1, T o2)//需要复写
boolean equals(Object obj)//不需要复写

2）Comparable<T> java.lang包集合元素需要实现此接口

int compareTo(T o)//将当前元素和o比较
一般在创建类的时候，为了可以将其对象存到集合中，需要复写hashCode、equals、toString方法，并且需要实现Comparable<T>接口，复写compareTo方法。
如果集合中泛型是T对象，那么集合只能存T对象。
但是比较器，如果泛型是T对象，那么可以比较T或者其子类。