Java集合总结

Java集合总结

概述

Java集合类主要由两个接口派生而出：

• Collection

• Map

这两个是Java集合框架的根接口

Collection与Iterator接口

Collection是List、Set、Queue的父接口

来看看具体使用：

public class CollectionTest {

    public static void main(String[] args) {


        Collection c = new ArrayList();
        // 添加元素
        c.add("孙悟空");
        // 虽然集合里不能放基本类型的值，但Java支持自动装箱
        c.add(6);
        System.out.println("c集合的元素个数为:" + c.size()); // 输出2
        // 删除指定元素
        c.remove(6);
        System.out.println("c集合的元素个数为:" + c.size()); // 输出1
        // 判断是否包含指定字符串
        System.out.println("c集合的是否包含\"孙悟空\"字符串:"
                + c.contains("孙悟空")); // 输出true
        c.add("Java");
        System.out.println("c集合的元素：" + c);
        Collection books = new HashSet();
        books.add("Java");
        books.add("Java9");
        System.out.println("c集合是否完全包含books集合？"
                + c.containsAll(books)); // 输出false
        // 用c集合减去books集合里的元素
        c.removeAll(books);
        System.out.println("c集合的元素：" + c);
        // 删除c集合里所有元素
        c.clear();
        System.out.println("c集合的元素：" + c);
        // 控制books集合里只剩下c集合里也包含的元素
        books.retainAll(c);
        System.out.println("books集合的元素:" + books);
    }
}

Lambda表达式遍历集合

Java8为Iterable接口新增了一个forEach默认方法，该方法所需参数类型是一个函数式接口，而Iterable是Collection接口的父接口，所以Collection集合可以直接使用

public class CollectionEach {

    public static void main(String[] args)
    {
        // 创建一个集合
        Collection books = new HashSet();
        books.add("Java");
        books.add("Java9");
        books.add("Android");
        // 调用forEach()方法遍历集合
        books.forEach(obj -> System.out.println("迭代集合元素：" + obj));
    }
}

Iterator遍历集合元素

public class IteratorTest {

    public static void main(String[] args)
    {
        // 创建集合、添加元素的代码与前一个程序相同
        Collection books = new HashSet();
        books.add("1");
        books.add("2");
        books.add("3");
        // 获取books集合对应的迭代器
        Iterator it = books.iterator();
        while(it.hasNext())
        {
            // it.next()方法返回的数据类型是Object类型，因此需要强制类型转换
            String book = (String)it.next();
            System.out.println(book);
            if (book.equals("2"))
            {
                // 从集合中删除上一次next方法返回的元素
                it.remove();
            }
            // 对book变量赋值，不会改变集合元素本身
            book = "测试字符串";   //①
        }
        System.out.println(books);
    }
}

Iterator依附于Collection对象，若有一个Iterator对象，则必然有一个与之关联的Collection对象

当使用Iterator迭代访问元素时，Collection里面的元素不能被改变，只有通过Iterator的remove方法删除上一次next方法返回的集合元素才可以

public class IteratorErrorTest {

    public static void main(String[] args) {

        // 创建集合、添加元素的代码与前一个程序相同
        Collection books = new HashSet();
        books.add("1");
        books.add("2");
        books.add("3");
        // 获取books集合对应的迭代器
        Iterator it = books.iterator();
        while(it.hasNext())
        {
            String book = (String)it.next();
            System.out.println(book);
            if (book.equals("2"))
            {
                // 使用Iterator迭代过程中，不可修改集合元素,下面代码引发异常
                books.remove(book);
            }
        }

    }
}

Lambda表达式遍历Iterator

Java8为Iterator新增了一个forEachRemaining方法

public class IteratorEach {

    public static void main(String[] args) {
        // 创建集合、添加元素的代码与前一个程序相同
        Collection books = new HashSet();
        books.add("1");
        books.add("2");
        books.add("3");
        // 获取books集合对应的迭代器
        Iterator it = books.iterator();
        // 使用Lambda表达式（目标类型是Comsumer）来遍历集合元素
        it.forEachRemaining(obj -> System.out.println("迭代集合元素：" + obj));


    }
}

foreach循环遍历集合元素

public class ForeachTest {

    public static void main(String[] args) {

        // 创建集合、添加元素的代码与前一个程序相同
        Collection books = new HashSet();
        books.add(new String("1"));
        books.add(new String("2"));
        books.add(new String("3"));
        for (Object obj : books)
        {
            // 此处的book变量也不是集合元素本身
            String book = (String)obj;
            System.out.println(book);
            if (book.equals("3"))
            {
                // 下面代码会引发ConcurrentModificationException异常
                books.remove(book);     //①
            }
        }
        System.out.println(books);

    }
}

Java8新增的Predicate操作

Java8为Collection新增了removeIf(Predicate filter)方法，该方法将批量删除符合filter条件的所有元素

public class PredicateTest {

    public static void main(String[] args) {

        // 创建一个集合
        Collection books = new HashSet();
        books.add(new String("1"));
        books.add(new String("2dnkjadjadjadhjka"));
        books.add(new String("3"));
        books.add(new String("4fflsjfksjdfksjfidsjfisj"));
        books.add(new String("5"));
        // 使用Lambda表达式（目标类型是Predicate）过滤集合
        books.removeIf(ele -> ((String)ele).length() < 10);
        System.out.println(books);

    }
}

Set集合

Set最大的特点就是不允许包含重复元素

HashSet

特点：

• 不能保证元素的排列顺序

• 不是同步的

• 集合元素值允许是null

向HashSet添加元素时，会调用该对象的hashCode()方法来得到该对象的hashCode值，然后根据hashCode值决定该对象在HashSet中的存储位置

假设两个元素equals()返回true，hashCode()返回值不同，那么将会把它们存储在不同位置

HashSet判读两个元素相等的标准是两个对象通过equals()比较一样，并且hashCode()返回值也一样

下面三个类分别重写了equals(),hashCode()中的一个或者两个

// 类A的equals方法总是返回true，但没有重写其hashCode()方法
class A
{
    public boolean equals(Object obj)
    {
        return true;
    }
}


// 类B的hashCode()方法总是返回1，但没有重写其equals()方法
class B
{
    public int hashCode()
    {
        return 1;
    }
}



// 类C的hashCode()方法总是返回2，且重写其equals()方法总是返回true
class C
{
    public int hashCode()
    {
        return 2;
    }
    public boolean equals(Object obj)
    {
        return true;
    }
}
public class HashSetTest
{
    public static void main(String[] args)
    {
        HashSet books = new HashSet();
        // 分别向books集合中添加两个A对象，两个B对象，两个C对象
        books.add(new A());
        books.add(new A());
        books.add(new B());
        books.add(new B());
        books.add(new C());
        books.add(new C());
        System.out.println(books);
    }
}

HashSet把A的两个对象以及B的两个对象当成了两个对象

当把一个对象仿佛HashSet，如果要重写equals(),则对应的也应该重写hashCode()

规则:

如果两个对象通过equals()比较返回true，这两个对象的hashCode()也应该一样

如果向HashSet添加一个可变对象后，后面修改了该对象的实例变量，可能导致它与集合中的其他元素相同，导致HashSet中包含两个一样的对象

class R
{
    int count;
    public R(int count)
    {
        this.count = count;
    }
    public String toString()
    {
        return "R[count:" + count + "]";
    }
    public boolean equals(Object obj)
    {
        if(this == obj)
            return true;
        if (obj != null && obj.getClass() == R.class)
        {
            R r = (R)obj;
            return this.count == r.count;
        }
        return false;
    }
    public int hashCode()
    {
        return this.count;
    }
}
public class HashSetTest2
{
    public static void main(String[] args)
    {
        HashSet hs = new HashSet();
        hs.add(new R(5));
        hs.add(new R(-3));
        hs.add(new R(9));
        hs.add(new R(-2));
        // 打印HashSet集合，集合元素没有重复
        System.out.println(hs);
        // 取出第一个元素
        Iterator it = hs.iterator();
        R first = (R)it.next();
        // 为第一个元素的count实例变量赋值
        first.count = -3;     // ①
        // 再次输出HashSet集合，集合元素有重复元素
        System.out.println(hs);
        // 删除count为-3的R对象
        hs.remove(new R(-3));    // ②
        // 可以看到被删除了一个R元素
        System.out.println(hs);
        System.out.println("hs是否包含count为-3的R对象？"
                + hs.contains(new R(-3))); // 输出false
        System.out.println("hs是否包含count为-2的R对象？"
                + hs.contains(new R(-2))); // 输出false
    }
}

可以看到，R类重写的equals()和hashCode()都是根据R对象的count这个实例变量来进行计算的

所以后面的程序对这个实例变量进行改变后会导致HashSet集合中出现重复的元素

LinkedHashSet

HashSet有一个子类LinkedHashSet，LinkedHashSet根据元素的hashCode值来决定元素的存储位置，同时使用链表维护元素的次序

public class LinkedHashSetTest {

    public static void main(String[] args) {

        LinkedHashSet books = new LinkedHashSet();
        books.add("1");
        books.add("2");
        System.out.println(books);
        books.remove("1");
        books.add("1");
        System.out.println(books);

    }
}

LinkedHashSet依然不允许集合元素重复

TreeSet

TreeSet是SortedSet接口的实现类，可以确保集合元素处于排序状态

public class TreeSetTest {

    public static void main(String[] args)
    {
        TreeSet nums = new TreeSet();
        // 向TreeSet中添加四个Integer对象
        nums.add(5);
        nums.add(2);
        nums.add(10);
        nums.add(-9);
        // 输出集合元素，看到集合元素已经处于排序状态
        System.out.println(nums);
        // 输出集合里的第一个元素
        System.out.println(nums.first()); // 输出-9
        // 输出集合里的最后一个元素
        System.out.println(nums.last());  // 输出10
        // 返回小于4的子集，不包含4
        System.out.println(nums.headSet(4)); // 输出[-9, 2]
        // 返回大于5的子集，如果Set中包含5，子集中还包含5
        System.out.println(nums.tailSet(5)); // 输出 [5, 10]
        // 返回大于等于-3，小于4的子集。
        System.out.println(nums.subSet(-3 , 4)); // 输出[2]
    }
}

TreeSet并不是根据元素的插入顺序进行排序的，而是根据元素实际值的大小进行排序的

TreeSet支持两种排序方法：

• 自然排序

• 定制排序

自然排序

TreeSet会调用集合元素的compareTo(Object o)来比较元素之间的大小关系，然后将集合元素按照升序排序

如果试图把一个对象添加到TreeSet，则该对象必须实现了Comparable接口，否则会出错

class Err{}
public class TreeSetErrorTest {

    public static void main(String[] args)
    {
        TreeSet ts = new TreeSet();
        // 向TreeSet集合中添加Err对象
        // 自然排序时，Err没实现Comparable接口将会引发错误
//        Exception in thread "main" java.lang.ClassCastException: C_2.c_2_1.Err cannot be cast to java.lang.Comparable
        ts.add(new Err());
    }


}

TreeSet集合，判断两个对象是否相等的唯一标准是：两个对象通过compareTo(Onject o)比较是否返回0—如果返回0，则认为相等，否则不相等

class Z implements Comparable
{
    int age;
    public Z(int age)
    {
        this.age = age;
    }
    // 重写equals()方法，总是返回true
    public boolean equals(Object obj)
    {
        return true;
    }
    // 重写了compareTo(Object obj)方法，总是返回1
    public int compareTo(Object obj)
    {
        return 1;
    }
}
public class TreeSetTest2
{
    public static void main(String[] args)
    {
        TreeSet set = new TreeSet();
        Z z1 = new Z(6);
        set.add(z1);
        // 第二次添加同一个对象，输出true，表明添加成功
        System.out.println(set.add(z1));    //①
        // 下面输出set集合，将看到有两个元素
        System.out.println(set);
        // 修改set集合的第一个元素的age变量
        ((Z)(set.first())).age = 9;
        // 输出set集合的最后一个元素的age变量，将看到也变成了9
        System.out.println(((Z)(set.last())).age);
    }
}

同样，如果两个对象通过equals()比较返回true,这两个对象通过compareTo比较应该返回0

如果向TreeSet添加一个可变对象，并且修改该对象的实例变量，将导致顺序发生改变

class R implements Comparable
{
    int count;
    public R(int count)
    {
        this.count = count;
    }
    public String toString()
    {
        return "R[count:" + count + "]";
    }
    // 重写equals方法，根据count来判断是否相等
    public boolean equals(Object obj)
    {
        if (this == obj)
        {
            return true;
        }
        if(obj != null && obj.getClass() == R.class)
        {
            R r = (R)obj;
            return r.count == this.count;
        }
        return false;
    }
    // 重写compareTo方法，根据count来比较大小
    public int compareTo(Object obj)
    {
        R r = (R)obj;
        return count > r.count ? 1 :
                count < r.count ? -1 : 0;
    }
}
public class TreeSetTest3
{
    public static void main(String[] args)
    {
        TreeSet ts = new TreeSet();
        ts.add(new R(5));
        ts.add(new R(-3));
        ts.add(new R(9));
        ts.add(new R(-2));
        // 打印TreeSet集合，集合元素是有序排列的
        System.out.println(ts);    // ①
        // 取出第一个元素
        R first = (R)ts.first();
        // 对第一个元素的count赋值
        first.count = 20;
        // 取出最后一个元素
        R last = (R)ts.last();
        // 对最后一个元素的count赋值，与第二个元素的count相同
        last.count = -2;
        // 再次输出将看到TreeSet里的元素处于无序状态，且有重复元素
        System.out.println(ts);   // ②
        // 删除实例变量被改变的元素，删除失败
        System.out.println(ts.remove(new R(-2)));   // ③
        System.out.println(ts);
        // 删除实例变量没有被改变的元素，删除成功
        System.out.println(ts.remove(new R(5)));    // ④
        System.out.println(ts);
    }
}

定制排序

如果想实现定制排序，比如降序排序，可以通过Comparator接口实现

class M
{
    int age;
    public M(int age)
    {
        this.age = age;
    }
    public String toString()
    {
        return "M [age:" + age + "]";
    }
}
public class TreeSetTest4
{
    public static void main(String[] args)
    {
        // 此处Lambda表达式的目标类型是Comparator
        TreeSet ts = new TreeSet((o1 , o2) ->
        {
            M m1 = (M)o1;
            M m2 = (M)o2;
            // 根据M对象的age属性来决定大小，age越大，M对象反而越小
            return m1.age > m2.age ? -1
                    : m1.age < m2.age ? 1 : 0;
        });
        ts.add(new M(5));
        ts.add(new M(-3));
        ts.add(new M(9));
        System.out.println(ts);
    }
}

EnumSet类

EnumSet类是一个专门为枚举类设计的集合类，EnumSet中所有元素都必须是指定枚举类型的枚举值，EnumSet集合元素也是有序的，EnumSet以枚举值在Enum类的定义顺序来决定集合元素的顺序

enum Season
{
    SPRING,SUMMER,FALL,WINTER
}


public class EnumSetTest
{
    public static void main(String[] args)
    {
        // 创建一个EnumSet集合，集合元素就是Season枚举类的全部枚举值
        EnumSet es1 = EnumSet.allOf(Season.class);
        System.out.println(es1); // 输出[SPRING,SUMMER,FALL,WINTER]

        System.out.println("___________________________________________________");
        // 创建一个EnumSet空集合，指定其集合元素是Season类的枚举值。
        EnumSet es2 = EnumSet.noneOf(Season.class);
        System.out.println(es2); // 输出[]

        System.out.println("___________________________________________________");


        // 手动添加两个元素
        es2.add(Season.WINTER);
        es2.add(Season.SPRING);
        System.out.println(es2); // 输出[SPRING,WINTER]

        System.out.println("___________________________________________________");


        // 以指定枚举值创建EnumSet集合
        EnumSet es3 = EnumSet.of(Season.SUMMER , Season.WINTER);
        System.out.println(es3); // 输出[SUMMER,WINTER]

        System.out.println("___________________________________________________");


        EnumSet es4 = EnumSet.range(Season.SUMMER , Season.WINTER);
        System.out.println(es4); // 输出[SUMMER,FALL,WINTER]

        System.out.println("___________________________________________________");

        
        // 新创建的EnumSet集合的元素和es4集合的元素有相同类型，
        // es5的集合元素 + es4集合元素 = Season枚举类的全部枚举值
        EnumSet es5 = EnumSet.complementOf(es4);
        System.out.println(es5); // 输出[SPRING]
    }
}

public class EnumSetTest2 {

    public static void main(String[] args)
    {
        Collection c = new HashSet();
        c.clear();
        c.add(Season.FALL);
        c.add(Season.SPRING);
        // 复制Collection集合中所有元素来创建EnumSet集合
        EnumSet enumSet = EnumSet.copyOf(c);   // ①
        System.out.println(enumSet); // 输出[SPRING,FALL]
        c.add("Java");
        c.add("C++");
        // 下面代码出现异常：因为c集合里的元素不是全部都为枚举值
        enumSet = EnumSet.copyOf(c);  // ②
    }
}

List集合

List接口和ListIterator接口

展示List集合常规操作

public class ListTest {

    public static void main(String[] args) {

        List books = new ArrayList();
        // 向books集合中添加三个元素
        books.add(new String("Java"));
        books.add(new String("C++"));
        books.add(new String("Android"));
        System.out.println(books);
        // 将新字符串对象插入在第二个位置
        books.add(1 , new String("Ajax"));
        for (int i = 0 ; i < books.size() ; i++ )
        {
            System.out.println(books.get(i));
        }
        // 删除第三个元素
        books.remove(2);
        System.out.println(books);
        // 判断指定元素在List集合中位置：输出1，表明位于第二位
        System.out.println(books.indexOf(new String("Ajax"))); //①
        //将第二个元素替换成新的字符串对象
        books.set(1, new String("Java"));
        System.out.println(books);
        //将books集合的第二个元素（包括）
        //到第三个元素（不包括）截取成子集合
        System.out.println(books.subList(1 , 2));

    }
}

List判断两个对象相等通过equals()返回true即可

class A
{
    public boolean equals(Object obj)
    {
        return true;
    }
}
public class ListTest2
{
    public static void main(String[] args)
    {
        List books = new ArrayList();
        books.add(new String("Java"));
        books.add(new String("C++"));
        books.add(new String("Android"));
        System.out.println(books);
        // 删除集合中A对象，将导致第一个元素被删除
        books.remove(new A());     // ①
        System.out.println(books);
        // 删除集合中A对象，再次删除集合中第一个元素
        books.remove(new A());     // ②
        System.out.println(books);
    }
}

Java 8为List集合增加了sort()和replaAll()两个默认方法

public class ListTest3 {

    public static void main(String[] args) {

        List books = new ArrayList();
        // 向books集合中添加4个元素
        books.add(new String("Java"));
        books.add(new String("C++"));
        books.add(new String("Android"));
        books.add(new String("iOS"));
        // 使用目标类型为Comparator的Lambda表达式对List集合排序
        books.sort((o1, o2)->((String)o1).length() - ((String)o2).length());
        System.out.println(books);
        // 使用目标类型为UnaryOperator的Lambda表达式来替换集合中所有元素
        // 该Lambda表达式控制使用每个字符串的长度作为新的集合元素
        books.replaceAll(ele->((String)ele).length());
        System.out.println(books); 


    }
}

固定长度的List

操作数组的工具类：Arrays，提供了一个asList(Object…a)方法，该方法可以把一个数组或指定个数的对象转换成一个List集合

Arrays.ArrayList是一个固定长度的List集合，只能遍历，不能增加，删除

public class FixedSizeList {

    public static void main(String[] args)
    {
        List fixedList = Arrays.asList("Java"
                , "Java EE");
        // 获取fixedList的实现类，将输出Arrays$ArrayList
        System.out.println(fixedList.getClass());
        // 使用方法引用遍历集合元素
        fixedList.forEach(System.out::println);
        // 试图增加、删除元素都会引发UnsupportedOperationException异常
        fixedList.add("Android");
        fixedList.remove("C++");
    }
}

Queue集合

Queue用于模拟队列这种数据结构

Queue接口有一个PriorityQueue实现类，还有一个Deque接口，Deque代表一个“双端队列”，Java为Deque提供了ArrayDeque和LinkedList两个实现类

PriorityQueue

PriorityQueue保存队列元素的顺序不是按加入队列的顺序，而是按照队列元素的大小进行重新排序，所以用peek()或者poll()取元素，并不是取出最先进入队列的元素，而是最小元素

public class PriorityQueueTest {

    public static void main(String[] args)
    {
        PriorityQueue pq = new PriorityQueue();
        // 下面代码依次向pq中加入四个元素
        pq.offer(6);
        pq.offer(-3);
        pq.offer(20);
        pq.offer(18);
        // 输出pq队列，并不是按元素的加入顺序排列
        System.out.println(pq); // 输出[-3, 6, 20, 18]
        // 访问队列第一个元素，其实就是队列中最小的元素：-3
        System.out.println(pq.poll());
    }
}

PriorityQueue不允许出现null值

Deque和ArrayDeque实现类

把ArrayDeque当成栈使用

public class ArrayDequeStack {

    public static void main(String[] args) {

        ArrayDeque stack = new ArrayDeque();
        // 依次将三个元素push入"栈"
        stack.push("Java");
        stack.push("Java EE");
        stack.push("Android");



        System.out.println(stack);


        System.out.println(stack.peek());


        System.out.println(stack);



        System.out.println(stack.pop());


        System.out.println(stack);

    }
}

ArrayDeque也可以用作队列使用

public class ArrayDequeQueue {

    public static void main(String[] args) {

        ArrayDeque queue = new ArrayDeque();
        // 依次将三个元素加入队列
        queue.offer("Java");
        queue.offer("Java EE");
        queue.offer("Android");


        System.out.println(queue);



        System.out.println(queue.peek());



        System.out.println(queue);



        System.out.println(queue.poll());



        System.out.println(queue);

    }
}

LinkedList

public class LinkedListTest {

    public static void main(String[] args)
    {
        LinkedList books = new LinkedList();
        // 将字符串元素加入队列的尾部
        books.offer("Java");
        // 将一个字符串元素加入栈的顶部
        books.push("Java EE");
        // 将字符串元素添加到队列的头部（相当于栈的顶部）
        books.offerFirst("Android");
        // 以List的方式（按索引访问的方式）来遍历集合元素
        for (int i = 0; i < books.size() ; i++ )
        {
            System.out.println("遍历中：" + books.get(i));
        }

        System.out.println("___________________________________");
        // 访问、并不删除栈顶的元素
        System.out.println(books.peekFirst());
        // 访问、并不删除队列的最后一个元素
        System.out.println(books.peekLast());
        // 将栈顶的元素弹出“栈”
        System.out.println(books.pop());
        // 下面输出将看到队列中第一个元素被删除
        System.out.println(books);
        // 访问、并删除队列的最后一个元素
        System.out.println(books.pollLast());


        System.out.println(books);
    }


}

Map

Map用于保存具有映射关系的数据，Map的key不允许重复

public class MapTest {

    public static void main(String[] args)
    {
        Map map = new HashMap();
        // 成对放入多个key-value对
        map.put("Java" , 109);
        map.put("iOS" , 10);
        map.put("Ajax" , 79);
        // 多次放入的key-value对中value可以重复
        map.put("Java EE" , 99);

        
        // 放入重复的key时，新的value会覆盖原有的value
        // 如果新的value覆盖了原有的value，该方法返回被覆盖的value

        System.out.println(map.put("iOS" , 99)); // 输出10

        System.out.println(map); // 输出的Map集合包含4个key-value对


        // 判断是否包含指定key
        System.out.println("是否包含值为 iOS key："
                + map.containsKey("iOS")); // 输出true


        // 判断是否包含指定value
        System.out.println("是否包含值为 99 value："
                + map.containsValue(99)); // 输出true
        // 获取Map集合的所有key组成的集合，通过遍历key来实现遍历所有key-value对

        for (Object key : map.keySet() )
        {
            // map.get(key)方法获取指定key对应的value
            System.out.println(key + "-->" + map.get(key));
        }

        map.remove("Ajax"); // 根据key来删除key-value对。
        System.out.println(map);
    }
}

Java 8新增方法：

public class MapTest2 {

    public static void main(String[] args)
    {
        Map map = new HashMap();
        // 成对放入多个key-value对
        map.put("Java" , 109);
        map.put("iOS" , 99);
        map.put("Ajax" , 79);
        // 尝试替换key为"XML"的value，由于原Map中没有对应的key，
        // 因此对Map没有改变，不会添加新的key-value对
        map.replace("XML" , 66);
        System.out.println(map);
        // 使用原value与参数计算出来的结果覆盖原有的value
        map.merge("iOS" , 10 ,
                (oldVal , param) -> (Integer)oldVal + (Integer)param);


        System.out.println(map);

        // 当key为"Java"对应的value为null（或不存在时），使用计算的结果作为新value
        map.computeIfAbsent("Java" , (key)->((String)key).length());

        System.out.println(map); // map中添加了 Java=4 这组key-value对

        // 当key为"Java"对应的value存在时，使用计算的结果作为新value
        map.computeIfPresent("Java",
                (key , value) -> (Integer)value * (Integer)value);

        System.out.println(map); 
    }


}