Java库中的常用集合（Collection/List/Set/Map）

最新推荐文章于 2024-06-06 09:32:02 发布

wutao1155

最新推荐文章于 2024-06-06 09:32:02 发布

阅读量646

点赞数

分类专栏： JavaSE 文章标签： java 对象

本文链接：https://blog.csdn.net/wutao1155/article/details/53151435

版权

JavaSE 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

一、Collection<E> 接口

1.1、常用方法

 /*
  *增删操作
  */
 boolean add(E e)
 boolean remove(Object o)

 /*
  *集合操作
  */
 //对于Set接口就是求并集，对于List接口就是将两列表连接起来 
 boolean addAll(Collection<? extends E> c) 
 //对于Set接口就是求差集 
 boolean removeAll(Collection<?> c)       
 //对于Set接口就是求交集
 boolean retainAll(Collection<?> c)      

 /*
  *查找某一个或几个元素在集合中是否存在
  */
 boolean contains(Object o)
 boolean containsAll(Collection<?> c)

以上方法都会涉及集合元素的比较，这些比较都是通过调用显式参数的equals()方法来完成的，所以需要重写equals()方法。
以上方法的隐式参数和显式参数都只要求实现了Collection接口即可，所以可以出现隐式参数和显式参数一者为Set，一者为List的情况（但这种情况，在实现正确的equals()方法的约束下，永远返回false）。

equals()方法重写示例：

/*
 *情形一：如果子类能够拥有自己的相等概念，则对称性需求将强制采用getClass进行检测
 */
class Employee{
    public String name;
    public int age;
    public double[] bwh;
    //...
    @Override
    public boolean equals(Object obj){ //equals()方法的入参必须为Object类型
        if(this ==  obj) return true;
        if(obj == null) return false;

        if(getClass() != obj.getClass()) return false;
        Employee other = (Employee)obj;

        return Objects.equals(name,other.name) //引用类型比较
            && age == other.age                //基本类型比较
            && Arrays.equals(bwh,other.bwh);   //数组比较
    }
}


/*
 *情形二：如果由超类决定相等的概念，那么就可以使用instanceof进行检测，这样可以在不同子类的对象之间进行相等的比较
 */
class Employee extends SuperClassName{
    public String name;
    public int age;
    public double[] bwh;
    //...
    @Override
    public boolean equals(Object obj){     
        if(this ==  obj) return true;
        if(obj == null) return false;

        if(!(obj instanceof SuperClassName)) return false;
        SuperClassName other = (SuperClassName)obj;

        //superName、superAge等是父类的属性
        return Objects.equals(superName,other.superName) 
            && superAge == other.superAge                
            && Arrays.equals(superbwh,other.superbwh);  
    }
}

重写equals()方法的同时，也必须重写hashCode()方法：

class Employee{
    public String name;
    public int age;
    public double height;
    public double[] bwh;
    //...
    @Override
    public int hashCode(){
        int c = 7;    //最好为质数。防止键的集聚
        return c * Objects.hashCode(name)        //引用类型的哈希值
             + c * age                           //int型的哈希值
             + c * new Double(height).hashCode() //double型的哈希值
             + c * Arrays.hashCode(bwh);         //数组的哈希值
    }
}

当equals()方法返回true时，两个对象的hashcode也必须相同；当equals()方法返回false时，两个对象的hashcode在大多数情况是不同的，在少数情况下相同。
集合类判断两个对象是否相等，是先判断hashcode是否相等，再判断equals()返回值是否为ture，只有两者都相等时，才认为该两个对象是相等的。所以若两个相同的对象有不同的hashcode，就会将两个相同的对象插入到Set或Map中。
所谓散列冲突，是指集合类在判断两个对象是不同的之后，将两者的hashcode经过运算，发现两者在桶（bucket）中的位置是相同的。两者的hashcode不相同时有可能出现散列冲突，两者的hashcode相同时一定会出现散列冲突。所以就算不同的对象有相同的hashcode，也不会影响集合类的正常运行。

1.2、迭代器方法 Iterator<E> iterator()

迭代器使用示例：

Collection<String> c = new ArrayList<String>();
Iterator<String> iter = c.iterator();
while(iter.hasNext()){
    String element = iter.next();
    if(...){
        iter.remove();
    }
}

只有对自然有序的集合使用迭代器添加元素才有实际意义。
——摘自《Core Java》

所以Collection接口的迭代器没有add()方法，而List接口的迭代器才有add()方法。
在执行 Iterator iter = c.iterator() 时，相当于生成了该集合的一个迭代器实例，若使用该迭代器实例以外的方法修改集合（包括集合自身的方法和其它迭代器实例的方法），就会抛出Concurrent ModificationException异常。
迭代器在add或remove时，会额外改变自己独有的游标，所以在遍历集合时进行增删操作不会出现误操作。
迭代器每次执行next()方法时，都会重新复制当前集合，所以迭代器可以实时反应集合的变化。

二、List<E> 接口

2.1、常用方法

//增
boolean add(E e)
void add(int index, E e) 
//删
boolean remove(Object o)
E remove(int index) 
//改
E set(int index, E element)
//查 
E get(int index) 
int indexOf(Object o) 
//获取子集合
List<E> subList(int fromIndex, int toIndex) 
//获取迭代器
ListIterator<E> listIterator()  
ListIterator<E> listIterator(int index)

2.2、迭代器方法 ListIterator<E> listIterator()

比Iterator多出来的方法：

//Iterator只有删和查的操作，ListIterator还增加了增和改的操作
void add(E e) 
void set(E e)

三、Set<E> 接口

3.1、常用方法

//增
boolean add(E e) 
//删
boolean remove(Object o)

四、Map<K,V> 接口

List接口、Set接口是继承自Collection接口的，而Map接口与Collection接口是平行的关系。

4.1、常用方法

//增、改
V put(K key, V value) 
void putAll(Map<? extends K,? extends V> m)
//查
V get(Object key)
boolean containsKey(Object key) 
boolean containsValue(Object value) 
//删
V remove(Object key)

4.2、Map的视图

三种视图：

//键值对集
Set<Map.Entry<K,V>> entrySet() 
//键集
Set<K> keySet()
//值集(不是集)
Collection<V> values()

视图使用示例：

Map<String,Employee> staff = new HashMap<String,Employee>();
for(Map.Entry<String,Employee> entry : staff.entrySet()){
    String key = entry.getKey();        //取键
    Employee value = entry.getValue();  //取值
    //...
    entry.setValue(e); //重新设值
}

注意点：

entrySet()和keySet()返回的Set，既不是HashSet也不是TreeSet，而是实现了Set接口的某个其它类的对象。同时Set接口扩展了Collection接口，因此可以与使用任何集合一样使用entrySet()和keySet()返回的Set。
——摘自《Core Java》

values()的返回类型是Collection而不是Set，是因为所谓“值集”并不是集，因为有可能重复。

五、类型转换

5.1 不同集合类之间的转换

//通过各自的构造函数
ArrayList(Collection<? extends E> c) 
LinkedList(Collection<? extends E> c)
HashSet(Collection<? extends E> c)

关键点在于这些构造函数的入参都仅仅要求是Collection，So elegant！

5.2 集合类与数组之间的转换

/*
 *数组转换为集合类
 */
String[] arr ={"a","b","c"};
List<String> list = Arrays.asList(arr); //此处list不可修改 
//或直接 List<String> list = Arrays.asList("a","b","c"); 

List<String> arrList = new ArrayList<String>(list);//此处arrList可修改

/*
 *集合类转换为数组
 */
 List<String> arrList = new ArrayList<String>();
 String[] arr = new String[arrList.size()];
 arrList.toArray(arr);