JDK中提供的不可变集合真的做到了不可变吗？

Bertha 。 2022-10-16 05:58 144阅读 0赞

### 文章目录 ###

*   *  JDK中提供的不可变集合真的做到了不可变吗？
     *   *  为什么需要不可变集合
         *  JDK中的不可变集合:Collections.unmodifiableXXX
         *   *  UnmodifiableCollection类
     *  参考链接

## JDK中提供的不可变集合真的做到了不可变吗？ ##

### 为什么需要不可变集合 ###

> 1.  保证线程安全：在并发程序中，使用Immutable既保证线程安全性，也大大增强了并发 的效率（跟并发锁方式相比）。尤其当一个对象是值对象时，更应该考虑采用Immutable方式；
> 2.  被不可信的类库使用时会很安全；
> 3.  如果一个对象不需要支持修改操作(mutation)，将会节省空间和时间的开销；经过分析，所有不可变的集合实现都比可变集合更加有效地利用内存；
> 4.  可以当作一个常量来对待，并且这个对象在以后也不会被改变。  
>     将一个对象复制一份成immutable的，是一个防御性编程技术。
> 
> 参考链接：[https://www.jianshu.com/p/bf2623f18d6a][https_www.jianshu.com_p_bf2623f18d6a]

### JDK中的不可变集合:Collections.unmodifiableXXX ###

在Java中，生成不可变集合主要是通过`java.util`包下的`Collections`工具类提供的方法。该类提供了很多生成不可变集合的方法，下面列举几个。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Nja2V2aW5jeWg_size_16_color_FFFFFF_t_70]

我们就来研究其中的一个方法`unmodifiableCollection`

/** * Returns an <a href="Collection.html#unmodview">unmodifiable view</a> of the * specified collection. Query operations on the returned collection "read through" * to the specified collection, and attempts to modify the returned * collection, whether direct or via its iterator, result in an * {@code UnsupportedOperationException}.<p> * * The returned collection does <i>not</i> pass the hashCode and equals * operations through to the backing collection, but relies on * {@code Object}'s {@code equals} and {@code hashCode} methods. This * is necessary to preserve the contracts of these operations in the case * that the backing collection is a set or a list.<p> * * The returned collection will be serializable if the specified collection * is serializable. * * @param <T> the class of the objects in the collection * @param c the collection for which an unmodifiable view is to be * returned. * @return an unmodifiable view of the specified collection. */
        public static <T> Collection<T> unmodifiableCollection(Collection<? extends T> c) { 
            return new UnmodifiableCollection<>(c);
        }

通过方法签名可以看出，返回类型还是`java.util`包下常见的集合类型，但是他却是不可变的集合，它到底是如何做到的呢？

你要想知道什么是不可变集合，那我就带你研究。

我们一看方法中的内容就只是返回了一个`UnmodifiableCollection`对象，那我们就来研究一下这个`UnmodifiableCollection`类吧

#### UnmodifiableCollection类 ####

static class UnmodifiableCollection<E> implements Collection<E>, Serializable { 
            private static final long serialVersionUID = 1820017752578914078L;
    
            final Collection<? extends E> c;
    
            UnmodifiableCollection(Collection<? extends E> c) { 
                if (c==null)
                    throw new NullPointerException();
                this.c = c;
            }
    
            public int size()                          { return c.size();}
            public boolean isEmpty()                   { return c.isEmpty();}
            public boolean contains(Object o)          { return c.contains(o);}
            public Object[] toArray()                  { return c.toArray();}
            public <T> T[] toArray(T[] a)              { return c.toArray(a);}
            public <T> T[] toArray(IntFunction<T[]> f) { return c.toArray(f);}
            public String toString()                   { return c.toString();}
    
            public Iterator<E> iterator() { 
                return new Iterator<E>() { 
                    private final Iterator<? extends E> i = c.iterator();
    
                    public boolean hasNext() { return i.hasNext();}
                    public E next()          { return i.next();}
                    public void remove() { 
                        throw new UnsupportedOperationException();
                    }
                    @Override
                    public void forEachRemaining(Consumer<? super E> action) { 
                        // Use backing collection version
                        i.forEachRemaining(action);
                    }
                };
            }
    
            public boolean add(E e) { 
                throw new UnsupportedOperationException();
            }
            public boolean remove(Object o) { 
                throw new UnsupportedOperationException();
            }
    
            public boolean containsAll(Collection<?> coll) { 
                return c.containsAll(coll);
            }
            public boolean addAll(Collection<? extends E> coll) { 
                throw new UnsupportedOperationException();
            }
            public boolean removeAll(Collection<?> coll) { 
                throw new UnsupportedOperationException();
            }
            public boolean retainAll(Collection<?> coll) { 
                throw new UnsupportedOperationException();
            }
            public void clear() { 
                throw new UnsupportedOperationException();
            }
    
            // Override default methods in Collection
            @Override
            public void forEach(Consumer<? super E> action) { 
                c.forEach(action);
            }
            @Override
            public boolean removeIf(Predicate<? super E> filter) { 
                throw new UnsupportedOperationException();
            }
            @SuppressWarnings("unchecked")
            @Override
            public Spliterator<E> spliterator() { 
                return (Spliterator<E>)c.spliterator();
            }
            @SuppressWarnings("unchecked")
            @Override
            public Stream<E> stream() { 
                return (Stream<E>)c.stream();
            }
            @SuppressWarnings("unchecked")
            @Override
            public Stream<E> parallelStream() { 
                return (Stream<E>)c.parallelStream();
            }
        }

一看这个类的内容，好家伙，居然用了**装饰者模式**，它本身实现了`Collection`接口，同时在内部持有一个`Collection`对象。而构造方法就是把传入进来的集合对象赋值给自己持有的`Collection`对象。接着就是装饰自己类的内部方法了，对于那些可以做修改操作的方法都进行了重新改造了，比如add，remove等方法，直接抛出UnsupportedOperationException异常。而对于不影响集合内容的方法，则直接委托给了持有的`Collection`对象。好家伙，又学到了一手**装饰者模式**了，JDK中还是用到蛮多设计模式的。

@Test
        void test(){ 
            List<String> list = new ArrayList<>();
            list.add("a");
            list.add("b");
            Collection<String> unmodifiableCollection = Collections.unmodifiableCollection(list);
            unmodifiableCollection.add("c");
        }

运行的时候我们就可以发现会报`java.lang.UnsupportedOperationException`的异常。

但是我们自己研究就可以发现，这里说的不可变不是真正意义上的不可变，如果你只能拿到返回的`UnmodifiableCollection`对象，那确实是不可变的；但是如果你能拿到传进来的`Collection`对象，因为是引用，所以如果`Collection`对象变了，`UnmodifiableCollection`对象也会发生变化。我们来用代码演示一下吧。

@Test
        void test(){ 
            List<String> list = new ArrayList<>();
            list.add("a");
            list.add("b");
            Collection<String> unmodifiableCollection = Collections.unmodifiableCollection(list);
            System.out.println(unmodifiableCollection);//[a, b]
            list.add("c");
            System.out.println(unmodifiableCollection);//[a, b, c]
        }

从上面的代码可以发现，如果传进来的list对象发生了变化，返回的不可变集合的内容也是会发生变化的。

可见，虽然无法从外部改变集合实际的值。但是当内部集合改变的时候，从外部再次获取集合，内容也变了。可见，不可变也只是相对的不可变。

## 参考链接 ##

[Java中的不变集合][Java]

[https_www.jianshu.com_p_bf2623f18d6a]: https://www.jianshu.com/p/bf2623f18d6a
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Nja2V2aW5jeWg_size_16_color_FFFFFF_t_70]: /images/20221014/020fe0111ed34915a5929e5c98ab075c.png
[Java]: https://blog.csdn.net/dbqb007/article/details/87747001?utm_medium=distribute.pc_relevant.none-task-blog-2%7Edefault%7EBlogCommendFromMachineLearnPai2%7Edefault-3.control&depth_1-utm_source=distribute.pc_relevant.none-task-blog-2%7Edefault%7EBlogCommendFromMachineLearnPai2%7Edefault-3.control

发表评论取消回复

表情：

评论列表（有 0 条评论，144人围观）

还没有评论，来说两句吧...

相关阅读

相关 Java中的不可变集合介绍

不可变集合什么是不可变集合? > 不可变集合，就是不可被修改的集合。 > > 集合的数据项在创建的时候提供，并且在整个生命周期中都不可改变。否则报错。为什么创建

逃离我推掉我的手/ 2023年09月24日 13:31/ 0 赞/ 20 阅读

相关 java集合不可变数_java 9新增的不可变集合详解

对于java 9你了解吗?下面的文章内容要给大家介绍的就是java 9新增的不可变集合，一起来了解一下吧。 Java 9版本之前，如果你要创建一个包含6个元素的Set集合，

朱雀/ 2022年11月09日 00:57/ 0 赞/ 223 阅读

相关 JDK中提供的不可变集合真的做到了不可变吗？

文章目录 JDK中提供的不可变集合真的做到了不可变吗？为什么需要不可变集合 JDK中的不可变集合:Collecti

Bertha 。/ 2022年10月16日 05:58/ 0 赞/ 145 阅读

相关 String不可变的分析

https://www.cnblogs.com/think-in-java/p/6127804.html https://blog.csdn.net/cws1214/arti

骑猪看日落/ 2022年08月28日 07:45/ 0 赞/ 210 阅读

相关不可变对象

什么是不可变对象？众所周知，在Java中， String类是不可变的。那么到底什么是不可变的对象呢？可以这样认为：如果一个对象，在它创建完成之后，不能再改变它的状态

蔚落/ 2022年07月29日 10:36/ 0 赞/ 203 阅读

相关不可变的String

String 对象是不可变的，String类中每一个看起来会修改String的方法，实际都是创造一个全新的String对象每当把String对象作为方法的参数时，都会复制一

水深无声/ 2022年06月03日 06:15/ 0 赞/ 170 阅读

相关不可变集合

分享一下我老师大神的人工智能教程！零基础，通俗易懂！[http://blog.csdn.net/jiangjunshow][http_blog.csdn.net_jiangju

一时失言乱红尘/ 2022年04月17日 05:22/ 0 赞/ 246 阅读

相关 Immutable(不可变)集合

转载：[https://www.cnblogs.com/peida/p/Guava\_ImmutableCollections.html][https_www.cnblogs.

客官°小女子只卖身不卖艺/ 2022年04月01日 05:59/ 0 赞/ 220 阅读

相关 Scala中的集合、不可变List、可变ListBuffer、不可变Set、可变HashSet、不可变Map、可变HashMap 08

前言 Scala的集合有三类：序列Seq、Set、映射Map，所有的集合都扩展自Iterable特质，在Scala中集合有可变（mutable）和不可变（immutabl

朴灿烈づ我的快乐病毒、/ 2022年02月04日 12:47/ 0 赞/ 505 阅读

相关不可变类

参考： [https://www.cnblogs.com/acode/articles/7090429.html][https_www.cnblogs.com_acode_

梦里梦外;/ 2022年01月14日 14:47/ 0 赞/ 211 阅读