【java集合一】根接口Collection、Map

原创 2016年05月31日 21:50:13

       Java集合类是一种非常实用的工具类,主要用于保存、盛装其它数据(集合里只能保存对象),因此集合类也被成为容器类。所有的集合类都位于java.util包下,在java.util.concurrent下还提供了一些支持多线程的集合类。Java的集合类主要由两个接口派生而来:Collection和Map,这两个是Java集合框架的根接口。

一、Collection接口


        Collection派生出三个子接口,Set代表不可重复的无序集合、List代表可重复的有序集合、Queue是java提供的队列实现;Collection是最基本的集合接口,它提供了一些通用的方法,供子接口调用。

        Collection源码分析如下:

// 位于java.util包下
package java.util;

import java.util.function.Predicate; // 函数式接口,广泛用在支持lambda表达式的API中
import java.util.stream.Stream; // 数据流接口,定义了众多Stream应该具有的行为
import java.util.stream.StreamSupport; //提供了底层的一些用于操作Stream的方法,如果不需要创建自己的Stream,一般不需要使用它。

// 继承于接口Iterable迭代器,即所有Collection集合体系中的集合类,都可以使用forEach进行循环遍历
public interface Collection<E> extends Iterable<E> {
    // 1.查询类操作
    int size(); // 返回元素个数
    boolean isEmpty(); // 判断集合是否为空
    boolean contains(Object o); // 判断是否包含元素 o
    Iterator<E> iterator(); // 返回集合类的迭代器
    Object[] toArray(); // 将集合转换为数组
    <T> T[] toArray(T[] a); // 转换为具体某一类型的数组

    // 2.修改类操作
    boolean add(E e); // 往集合中添加元素 e
    boolean remove(Object o); // 删除元素 o

    // 3.批量操作
    boolean containsAll(Collection<?> c); // 判断 c 是否包含在集合中
    boolean addAll(Collection<? extends E> c); // 将 c 中所有元素添加到集合中
    boolean removeAll(Collection<?> c); // 移除集合中所包含的 c 中的所有元素
    boolean retainAll(Collection<?> c); //移除所有不包含在 c 中的所有元素,即只留下两个集合共有的元素
    void clear(); // 清除集合中所有元素
    // 删除满足 filter 条件的元素
    default boolean removeIf(Predicate<? super E> filter) {
        Objects.requireNonNull(filter);
        boolean removed = false;
        final Iterator<E> each = iterator();
        while (each.hasNext()) {
            if (filter.test(each.next())) {
                each.remove();
                removed = true;
            }
        }
        return removed;
    }

    // 4.比较和散列
    boolean equals(Object o); // 判断集合和对象 o 是否相等
    int hashCode(); // 返回该集合的 hashcode 值
    // 重写了 Iterable 接口的 Spliterator 方法
    @Override
    default Spliterator<E> spliterator() {
        return Spliterators.spliterator(this, 0);
    }
    // 在这个集合上返回一个连续的代码流
    default Stream<E> stream() {
        return StreamSupport.stream(spliterator(), false);
    }
    // 在这个集合上返回一个并行的代码流
    default Stream<E> parallelStream() {
        return StreamSupport.stream(spliterator(), true);
    }
}

二、Map接口


        Map实现类都用于保存具有映射关系的数据,它们保存的数据都是key-value对,如果要查找Map中的数据,总是根据key来获取,所以key是不可重复的,它用于标识集合里的每项数据。

        Map源码分析如下:

// 位于java.util包下
package java.util;

import java.util.function.BiConsumer;
import java.util.function.BiFunction;
import java.util.function.Function;
import java.io.Serializable; // 通过实现该接口以启用其序列化功能

// Map 接口, K 为键, V 为值
public interface Map<K,V> {
    // 1.查询操作
    int size(); // 返回元素个数
    boolean isEmpty(); // 判断是否为空
    boolean containsKey(Object key); // 判断是否包含键 key
    boolean containsValue(Object value); // 判断是否包含值 value
    V get(Object key); //返回键 key 对应的值

    // 2.修改操作
    V put(K key, V value); // 添加元素, 元素为 (key,value)
    V remove(Object key); // 移除键为 key 的元素


    // 3.批量操作
    void putAll(Map<? extends K, ? extends V> m); // 将 m 中所有元素添加到集合中
    void clear(); // 清空集合


    // 4.集合视图
    Set<K> keySet(); // 返回 key 的集合视图
    Collection<V> values(); // 返回 value 的集合视图
    Set<Map.Entry<K, V>> entrySet(); //返回元素 Entry<K,V> 的集合视图
    // 集合实体,Map的内部集合,对应Map中的一个元素
    interface Entry<K,V> {
        K getKey();
        V getValue();
        V setValue(V value);
        boolean equals(Object o);
        int hashCode();
        public static <K extends Comparable<? super K>, V> Comparator<Map.Entry<K,V>> comparingByKey() {
            return (Comparator<Map.Entry<K, V>> & Serializable)
                    (c1, c2) -> c1.getKey().compareTo(c2.getKey());
        }

        public static <K, V extends Comparable<? super V>> Comparator<Map.Entry<K,V>> comparingByValue() {
            return (Comparator<Map.Entry<K, V>> & Serializable)
                    (c1, c2) -> c1.getValue().compareTo(c2.getValue());
        }

        public static <K, V> Comparator<Map.Entry<K, V>> comparingByKey(Comparator<? super K> cmp) {
            Objects.requireNonNull(cmp);
            return (Comparator<Map.Entry<K, V>> & Serializable)
                    (c1, c2) -> cmp.compare(c1.getKey(), c2.getKey());
        }

        public static <K, V> Comparator<Map.Entry<K, V>> comparingByValue(Comparator<? super V> cmp) {
            Objects.requireNonNull(cmp);
            return (Comparator<Map.Entry<K, V>> & Serializable)
                    (c1, c2) -> cmp.compare(c1.getValue(), c2.getValue());
        }
    }

    // 5.比较和散列
    boolean equals(Object o); // 判断集合和对象 o 是否相等
    int hashCode(); // 返回该集合的 hashcode 值

    // 6.JDK8出现的新方法 - default新特性
    default V getOrDefault(Object key, V defaultValue) {
        V v;
        return (((v = get(key)) != null) || containsKey(key))
                ? v
                : defaultValue;
    }

    default void forEach(BiConsumer<? super K, ? super V> action) {
        Objects.requireNonNull(action);
        for (Map.Entry<K, V> entry : entrySet()) {
            K k;
            V v;
            try {
                k = entry.getKey();
                v = entry.getValue();
            } catch(IllegalStateException ise) {
                // this usually means the entry is no longer in the map.
                throw new ConcurrentModificationException(ise);
            }
            action.accept(k, v);
        }
    }

    default void replaceAll(BiFunction<? super K, ? super V, ? extends V> function) {
        Objects.requireNonNull(function);
        for (Map.Entry<K, V> entry : entrySet()) {
            K k;
            V v;
            try {
                k = entry.getKey();
                v = entry.getValue();
            } catch(IllegalStateException ise) {
                // this usually means the entry is no longer in the map.
                throw new ConcurrentModificationException(ise);
            }

            // ise thrown from function is not a cme.
            v = function.apply(k, v);

            try {
                entry.setValue(v);
            } catch(IllegalStateException ise) {
                // this usually means the entry is no longer in the map.
                throw new ConcurrentModificationException(ise);
            }
        }
    }

    default V putIfAbsent(K key, V value) {
        V v = get(key);
        if (v == null) {
            v = put(key, value);
        }

        return v;
    }

    default boolean remove(Object key, Object value) {
        Object curValue = get(key);
        if (!Objects.equals(curValue, value) ||
                (curValue == null && !containsKey(key))) {
            return false;
        }
        remove(key);
        return true;
    }

    default boolean replace(K key, V oldValue, V newValue) {
        Object curValue = get(key);
        if (!Objects.equals(curValue, oldValue) ||
                (curValue == null && !containsKey(key))) {
            return false;
        }
        put(key, newValue);
        return true;
    }

    default V replace(K key, V value) {
        V curValue;
        if (((curValue = get(key)) != null) || containsKey(key)) {
            curValue = put(key, value);
        }
        return curValue;
    }

    default V computeIfAbsent(K key,
                              Function<? super K, ? extends V> mappingFunction) {
        Objects.requireNonNull(mappingFunction);
        V v;
        if ((v = get(key)) == null) {
            V newValue;
            if ((newValue = mappingFunction.apply(key)) != null) {
                put(key, newValue);
                return newValue;
            }
        }

        return v;
    }

    default V computeIfPresent(K key,
                               BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
        Objects.requireNonNull(remappingFunction);
        V oldValue;
        if ((oldValue = get(key)) != null) {
            V newValue = remappingFunction.apply(key, oldValue);
            if (newValue != null) {
                put(key, newValue);
                return newValue;
            } else {
                remove(key);
                return null;
            }
        } else {
            return null;
        }
    }

    default V compute(K key,
                      BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
        Objects.requireNonNull(remappingFunction);
        V oldValue = get(key);

        V newValue = remappingFunction.apply(key, oldValue);
        if (newValue == null) {
            // delete mapping
            if (oldValue != null || containsKey(key)) {
                // something to remove
                remove(key);
                return null;
            } else {
                // nothing to do. Leave things as they were.
                return null;
            }
        } else {
            // add or replace old mapping
            put(key, newValue);
            return newValue;
        }
    }

    default V merge(K key, V value,
                    BiFunction<? super V, ? super V, ? extends V> remappingFunction) {
        Objects.requireNonNull(remappingFunction);
        Objects.requireNonNull(value);
        V oldValue = get(key);
        V newValue = (oldValue == null) ? value :
                remappingFunction.apply(oldValue, value);
        if(newValue == null) {
            remove(key);
        } else {
            put(key, newValue);
        }
        return newValue;
    }
}

三、defalut 扩展方法(JDK8新特性)

        与以前的集合类相比,JDK8的新特性之一就是提供了很多 default 方法,这些方法拥有具体的实现,子类可以直接调用这些方法的默认实现。defalut方法对Java集合API进行了优化升级,并且在JDK与Lambda表达式的结合中起到了至关重要的作用。

示例1:

        A 接口中定义了一个 hello() 方法,B 类实现 A 接口,则 B 默认实现了 A 中的 hello() 方法

// A 接口中定义了一个用defalut修饰的 hello 方法
public interface A {
    default void hello(){
        System.out.println("调用 A 接口的 hello() ");
    }
}
// B 类实现 A 接口
public class B implements A {}
public class defaultTest {
    public static void main(String[] args) {
        B b = new B();
        b.hello(); // B 类调用了 A 接口中 hello() 方法的默认实现
    }
}


示例2:

        A 接口中定义了一个 defaul 修饰的 hello() 方法,B 接口中也有一个 defaul 修饰的 hello() 方法,defaulTest 同时实现 A、B 接口,则 defaultTest中必须重写 hello() 方法,否则报错

public interface A {
    default void hello(){
        System.out.println("调用 A 接口的 hello() ");
    }
}
public interface B {
    default void hello(){
        System.out.println("调用 B 接口的 hello() ");
    }
}
public class defaultTest implements A,B{
    public void hello(){
        System.out.println("调用 dafultTest 接口的 hello() "); // 调用自身hello方法
        A.super.hello(); // A 接口的 hello 方法
        B.super.hello(); // B 接口的 hello 方法
    }
    public static void main(String[] args) {
        defaultTest test = new defaultTest();
        test.hello();
    }
}
        接口一般没有方法的具体实现,而java又是一种单继承语言,JDK8中加入的这种新特性,不知道算不算在变相的实现多继承。。。
版权声明:本文为博主原创文章,未经博主允许不得转载。

相关文章推荐

JAVA集合详解(Collection和Map接口)

在JAVA的util包中有两个所有集合的父接口Collection和Map,它们的父子关系:             java.util         +Collection 这个接口exten...

JAVA集合 Set(集)、List(列表)、Map(映射)、Collection(接口)

对JAVA集合的理解:     JAVA集合可以存储和操作数目不固定的一组数据;     它不同于数组,数组的大小是固定的,并且只能存放类型相同的数据(基本类型/引用类型);     所有的JAVA集...

几个JAVA集合中常用的接口学习:Collection、Iterator和Map

几个JAVA集合中常用的接口学习:Collection、Iterator和Map集合
  • NTSDB
  • NTSDB
  • 2016年12月21日 23:25
  • 150

JAVA集合详解(Collection和Map接口)

在JAVA的util包中有两个所有集合的父接口Collection和Map,它们的父子关系:             java.util         +Collection 这个接口exten...
  • lioncode
  • lioncode
  • 2013年03月14日 15:20
  • 18415

java中集合Collection和Map接口的实现类

今天又重新学习了java基础类中的集合,那么就总结了一些常用的集合类 那么为什么需要集合类呢?原因其实很简单,因为java中不能动态的创建大小自动扩大的数组,那么我们的集合类就很好的解决了这样的问题。...

JAVA集合详解(Collection和Map接口)

在JAVA的util包中有两个所有集合的父接口Collection和Map,它们的父子关系:             java.util         +Collection 这个接口exten...

13. Java类集 Part 2(Map接口、SortedMap接口、集合工具类Collection、Stack类、属性类Properties) ----- 学习笔记

13.7  Map接口       13.7.1

Java——集合类 Collection接口和 Map接口

以下内容很多引用自http://skyuck.iteye.com/blog/526358 Collection1、集合可以理解为一个动态的对象数组,不同的是集合中的对象内容可以任意扩充。 2、集合的...

Java中的集合类Collection接口和Map接口以及列表和LinkedList类

Java中的集合类 Java用集合类来容纳不同种类的数据,这种容纳是建立在未知的基础上,即Java要用有限种类的集合类,来容纳无限种类的数据对象。 归纳起来Java的集合类可以分为3类,即集、...

java11.语言进阶------Java集合(Collection接口、Map接口)

一、Collection接口1.集合可以理解为一个动态的对象数组,不同的是集合中的对象内容可以任意扩充2.集合的特点:性能高 容易扩展和修改3.Collection的常用子类a).List接口1)....
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:【java集合一】根接口Collection、Map
举报原因:
原因补充:

(最多只允许输入30个字)