关于string:常见包装类ListSetHashMap见解

7次阅读

共计 4961 个字符，预计需要花费 13 分钟才能阅读完成。

包装类，就是对根本数据类型的一个包装，赋予一些罕用的办法

比方类型装换等。

int 的包装类，应用 final 润饰类，不可继承。

会主动装箱与主动拆箱。

特地留神：在 -128 到 127 之间, 保护了一个数组（static 初始化，服务器启动就存在。）

比拟值时，如果是这个区间，则默认从数组中拿出值来进行判断。

Integer a = 1;
Integer b = 1;
Integer c = 128;
Integer d = 128;
sout(a == b); // true
sout(c == d); // false

 private static class IntegerCache {
     static final int low = -128;
     static final int high;
     static final Integer cache[];
    
     static {
         // high value may be configured by property
         int h = 127;
         String integerCacheHighPropValue =
         sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
         if (integerCacheHighPropValue != null) {
            try {int i = parseInt(integerCacheHighPropValue);
                 i = Math.max(i, 127);
                 // Maximum array size is Integer.MAX_VALUE
                 h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
            } catch(NumberFormatException nfe) {// If the property cannot be parsed into an int, ignore it.}
         }
         high = h;
        
         cache = new Integer[(high - low) + 1];
         int j = low;
         for(int k = 0; k < cache.length; k++)
         cache[k] = new Integer(j++);
        
         // range [-128, 127] must be interned (JLS7 5.1.7)
         assert IntegerCache.high >= 127;
 }

 private IntegerCache() {}
 } 

 public static Integer valueOf(int i) {if (i >= IntegerCache.low && i <= IntegerCache.high)
     return IntegerCache.cache[i + (-IntegerCache.low)];
     return new Integer(i);
 }

不可变长字符串。

应用 String 字符串拼接时，默认调用 StringBulider 的 append 办法

String str1 = "hello,";
String str2 = "dbc";
String str3 = str1 + str2;
// 理论：String str3 = (new StringBuilder()).append(str1).append(str2).toString();

String: 定长字符串
StringBuilder: 可变长字符串、线性不平安、效率高
StringBuffer：可变长字符串、线性平安、效率低

有序，可反复

底层保护了一个数组

会依据存入数据个数和容量, 来 主动扩容

特点：查问快、增加和删除效率低（和 LinkedList 相比）。

 transient Object[] elementData; // non-private to simplify nested class access
 private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
 private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

 // 带参的一个构造方法
 public ArrayList(int initialCapacity) {if (initialCapacity > 0) {this.elementData = new Object[initialCapacity];
     } else if (initialCapacity == 0) {this.elementData = EMPTY_ELEMENTDATA;} else {
        throw new IllegalArgumentException("Illegal Capacity:"+
     initialCapacity);
     }
 }

 // 增加的一个办法
 public boolean add(E e) {ensureCapacityInternal(size + 1);  // Increments modCount!!
    elementData[size++] = e;
    return true;
 }

 // 扩容相干
 private void ensureCapacityInternal(int minCapacity) {ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
 }

 private void ensureExplicitCapacity(int minCapacity) {
    modCount++;

    // overflow-conscious code
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
    }
 private void grow(int minCapacity) {
    // overflow-conscious code
    int oldCapacity = elementData.length;
    int newCapacity = oldCapacity + (oldCapacity >> 1); // 扩容 1.5 倍
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);
     // minCapacity is usually close to size, so this is a win:
    elementData = Arrays.copyOf(elementData, newCapacity);
 }

底层保护了一个链表

特点：查问慢、增加和删除快（和 ArrayList 相比）。

 // 链表的节点
 private static class Node<E> {
     E item;
     Node<E> next;
     Node<E> prev;
    
     Node(Node<E> prev, E element, Node<E> next) {
         this.item = element;
         this.next = next;
         this.prev = prev;
     }
 }

key-value 型存储格局

key 不可反复

底层是一个 哈希表（数组 + 链表）

key 和 value 能够为 null

HashTable 是线性平安的，效率低，而 HashMap 线性不平安。
HashTable 不允许值 (key 和 value) 为 null，HashMap 的值能够为 null

 /**
 * 默认容量（数组长度）*/
 static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;

 /**
 * 最大容量
 */
 static final int MAXIMUM_CAPACITY = 1 << 30;

 /**
 *  Jdk1.8 后，数组中某个地位的链表长度为 8, 并且总元素个数 >=64, 则将该链表编程红黑树
 *  优化查问效率
 */
 static final int TREEIFY_THRESHOLD = 8;

 /**
 * 最小树化容量 
 * 数组中某个地位的链表长度为 8, 并且总元素个数 >=64, 则将该链表编程红黑树
 * 优化查问效率
 */
 static final int MIN_TREEIFY_CAPACITY = 64;

 /**
 *  当数据个数低于这个数, 将其转换为链表
 */
 static final int UNTREEIFY_THRESHOLD = 6;

 /**
 * 负载因子, 增加元素时，当哈希表中的元素个数为: 数组长度 * 负载因子时，会扩容
 */
 static final float DEFAULT_LOAD_FACTOR = 0.75f;


 /**
 * 根本的哈希 bin 节点
 */
 static class Node<K,V> implements Map.Entry<K,V> {
     final int hash;
     final K key;
     V value;
     Node<K,V> next;
    
     Node(int hash, K key, V value, Node<K,V> next) {
         this.hash = hash;
         this.key = key;
         this.value = value;
         this.next = next;
    }

     public final K getKey()        { return key;}
     public final V getValue()      { return value;}
     public final String toString() { return key + "=" + value;}

    public final int hashCode() {return Objects.hashCode(key) ^ Objects.hashCode(value);
    }

     public final V setValue(V newValue) {
        V oldValue = value;
         value = newValue;
        return oldValue;
     }

    public final boolean equals(Object o) {if (o == this)
         return true;
     if (o instanceof Map.Entry) {Map.Entry<?,?> e = (Map.Entry<?,?>)o;
         if (Objects.equals(key, e.getKey()) &&
            Objects.equals(value, e.getValue()))
             return true;
         }
        return false;
     }
 }

无序、不可反复

底层保护了一个Map

存值时，将增加的值存为 Map 的key, 而 value 就是一个 Object

故要获取值, 只能获取 迭代器 来遍历

底层保护了一个HashMap

存值时，存的为 Map 的key

能够增加 null（HashMap 的 key 能够为 null）

先判断 hashCode
再应用 equals 判断

如果 hashCode 的返回值相等并且 equals 返回 true，则被认为是雷同的元素

 ...
 private transient HashMap<E,Object> map;
 // Dummy value to associate with an Object in the backing Map
 // 要与反对映射中的对象关联的伪值
 private static final Object PRESENT = new Object();
 ...
 
 // 构造方法 
 public HashSet() {map = new HashMap<>();
 }
 ...
 
 // 增加办法 
 public boolean add(E e) {return map.put(e, PRESENT)==null;
 }

HashSet 的子类

双向链表

底层保护了一个TreeMap

存值时，存的为 Map 的key

不能增加 null

 private transient NavigableMap<E,Object> m;

 TreeSet(NavigableMap<E,Object> m) {this.m = m;}

 // 构造方法
 public TreeSet() {this(new TreeMap<E,Object>());
 }

 // 增加办法
 public boolean add(E e) {return m.put(e, PRESENT)==null;
 }

正文完

string

发表至： string

2020-10-22

0

关于string:String类型和基本数据类的转化

关于string:因为这7个C的坑整个团队加班一星期

关于string:前端笔记-字符串

关于string:常见包装类ListSetHashMap见解

关于云服务:腾讯云直播开启互动直播

关于string:常见包装类ListSetHashMap见解

一. Integer 与 String

1.1 Integer

源码局部

1.2 String

String,StringBuilder,StringBuffer 的区别

二. List

2.1 ArrayList

源码

2.2 LinkedList

源码

三. Map

3.1 HashMap

与 HashTable 的区别

源码

四. Set

4.1 HashSet

HashSet 如何判断元素是否反复的？

源码

4.2 LinkedHashSet

4.3 TreeSet

源码

站内搜索