高并发第七弹:不可变对象及常用的工具类

 

不可变类：所谓的不可变类是指这个类的实例一旦创建完成后，就不能改变其成员变量值。如JDK内部自带的很多不可变类：Interger、Long和String等。
可变类：相对于不可变类，可变类创建实例后可以改变其成员变量值，开发中创建的大部分类都属于可变类。

下面的理解可能会易懂一些：

{概念：不可变类的意思是创建该类的实例后，该实例的属性是不可改变的。Java中的8个包装类和String类都是不可变类。所以不可变类并不是指该类是被final修饰的，而是指该类的属性是被final修饰的。

自定义不可变类遵守如下原则：

1. 使用private和final修饰符来修饰该类的属性。

2. 提供带参数的构造器，用于根据传入的参数来初始化属性。

3 .仅为该类属性提供getter方法，不要提供setter方法。

4. 如果有必要，重写hashCode和equals方法，同时应保证两个用equals方法判断为相等的对象，其hashCode也应相等。

5.在get方法中不直接返回对象的本身，而是克隆对象，返回对象的拷贝。

（1）使用Java中提供的Collection类中的各种unmodifiable开头的方法 
（2）使用Guava中的Immutable开头的类

　　......}

 

1.使用private和final修饰符来修饰该类的属性

final关键字可以修饰类、修饰方法、修饰变量

• • 修饰类：类不能被集成。 
    基础类型的包装类都是final类型的类。final类中的成员变量可以根据需要设置为final，但是要注意的是，final类中的所有成员方法都会被隐式的指定为final方法
  • 修饰方法： 
    (1)把方法锁定，以防任何继承类修改它的含义 
    (2)效率：在早期的java实现版本中，会将final方法转为内嵌调用。但是如果方法过于庞大，可能看不见效果。一个private方法会被隐式的指定为final方法
  • 修饰变量： 
    基本数据类型变量，在初始化之后，它的值就不能被修改了。如果是引用类型变量，在它初始化之后便不能再指向另外的对象。 

 来来其他几个都还是好理解  咱们直接上 5 

5.在get方法中不直接返回对象的本身，而是克隆对象，返回对象的拷贝。

如果构造器传入的对象直接赋值给成员变量，还是可以通过对传入对象的修改进而导致改变内部变量的值。

 

public final class ImmutableDemo {  
    private final int[] myArray;  
    public ImmutableDemo(int[] array) {  
        this.myArray = array;   // 错误的
    }  
}

这种方式不能保证不可变性，myArray和array指向同一块内存地址，用户可以在ImmutableDemo之外通过修改array对象的值来改变myArray内部的值。
为了保证内部的值不被修改，可以采用深度copy来创建一个新内存保存传入的值。正确做法：

public final class MyImmutableDemo {  
    private final int[] myArray;  
    public MyImmutableDemo(int[] array) {  
        this.myArray = array.clone();   
    }   

在getter方法中，不要直接返回对象本身，而是克隆对象，并返回对象的拷贝
这种做法也是防止对象外泄，防止通过getter获得内部可变成员对象后对成员变量直接操作，导致成员变量发生改变。

 

常用的方法有

Java:unmodifiable相关方法

public class CollectionDemo {

    public static Map<String, String> map = new HashMap<>();

    static {
        map.put("a", "a");
        map.put("b", "b");
        map.put("c", "c");
        map = Collections.unmodifiableMap(map);
    }

    public static void main(String[] args) {
        // 看着不报错
        map.put("d", "d");
        System.out.println(map.get("d"));
    }

}

Collections重写了基本所有的方法

................
public static <K,V> Map<K,V> unmodifiableMap(Map<? extends K, ? extends V> m) {
        return new UnmodifiableMap<>(m);
    }

    /**
     * @serial include
     */
    private static class UnmodifiableMap<K,V> implements Map<K,V>, Serializable {
        private static final long serialVersionUID = -1034234728574286014L;

        private final Map<? extends K, ? extends V> m;

        UnmodifiableMap(Map<? extends K, ? extends V> m) {
            if (m==null)
                throw new NullPointerException();
            this.m = m;
        }

        public int size()                        {return m.size();}
        public boolean isEmpty()                 {return m.isEmpty();}
        public boolean containsKey(Object key)   {return m.containsKey(key);}
        public boolean containsValue(Object val) {return m.containsValue(val);}
        public V get(Object key)                 {return m.get(key);}

        public V put(K key, V value) {
            throw new UnsupportedOperationException();
        }
        public V remove(Object key) {
            throw new UnsupportedOperationException();
        }
        public void putAll(Map<? extends K, ? extends V> m) {
            throw new UnsupportedOperationException();
        }
        public void clear() {
            throw new UnsupportedOperationException();
        }
...............

对他修改的任何一个方法都会报错

Guava:Immutable相关类

public class GuavaDemo {

    public static ImmutableList<String> list = ImmutableList.of("A", "B");
    
    public static void main(String[] args) {
        list.add("c");
    }
}

 

 

 

 @CanIgnoreReturnValue
  @Deprecated
  @Override
  public final E set(int index, E element) {
    throw new UnsupportedOperationException();
  }

  /**
   * Guaranteed to throw an exception and leave the list unmodified.
   *
   * @throws UnsupportedOperationException always
   * @deprecated Unsupported operation.
   */
  @Deprecated
  @Override
  public final void add(int index, E element) {
    throw new UnsupportedOperationException();
  }

也是把这些课修改的方法都进行了重写

这两个都是我们常用的不可变对象的写法.

转载于:https://www.cnblogs.com/aihuxi/p/9677737.html