a745233700
a745233700

Java集合篇：Hashtable原理详解（JDK1.8）

（本文使用的源码基于JDK1.8的）

 

一、Hashtable的基本方法：

这部分参考博客：https://blog.csdn.net/chenssy/article/details/22896871

1、定义：

HashTable在Java中的定义如下：

public class Hashtable
    extends Dictionary
    implements Map, Cloneable, java.io.Serializable

从中可以看出HashTable继承Dictionary类，实现Map接口。其中Dictionary类是任何可将键映射到相应值的类（如 Hashtable）的抽象父类。每个键和每个值都是一个对象。在任何一个 Dictionary 对象中，每个键至多与一个值相关联。Map是"key-value键值对"接口。

HashTable采用"拉链法"实现哈希表，它定义了几个重要的参数：table、count、threshold、loadFactor、modCount。

table：为一个Entry[]数组类型，Entry代表了“拉链”的节点，每一个Entry代表了一个键值对，哈希表的"key-value键值对"都是存储在Entry数组中的。

 count：HashTable的大小，注意这个大小并不是HashTable的容器大小，而是他所包含Entry键值对的数量。

 threshold：Hashtable的阈值，用于判断是否需要调整Hashtable的容量。threshold的值="容量*加载因子"。

loadFactor：加载因子。

modCount：用来实现“fail-fast”机制的（也就是快速失败）。所谓快速失败就是在并发集合中，其进行迭代操作时，若有其他线程对其进行结构性的修改，这时迭代器会立马感知到，并且立即抛出ConcurrentModificationException异常，而不是等到迭代完成之后才告诉你已经出错了。

2、构造方法：

在HashTabel中存在4个构造函数。通过这4个构造函数我们构建出一个我想要的HashTable。

public Hashtable() {
        this(11, 0.75f);
    }

 默认构造函数，容量为11，加载因子为0.75。

public Hashtable(int initialCapacity) {
        this(initialCapacity, 0.75f);
    }

用指定初始容量和默认的加载因子 (0.75) 构造一个新的空哈希表。

public Hashtable(int initialCapacity, float loadFactor) {
        //验证初始容量
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        //验证加载因子
        if (loadFactor <= 0 || Float.isNaN(loadFactor))
            throw new IllegalArgumentException("Illegal Load: "+loadFactor);
 
        if (initialCapacity==0)
            initialCapacity = 1;
        
        this.loadFactor = loadFactor;
        
        //初始化table，获得大小为initialCapacity的table数组
        table = new Entry[initialCapacity];
        //计算阀值
        threshold = (int)Math.min(initialCapacity * loadFactor, MAX_ARRAY_SIZE + 1);
    }

用指定初始容量和指定加载因子构造一个新的空哈希表。

public Hashtable(Map t) {
        //设置table容器大小，其值==t.size * 2 + 1
        this(Math.max(2*t.size(), 11), 0.75f);
        putAll(t);
    }

构造一个与给定的 Map 具有相同映射关系的新哈希表。

3、主要方法：

 HashTable的API对外提供了许多方法，这些方法能够很好帮助我们操作HashTable，但是这里我只介绍两个最根本的方法：put、get。

（1）首先我们先看put方法：将指定 key 映射到此哈希表中的指定 value。注意这里键key和值value都不可为空。

public synchronized V put(K key, V value) {
        // 确保value不为null
        if (value == null) {
            throw new NullPointerException();
        }
 
        /*
         * 确保key在table[]是不重复的
         * 处理过程：
         * 1、计算key的hash值，确认在table[]中的索引位置
         * 2、迭代index索引位置，如果该位置处的链表中存在一个一样的key，则替换其value，返回旧值
         */
        Entry tab[] = table;
        int hash = hash(key);    //计算key的hash值
        int index = (hash & 0x7FFFFFFF) % tab.length;     //确认该key的索引位置
        //迭代，寻找该key，替换
        for (Entry e = tab[index] ; e != null ; e = e.next) {
            if ((e.hash == hash) && e.key.equals(key)) {
                V old = e.value;
                e.value = value;
                return old;
            }
        }
 
        modCount++;
        if (count >= threshold) {  //如果容器中的元素数量已经达到阀值，则进行扩容操作
            rehash();
            tab = table;
            hash = hash(key);
            index = (hash & 0x7FFFFFFF) % tab.length;
        }
 
        // 在索引位置处插入一个新的节点
        Entry e = tab[index];
        tab[index] = new Entry<>(hash, key, value, e);
        //容器中元素+1
        count++;
        return null;
    }

put方法的整个处理流程是：计算key的hash值，根据hash值获得key在table数组中的索引位置，然后迭代该key处的Entry链表（我们暂且理解为链表），若该链表中存在一个这个的key对象，那么就直接替换其value值即可，否则在将改key-value节点插入该index索引位置处。

Hashtable的扩容操作，在put方法中，如果需要向table[]中添加Entry元素，会首先进行容量校验，如果容量已经达到了阀值，HashTable就会进行扩容处理rehash()，如下:

protected void rehash() {
        int oldCapacity = table.length;
        //元素
        Entry[] oldMap = table;
 
        //新容量=旧容量 * 2 + 1
        int newCapacity = (oldCapacity << 1) + 1;
        if (newCapacity - MAX_ARRAY_SIZE > 0) {
            if (oldCapacity == MAX_ARRAY_SIZE)
                return;
            newCapacity = MAX_ARRAY_SIZE;
        }
        
        //新建一个size = newCapacity 的HashTable
        Entry[] newMap = new Entry[newCapacity];
 
        modCount++;
        //重新计算阀值
        threshold = (int)Math.min(newCapacity * loadFactor, MAX_ARRAY_SIZE + 1);
 
        table = newMap;
        //将原来的元素拷贝到新的HashTable中
        for (int i = oldCapacity ; i-- > 0 ;) {
            for (Entry old = oldMap[i] ; old != null ; ) {
                Entry e = old;
                old = old.next;
 
                int index = (e.hash & 0x7FFFFFFF) % newCapacity;
                e.next = newMap[index];
                newMap[index] = e;
            }
        }
    }

在这个rehash()方法中我们可以看到容量扩大两倍+1，同时需要将原来HashTable中的元素一一复制到新的HashTable中，这个过程是比较消耗时间的，同时还需要重新计算 index 的，毕竟容量已经变了。这里对阀值啰嗦一下：比如初始值11、加载因子默认0.75，那么这个时候阀值threshold=8，当容器中的元素达到8时，HashTable进行一次扩容操作，容量 = 8 * 2 + 1 =17，而阀值threshold=17*0.75 = 13，当容器元素再一次达到阀值时，HashTable还会进行扩容操作，依次类推。

（2）get方法就会比较简单，处理过程就是计算key的hash值，判断在table数组中的索引位置，然后迭代链表，匹配直到找到相对应key的value,若没有找到返回null。

public synchronized V get(Object key) {
        Entry tab[] = table;
        int hash = hash(key);
        int index = (hash & 0x7FFFFFFF) % tab.length;
        for (Entry e = tab[index] ; e != null ; e = e.next) {
            if ((e.hash == hash) && e.key.equals(key)) {
                return e.value;
            }
        }
        return null;
    }

 

二、Hashtable的三种遍历方式：

import java.util.Enumeration;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
 
public class HashTableTest {
	public static void main(String args[]){
		Hashtable table = new Hashtable();
		
		table.put("zhangsan", 22);
		table.put("lisi", 33);
		table.put("wangwu", 44);	
		
		//[1]Iterator遍历方式1--键值对遍历entrySet()
		Iterator> iter = table.entrySet().iterator();
		while(iter.hasNext()){
			Map.Entry entry = (Map.Entry)iter.next();
			String key = entry.getKey();
			int value = entry.getValue();
			System.out.println("entrySet:"+key+" "+value);
		}
		
		System.out.println("====================================");
		
		//[2]Iterator遍历方式2--key键的遍历
		Iterator iterator = table.keySet().iterator();
		while(iterator.hasNext()){
			String key = (String)iterator.next();
			int value = table.get(key);
			System.out.println("keySet:"+key+" "+value);
		}
		
		System.out.println("====================================");
		
		//[3]通过Enumeration来遍历Hashtable
		Enumeration enu = table.keys();
		while(enu.hasMoreElements()) {
		    System.out.println("Enumeration:"+table.keys()+" "+enu.nextElement());
		} 	
	}
}

输出结果：
entrySet:zhangsan 22
entrySet:lisi 33
entrySet:wangwu 44
====================================
keySet:zhangsan 22
keySet:lisi 33
keySet:wangwu 44
====================================
Enumeration:java.util.Hashtable$Enumerator@139a55 zhangsan
Enumeration:java.util.Hashtable$Enumerator@1db9742 lisi
Enumeration:java.util.Hashtable$Enumerator@106d69c wangwu

 

三、Hashtable与HashMap的区别详解：

参考博客：https://blog.csdn.net/wangxing233/article/details/79452946?utm_source=blogxgwz5

1、继承的父类不同：

Hashtable继承的是Dictionary类，HashMap继承的是AbstractMap，但两者都实现了Map接口。

2、是否允许null：

HashMap可以允许存在一个 null 的 key 和任意个 null 的 value，不过建议尽量避免这样使用null作为 key，HashMap以null作为key时，总是存储在table数组的第一个节点上；Hashtable中的 key 和 value 都不允许为 null 。

在HashMap中，当get()方法返回null值时，可能是 HashMap中没有该键，也可能使该键所对应的值为null。因此，在HashMap中不能由get()方法来判断HashMap中是否存在某个键， 而应该用containsKey()方法来判断。

（1）当HashMap遇到为null的key时，它会调用putForNullKey方法来进行处理。对于value没有进行任何处理，只要是对象都可以。

if (key == null)
            return putForNullKey(value);

（2）如果在Hashtable中有类似put(null,null)的操作，编译时可以通过，因为key和value都是Object类型，但运行时会抛出NullPointerException异常。

if (value == null) {
            throw new NullPointerException();
        }

3、Hashtable的方法是线程安全的，底层的每个方法都使用synchronized的），而HashMap的方法多线程不安全。

虽然HashMap不是线程安全的，但是它的效率会比Hashtable要好很多。当需要多线程操作的时候可以使用线程安全的ConcurrentHashMap。ConcurrentHashMap虽然也是线程安全的，但是它的效率比Hashtable要高好多倍。因为ConcurrentHashMap使用了分段锁，并不对整个数据进行锁定。

4、遍历不同：HashMap仅支持Iterator的遍历方式，Hashtable支持Iterator和Enumeration两种遍历方式。

（1）HashMap 的Iterator 使用的是fail-fast 迭代器，当有其他线程改变了 HashMap 的结构（增加、删除、修改元素），将会抛出ConcurrentModificationException。

（2）JDK8之前的版本中，Hashtable是没有fast-fail机制的。在JDK8及以后的版本中 ，HashTable也是使用fast-fail的， 源码如下： 

 if (expectedModCount != modCount) {
     throw new ConcurrentModificationException();
  }

modCount 的使用类似于并发编程中的 CAS( Compare and Swap) 技术，每次在发生增删改操作的时候，都会出现modCount++的动作，而modcount可以理解为是当前hashtable的状态。每发生一次操作，状态+1。设置这个状态，主要是用于hashtable 等容器类在迭代时，判断数据是否过时时使用的。尽管hashtable采用了原生的同步锁来保护数据安全。但是在出现迭代数据的时候，则无法保证边迭代，边正确操作。于是使用这个值来标记状态。一旦在迭代的过程中状态发生了改变，则会快速抛出一个异常，终止迭代行为。

5、是否提供contains方法：

（1）HashMap把Hashtable的contains()方法去掉了，改成containsValue 和 containsKey ，因为contains() 方法容易让人引起误解；

（2）Hashtable则保留了contains，containsValue 和 containsKey 三个方法 ，其中 contains 和 containsValue 功能相同。

6、内部实现使用的数值初始化 和 扩容方式不同：

（1）两者的默认负载因子都是0.75，但Hashtable扩容时，容量变为原来的2倍+1，HashMap扩容时，将容量变成原来的2倍；Hashtable在不制定容量的情况下默认容量是11，也就是说Hashtable会尽量使用素数、奇数，而HashMap 的默认容量 为16，Hashtable不要求底层数组的容量为2的整数次幂，而 HashMap 要求一定为2的整数次幂。

（2） 之所以会有这样的不同，是因为Hashtable和HashMap设计时的侧重点不同。Hashtable的侧重点是哈希的结果更加均匀，使得哈希冲突减少。当哈希表的大小为素数时，简单的取模哈希的结果会更加均匀。而HashMap则更加关注hash的计算效率问题。在取模计算时，如果模数是2的幂，那么我们可以直接使用位运算来得到结果，效率要大大高于做除法。HashMap为了加快hash的速度，将哈希表的大小固定为了2的幂。当然这引入了哈希分布不均匀的问题，所以HashMap为解决这问题，又对hash算法做了一些改动。这从而导致了Hashtable和HashMap的计算hash值的方法不同。

7、hash 值不同：

（1）Hashtable直接使用Object的hashCode()，hashCode是JDK根据对象的地址或者字符串或者数字算出来的int类型的数值，然后再使用去取模运算来获得最终的位置。 这里一般先用 hash & 0x7FFFFFFF 后，再对length取模，&0x7FFFFFFF的目的是为了将负的hash值转化为正值，因为hash值有可能为负数，而 hash & 0x7FFFFFFF 后，只有符号外改变，而后面的位都不变。Hashtable在计算元素的位置时需要进行一次除法运算，而除法运算是比较耗时的。 

 int hash = key.hashCode();
 int index = (hash & 0x7FFFFFFF) % tab.length;

（2）为了提高计算效率，HashMap 将哈希表的大小固定为了2的幂，这样在取模预算时，不需要做除法，只需要做位运算。位运算比除法的效率要高很多。HashMap的效率虽然提高了，但是hash冲突却也增加了。因为它得出的hash值的低位相同的概率比较高，HashMap的效率虽然提高了，但是hash冲突却也增加了。因为它得出的hash值的低位相同的概率比较高。而计算位运算为了解决这个问题，HashMap重新根据hashcode计算hash值后，又对hash值做了一些运算来打散数据。使得取得的位置更加分散，从而减少了hash冲突。当然了，为了高效，HashMap只做了一些简单的位处理。从而不至于把使用2 的幂次方带来的效率提升给抵消掉。

  static final int hash(Object key) {
        int h;
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
    }

 

四、Hashtable 部分源码注释：

这部分摘自博客：https://blog.csdn.net/ns_code/article/details/36191279

package java.util;  
import java.io.*;  
 
public class Hashtable  
    extends Dictionary  
    implements Map, Cloneable, java.io.Serializable {  
 
    // 保存key-value的数组。  
    // Hashtable同样采用单链表解决冲突，每一个Entry本质上是一个单向链表  
    private transient Entry[] table;  
 
    // Hashtable中键值对的数量  
    private transient int count;  
 
    // 阈值，用于判断是否需要调整Hashtable的容量（threshold = 容量*加载因子）  
    private int threshold;  
 
    // 加载因子  
    private float loadFactor;  
 
    // Hashtable被改变的次数，用于fail-fast机制的实现  
    private transient int modCount = 0;  
 
    // 序列版本号  
    private static final long serialVersionUID = 1421746759512286392L;  
 
    // 指定“容量大小”和“加载因子”的构造函数  
    public Hashtable(int initialCapacity, float loadFactor) {  
        if (initialCapacity < 0)  
            throw new IllegalArgumentException("Illegal Capacity: "+  
                                               initialCapacity);  
        if (loadFactor <= 0 || Float.isNaN(loadFactor))  
            throw new IllegalArgumentException("Illegal Load: "+loadFactor);  
 
        if (initialCapacity==0)  
            initialCapacity = 1;  
        this.loadFactor = loadFactor;  
        table = new Entry[initialCapacity];  
        threshold = (int)(initialCapacity * loadFactor);  
    }  
 
    // 指定“容量大小”的构造函数  
    public Hashtable(int initialCapacity) {  
        this(initialCapacity, 0.75f);  
    }  
 
    // 默认构造函数。  
    public Hashtable() {  
        // 默认构造函数，指定的容量大小是11；加载因子是0.75  
        this(11, 0.75f);  
    }  
 
    // 包含“子Map”的构造函数  
    public Hashtable(Map t) {  
        this(Math.max(2*t.size(), 11), 0.75f);  
        // 将“子Map”的全部元素都添加到Hashtable中  
        putAll(t);  
    }  
 
    public synchronized int size() {  
        return count;  
    }  
 
    public synchronized boolean isEmpty() {  
        return count == 0;  
    }  
 
    // 返回“所有key”的枚举对象  
    public synchronized Enumeration keys() {  
        return this.getEnumeration(KEYS);  
    }  
 
    // 返回“所有value”的枚举对象  
    public synchronized Enumeration elements() {  
        return this.getEnumeration(VALUES);  
    }  
 
    // 判断Hashtable是否包含“值(value)”  
    public synchronized boolean contains(Object value) {  
        //注意，Hashtable中的value不能是null，  
        // 若是null的话，抛出异常!  
        if (value == null) {  
            throw new NullPointerException();  
        }  
 
        // 从后向前遍历table数组中的元素(Entry)  
        // 对于每个Entry(单向链表)，逐个遍历，判断节点的值是否等于value  
        Entry tab[] = table;  
        for (int i = tab.length ; i-- > 0 ;) {  
            for (Entry e = tab[i] ; e != null ; e = e.next) {  
                if (e.value.equals(value)) {  
                    return true;  
                }  
            }  
        }  
        return false;  
    }  
 
    public boolean containsValue(Object value) {  
        return contains(value);  
    }  
 
    // 判断Hashtable是否包含key  
    public synchronized boolean containsKey(Object key) {  
        Entry tab[] = table;  
		//计算hash值，直接用key的hashCode代替
        int hash = key.hashCode();    
        // 计算在数组中的索引值 
        int index = (hash & 0x7FFFFFFF) % tab.length;  
        // 找到“key对应的Entry(链表)”，然后在链表中找出“哈希值”和“键值”与key都相等的元素  
        for (Entry e = tab[index] ; e != null ; e = e.next) {  
            if ((e.hash == hash) && e.key.equals(key)) {  
                return true;  
            }  
        }  
        return false;  
    }  
 
    // 返回key对应的value，没有的话返回null  
    public synchronized V get(Object key) {  
        Entry tab[] = table;  
        int hash = key.hashCode();  
        // 计算索引值，  
        int index = (hash & 0x7FFFFFFF) % tab.length;  
        // 找到“key对应的Entry(链表)”，然后在链表中找出“哈希值”和“键值”与key都相等的元素  
        for (Entry e = tab[index] ; e != null ; e = e.next) {  
            if ((e.hash == hash) && e.key.equals(key)) {  
                return e.value;  
            }  
        }  
        return null;  
    }  
 
    // 调整Hashtable的长度，将长度变成原来的2倍+1 
    protected void rehash() {  
        int oldCapacity = table.length;  
        Entry[] oldMap = table;  
 
		//创建新容量大小的Entry数组
        int newCapacity = oldCapacity * 2 + 1;  
        Entry[] newMap = new Entry[newCapacity];  
 
        modCount++;  
        threshold = (int)(newCapacity * loadFactor);  
        table = newMap;  
		
		//将“旧的Hashtable”中的元素复制到“新的Hashtable”中
		for (int i = oldCapacity ; i-- > 0 ;) {  
            for (Entry old = oldMap[i] ; old != null ; ) {  
                Entry e = old;  
                old = old.next;  
				//重新计算index
                int index = (e.hash & 0x7FFFFFFF) % newCapacity;  
                e.next = newMap[index];  
                newMap[index] = e;  
            }  
        }  
    }  
 
    // 将“key-value”添加到Hashtable中  
    public synchronized V put(K key, V value) {  
        // Hashtable中不能插入value为null的元素！！！  
        if (value == null) {  
            throw new NullPointerException();  
        }  
 
        // 若“Hashtable中已存在键为key的键值对”，  
        // 则用“新的value”替换“旧的value”  
        Entry tab[] = table;  
        int hash = key.hashCode();  
        int index = (hash & 0x7FFFFFFF) % tab.length;  
        for (Entry e = tab[index] ; e != null ; e = e.next) {  
            if ((e.hash == hash) && e.key.equals(key)) {  
                V old = e.value;  
                e.value = value;  
                return old;  
                }  
        }  
 
        // 若“Hashtable中不存在键为key的键值对”，
        // 将“修改统计数”+1  
        modCount++;  
        //  若“Hashtable实际容量” > “阈值”(阈值=总的容量 * 加载因子)  
        //  则调整Hashtable的大小  
        if (count >= threshold) {
            rehash();  
 
            tab = table;  
            index = (hash & 0x7FFFFFFF) % tab.length;  
        }  
 
        //将新的key-value对插入到tab[index]处（即链表的头结点）
        Entry e = tab[index];         
        tab[index] = new Entry(hash, key, value, e);  
        count++;  
        return null;  
    }  
 
    // 删除Hashtable中键为key的元素  
    public synchronized V remove(Object key) {  
        Entry tab[] = table;  
        int hash = key.hashCode();  
        int index = (hash & 0x7FFFFFFF) % tab.length;  
		
        //从table[index]链表中找出要删除的节点，并删除该节点。
		//因为是单链表，因此要保留带删节点的前一个节点，才能有效地删除节点
        for (Entry e = tab[index], prev = null ; e != null ; prev = e, e = e.next) {  
            if ((e.hash == hash) && e.key.equals(key)) {  
                modCount++;  
                if (prev != null) {  
                    prev.next = e.next;  
                } else {  
                    tab[index] = e.next;  
                }  
                count--;  
                V oldValue = e.value;  
                e.value = null;  
                return oldValue;  
            }  
        }  
        return null;  
    }  
 
    // 将“Map(t)”的中全部元素逐一添加到Hashtable中  
    public synchronized void putAll(Map t) {  
        for (Map.Entry e : t.entrySet())  
            put(e.getKey(), e.getValue());  
    }  
 
    // 清空Hashtable  
    // 将Hashtable的table数组的值全部设为null  
    public synchronized void clear() {  
        Entry tab[] = table;  
        modCount++;  
        for (int index = tab.length; --index >= 0; )  
            tab[index] = null;  
        count = 0;  
    }  
 
    // 克隆一个Hashtable，并以Object的形式返回。  
    public synchronized Object clone() {  
        try {  
            Hashtable t = (Hashtable) super.clone();  
            t.table = new Entry[table.length];  
            for (int i = table.length ; i-- > 0 ; ) {  
                t.table[i] = (table[i] != null)  
                ? (Entry) table[i].clone() : null;  
            }  
            t.keySet = null;  
            t.entrySet = null;  
            t.values = null;  
            t.modCount = 0;  
            return t;  
        } catch (CloneNotSupportedException e) {   
            throw new InternalError();  
        }  
    }  
 
    public synchronized String toString() {  
        int max = size() - 1;  
        if (max == -1)  
            return "{}";  
 
        StringBuilder sb = new StringBuilder();  
        Iterator> it = entrySet().iterator();  
 
        sb.append('{');  
        for (int i = 0; ; i++) {  
            Map.Entry e = it.next();  
            K key = e.getKey();  
            V value = e.getValue();  
            sb.append(key   == this ? "(this Map)" : key.toString());  
            sb.append('=');  
            sb.append(value == this ? "(this Map)" : value.toString());  
 
            if (i == max)  
                return sb.append('}').toString();  
            sb.append(", ");  
        }  
    }  
 
    // 获取Hashtable的枚举类对象  
    // 若Hashtable的实际大小为0,则返回“空枚举类”对象；  
    // 否则，返回正常的Enumerator的对象。 
    private  Enumeration getEnumeration(int type) {  
    if (count == 0) {  
        return (Enumeration)emptyEnumerator;  
    } else {  
        return new Enumerator(type, false);  
    }  
    }  
 
    // 获取Hashtable的迭代器  
    // 若Hashtable的实际大小为0,则返回“空迭代器”对象；  
    // 否则，返回正常的Enumerator的对象。(Enumerator实现了迭代器和枚举两个接口)  
    private  Iterator getIterator(int type) {  
        if (count == 0) {  
            return (Iterator) emptyIterator;  
        } else {  
            return new Enumerator(type, true);  
        }  
    }  
 
    // Hashtable的“key的集合”。它是一个Set，没有重复元素  
    private transient volatile Set keySet = null;  
    // Hashtable的“key-value的集合”。它是一个Set，没有重复元素  
    private transient volatile Set> entrySet = null;  
    // Hashtable的“key-value的集合”。它是一个Collection，可以有重复元素  
    private transient volatile Collection values = null;  
 
    // 返回一个被synchronizedSet封装后的KeySet对象  
    // synchronizedSet封装的目的是对KeySet的所有方法都添加synchronized，实现多线程同步  
    public Set keySet() {  
        if (keySet == null)  
            keySet = Collections.synchronizedSet(new KeySet(), this);  
        return keySet;  
    }  
 
    // Hashtable的Key的Set集合。  
    // KeySet继承于AbstractSet，所以，KeySet中的元素没有重复的。  
    private class KeySet extends AbstractSet {  
        public Iterator iterator() {  
            return getIterator(KEYS);  
        }  
        public int size() {  
            return count;  
        }  
        public boolean contains(Object o) {  
            return containsKey(o);  
        }  
        public boolean remove(Object o) {  
            return Hashtable.this.remove(o) != null;  
        }  
        public void clear() {  
            Hashtable.this.clear();  
        }  
    }  
 
    // 返回一个被synchronizedSet封装后的EntrySet对象  
    // synchronizedSet封装的目的是对EntrySet的所有方法都添加synchronized，实现多线程同步  
    public Set> entrySet() {  
        if (entrySet==null)  
            entrySet = Collections.synchronizedSet(new EntrySet(), this);  
        return entrySet;  
    }  
 
    // Hashtable的Entry的Set集合。  
    // EntrySet继承于AbstractSet，所以，EntrySet中的元素没有重复的。  
    private class EntrySet extends AbstractSet> {  
        public Iterator> iterator() {  
            return getIterator(ENTRIES);  
        }  
 
        public boolean add(Map.Entry o) {  
            return super.add(o);  
        }  
 
        // 查找EntrySet中是否包含Object(0)  
        // 首先，在table中找到o对应的Entry链表  
        // 然后，查找Entry链表中是否存在Object  
        public boolean contains(Object o) {  
            if (!(o instanceof Map.Entry))  
                return false;  
            Map.Entry entry = (Map.Entry)o;  
            Object key = entry.getKey();  
            Entry[] tab = table;  
            int hash = key.hashCode();  
            int index = (hash & 0x7FFFFFFF) % tab.length;  
 
            for (Entry e = tab[index]; e != null; e = e.next)  
                if (e.hash==hash && e.equals(entry))  
                    return true;  
            return false;  
        }  
 
        // 删除元素Object(0)  
        // 首先，在table中找到o对应的Entry链表
        // 然后，删除链表中的元素Object  
        public boolean remove(Object o) {  
            if (!(o instanceof Map.Entry))  
                return false;  
            Map.Entry entry = (Map.Entry) o;  
            K key = entry.getKey();  
            Entry[] tab = table;  
            int hash = key.hashCode();  
            int index = (hash & 0x7FFFFFFF) % tab.length;  
 
            for (Entry e = tab[index], prev = null; e != null;  
                 prev = e, e = e.next) {  
                if (e.hash==hash && e.equals(entry)) {  
                    modCount++;  
                    if (prev != null)  
                        prev.next = e.next;  
                    else 
                        tab[index] = e.next;  
 
                    count--;  
                    e.value = null;  
                    return true;  
                }  
            }  
            return false;  
        }  
 
        public int size() {  
            return count;  
        }  
 
        public void clear() {  
            Hashtable.this.clear();  
        }  
    }  
 
    // 返回一个被synchronizedCollection封装后的ValueCollection对象  
    // synchronizedCollection封装的目的是对ValueCollection的所有方法都添加synchronized，实现多线程同步  
    public Collection values() {  
    if (values==null)  
        values = Collections.synchronizedCollection(new ValueCollection(),  
                                                        this);  
        return values;  
    }  
 
    // Hashtable的value的Collection集合。  
    // ValueCollection继承于AbstractCollection，所以，ValueCollection中的元素可以重复的。  
    private class ValueCollection extends AbstractCollection {  
        public Iterator iterator() {  
        return getIterator(VALUES);  
        }  
        public int size() {  
            return count;  
        }  
        public boolean contains(Object o) {  
            return containsValue(o);  
        }  
        public void clear() {  
            Hashtable.this.clear();  
        }  
    }  
 
    // 重新equals()函数  
    // 若两个Hashtable的所有key-value键值对都相等，则判断它们两个相等  
    public synchronized boolean equals(Object o) {  
        if (o == this)  
            return true;  
 
        if (!(o instanceof Map))  
            return false;  
        Map t = (Map) o;  
        if (t.size() != size())  
            return false;  
 
        try {  
            // 通过迭代器依次取出当前Hashtable的key-value键值对  
            // 并判断该键值对，存在于Hashtable中。  
            // 若不存在，则立即返回false；否则，遍历完“当前Hashtable”并返回true。  
            Iterator> i = entrySet().iterator();  
            while (i.hasNext()) {  
                Map.Entry e = i.next();  
                K key = e.getKey();  
                V value = e.getValue();  
                if (value == null) {  
                    if (!(t.get(key)==null && t.containsKey(key)))  
                        return false;  
                } else {  
                    if (!value.equals(t.get(key)))  
                        return false;  
                }  
            }  
        } catch (ClassCastException unused)   {  
            return false;  
        } catch (NullPointerException unused) {  
            return false;  
        }  
 
        return true;  
    }  
 
    // 计算Entry的hashCode  
    // 若 Hashtable的实际大小为0 或者 加载因子<0，则返回0。  
    // 否则，返回“Hashtable中的每个Entry的key和value的异或值 的总和”。  
    public synchronized int hashCode() {  
        int h = 0;  
        if (count == 0 || loadFactor < 0)  
            return h;  // Returns zero  
 
        loadFactor = -loadFactor;  // Mark hashCode computation in progress  
        Entry[] tab = table;  
        for (int i = 0; i < tab.length; i++)  
            for (Entry e = tab[i]; e != null; e = e.next)  
                h += e.key.hashCode() ^ e.value.hashCode();  
        loadFactor = -loadFactor;  // Mark hashCode computation complete  
 
        return h;  
    }  
 
    // java.io.Serializable的写入函数  
    // 将Hashtable的“总的容量，实际容量，所有的Entry”都写入到输出流中  
    private synchronized void writeObject(java.io.ObjectOutputStream s)  
        throws IOException  
    {  
        // Write out the length, threshold, loadfactor  
        s.defaultWriteObject();  
 
        // Write out length, count of elements and then the key/value objects  
        s.writeInt(table.length);  
        s.writeInt(count);  
        for (int index = table.length-1; index >= 0; index--) {  
            Entry entry = table[index];  
 
            while (entry != null) {  
            s.writeObject(entry.key);  
            s.writeObject(entry.value);  
            entry = entry.next;  
            }  
        }  
    }  
 
    // java.io.Serializable的读取函数：根据写入方式读出  
    // 将Hashtable的“总的容量，实际容量，所有的Entry”依次读出  
    private void readObject(java.io.ObjectInputStream s)  
         throws IOException, ClassNotFoundException  
    {  
        // Read in the length, threshold, and loadfactor  
        s.defaultReadObject();  
 
        // Read the original length of the array and number of elements  
        int origlength = s.readInt();  
        int elements = s.readInt();  
 
        // Compute new size with a bit of room 5% to grow but  
        // no larger than the original size.  Make the length  
        // odd if it's large enough, this helps distribute the entries.  
        // Guard against the length ending up zero, that's not valid.  
        int length = (int)(elements * loadFactor) + (elements / 20) + 3;  
        if (length > elements && (length & 1) == 0)  
            length--;  
        if (origlength > 0 && length > origlength)  
            length = origlength;  
 
        Entry[] table = new Entry[length];  
        count = 0;  
 
        // Read the number of elements and then all the key/value objects  
        for (; elements > 0; elements--) {  
            K key = (K)s.readObject();  
            V value = (V)s.readObject();  
                // synch could be eliminated for performance  
                reconstitutionPut(table, key, value);  
        }  
        this.table = table;  
    }  
 
    private void reconstitutionPut(Entry[] tab, K key, V value)  
        throws StreamCorruptedException  
    {  
        if (value == null) {  
            throw new java.io.StreamCorruptedException();  
        }  
        // Makes sure the key is not already in the hashtable.  
        // This should not happen in deserialized version.  
        int hash = key.hashCode();  
        int index = (hash & 0x7FFFFFFF) % tab.length;  
        for (Entry e = tab[index] ; e != null ; e = e.next) {  
            if ((e.hash == hash) && e.key.equals(key)) {  
                throw new java.io.StreamCorruptedException();  
            }  
        }  
        // Creates the new entry.  
        Entry e = tab[index];  
        tab[index] = new Entry(hash, key, value, e);  
        count++;  
    }  
 
    // Hashtable的Entry节点，它本质上是一个单向链表。  
    // 也因此，我们才能推断出Hashtable是由拉链法实现的散列表  
    private static class Entry implements Map.Entry {  
        // 哈希值  
        int hash;  
        K key;  
        V value;  
        // 指向的下一个Entry，即链表的下一个节点  
        Entry next;  
 
        // 构造函数  
        protected Entry(int hash, K key, V value, Entry next) {  
            this.hash = hash;  
            this.key = key;  
            this.value = value;  
            this.next = next;  
        }  
 
        protected Object clone() {  
            return new Entry(hash, key, value,  
                  (next==null ? null : (Entry) next.clone()));  
        }  
 
        public K getKey() {  
            return key;  
        }  
 
        public V getValue() {  
            return value;  
        }  
 
        // 设置value。若value是null，则抛出异常。  
        public V setValue(V value) {  
            if (value == null)  
                throw new NullPointerException();  
 
            V oldValue = this.value;  
            this.value = value;  
            return oldValue;  
        }  
 
        // 覆盖equals()方法，判断两个Entry是否相等。  
        // 若两个Entry的key和value都相等，则认为它们相等。  
        public boolean equals(Object o) {  
            if (!(o instanceof Map.Entry))  
                return false;  
            Map.Entry e = (Map.Entry)o;  
 
            return (key==null ? e.getKey()==null : key.equals(e.getKey())) &&  
               (value==null ? e.getValue()==null : value.equals(e.getValue()));  
        }  
 
        public int hashCode() {  
            return hash ^ (value==null ? 0 : value.hashCode());  
        }  
 
        public String toString() {  
            return key.toString()+"="+value.toString();  
        }  
    }  
 
    private static final int KEYS = 0;  
    private static final int VALUES = 1;  
    private static final int ENTRIES = 2;  
 
    // Enumerator的作用是提供了“通过elements()遍历Hashtable的接口” 和 “通过entrySet()遍历Hashtable的接口”。  
    private class Enumerator implements Enumeration, Iterator {  
        // 指向Hashtable的table  
        Entry[] table = Hashtable.this.table;  
        // Hashtable的总的大小  
        int index = table.length;  
        Entry entry = null;  
        Entry lastReturned = null;  
        int type;  
 
        // Enumerator是 “迭代器(Iterator)” 还是 “枚举类(Enumeration)”的标志  
        // iterator为true，表示它是迭代器；否则，是枚举类。  
        boolean iterator;  
 
        // 在将Enumerator当作迭代器使用时会用到，用来实现fail-fast机制。  
        protected int expectedModCount = modCount;  
 
        Enumerator(int type, boolean iterator) {  
            this.type = type;  
            this.iterator = iterator;  
        }  
 
        // 从遍历table的数组的末尾向前查找，直到找到不为null的Entry。  
        public boolean hasMoreElements() {  
            Entry e = entry;  
            int i = index;  
            Entry[] t = table;  
            /* Use locals for faster loop iteration */ 
            while (e == null && i > 0) {  
                e = t[--i];  
            }  
            entry = e;  
            index = i;  
            return e != null;  
        }  
 
        // 获取下一个元素  
        // 注意：从hasMoreElements() 和nextElement() 可以看出“Hashtable的elements()遍历方式”  
        // 首先，从后向前的遍历table数组。table数组的每个节点都是一个单向链表(Entry)。  
        // 然后，依次向后遍历单向链表Entry。  
        public T nextElement() {  
            Entry et = entry;  
            int i = index;  
            Entry[] t = table;  
            /* Use locals for faster loop iteration */ 
            while (et == null && i > 0) {  
                et = t[--i];  
            }  
            entry = et;  
            index = i;  
            if (et != null) {  
                Entry e = lastReturned = entry;  
                entry = e.next;  
                return type == KEYS ? (T)e.key : (type == VALUES ? (T)e.value : (T)e);  
            }  
            throw new NoSuchElementException("Hashtable Enumerator");  
        }  
 
        // 迭代器Iterator的判断是否存在下一个元素  
        // 实际上，它是调用的hasMoreElements()  
        public boolean hasNext() {  
            return hasMoreElements();  
        }  
 
        // 迭代器获取下一个元素  
        // 实际上，它是调用的nextElement()  
        public T next() {  
            if (modCount != expectedModCount)  
                throw new ConcurrentModificationException();  
            return nextElement();  
        }  
 
        // 迭代器的remove()接口。  
        // 首先，它在table数组中找出要删除元素所在的Entry，  
        // 然后，删除单向链表Entry中的元素。  
        public void remove() {  
            if (!iterator)  
                throw new UnsupportedOperationException();  
            if (lastReturned == null)  
                throw new IllegalStateException("Hashtable Enumerator");  
            if (modCount != expectedModCount)  
                throw new ConcurrentModificationException();  
 
            synchronized(Hashtable.this) {  
                Entry[] tab = Hashtable.this.table;  
                int index = (lastReturned.hash & 0x7FFFFFFF) % tab.length;  
 
                for (Entry e = tab[index], prev = null; e != null;  
                     prev = e, e = e.next) {  
                    if (e == lastReturned) {  
                        modCount++;  
                        expectedModCount++;  
                        if (prev == null)  
                            tab[index] = e.next;  
                        else 
                            prev.next = e.next;  
                        count--;  
                        lastReturned = null;  
                        return;  
                    }  
                }  
                throw new ConcurrentModificationException();  
            }  
        }  
    }  
 
 
    private static Enumeration emptyEnumerator = new EmptyEnumerator();  
    private static Iterator emptyIterator = new EmptyIterator();  
 
    // 空枚举类  
    // 当Hashtable的实际大小为0；此时，又要通过Enumeration遍历Hashtable时，返回的是“空枚举类”的对象。  
    private static class EmptyEnumerator implements Enumeration {  
 
        EmptyEnumerator() {  
        }  
 
        // 空枚举类的hasMoreElements() 始终返回false  
        public boolean hasMoreElements() {  
            return false;  
        }  
 
        // 空枚举类的nextElement() 抛出异常  
        public Object nextElement() {  
            throw new NoSuchElementException("Hashtable Enumerator");  
        }  
    }  
 
 
    // 空迭代器  
    // 当Hashtable的实际大小为0；此时，又要通过迭代器遍历Hashtable时，返回的是“空迭代器”的对象。  
    private static class EmptyIterator implements Iterator {  
 
        EmptyIterator() {  
        }  
 
        public boolean hasNext() {  
            return false;  
        }  
 
        public Object next() {  
            throw new NoSuchElementException("Hashtable Iterator");  
        }  
 
        public void remove() {  
            throw new IllegalStateException("Hashtable Iterator");  
        }  
 
    }  
} 
 
  
 
 
  
 
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(Java基础与集合)

        

            

                
    
                    
  • 斤斤计较的婚姻到底有多难？
                        白心之岂必有为

                        
    很多人私聊我会问到在哪个人群当中斤斤计较的人最多？我都会回答他，一般婚姻出现问题的斤斤计较的人士会非常多，以我多年经验，在婚姻落的一塌糊涂的人当中，斤斤计较的人数占比在20～30%以上，也就是说10个婚姻出现问题的斤斤计较的人有2-3个有多不减。在婚姻出问题当中，有大量的心理不平衡的、尖酸刻薄的怨妇。在婚姻中仅斤斤计较有两种类型：第一种是物质上的，另一种是精神上的。在物质与精神上抠门已经严重的影响
    
                    
    • 
                    
  • QQ群采集助手，精准引流必备神器
                        2401_87347160
其他经验分享
                        
    功能概述微信群查找与筛选工具是一款专为微信用户设计的辅助工具，它通过关键词搜索功能，帮助用户快速找到相关的微信群，并提供筛选是否需要验证的群组的功能。主要功能关键词搜索：用户可以输入关键词，工具将自动查找包含该关键词的微信群。筛选功能：工具提供筛选机制，用户可以选择是否只显示需要验证或不需要验证的群组。精准引流：通过上述功能，用户可以更精准地找到目标群组，进行有效的引流操作。3.设备需求该工具可以
    
                    
    • 
                    
  • 机器学习与深度学习间关系与区别
                        ℒℴѵℯ心·动ꦿ໊ོ꫞
人工智能学习深度学习python
                        
    一、机器学习概述定义机器学习（MachineLearning,ML）是一种通过数据驱动的方法，利用统计学和计算算法来训练模型，使计算机能够从数据中学习并自动进行预测或决策。机器学习通过分析大量数据样本，识别其中的模式和规律，从而对新的数据进行判断。其核心在于通过训练过程，让模型不断优化和提升其预测准确性。主要类型1.监督学习（SupervisedLearning）监督学习是指在训练数据集中包含输入
    
                    
    • 
                    
  • 随笔 | 仙一般的灵气
                        海思沧海

                        
    仙岛今天，我看了你全部，似乎已经进入你的世界我不知道，这是否是梦幻，还是你仙一般的灵气吸引了我也许每一个人都要有一份属于自己的追求，这样才能够符合人生的梦想，生活才能够充满着阳光与快乐我不知道，我为什么会这样的感叹，是在感叹自己的人生，还是感叹自己一直没有孜孜不倦的追求只感觉虚度了光阴，每天活在自己的梦中，活在一个不真实的世界是在逃避自己，还是在逃避周围的一切有时候我嘲笑自己，嘲笑自己如此的虚无，
    
                    
    • 
                    
  • 一百九十四章. 自相矛盾
                        巨木擎天

                        
    唉！就这么一夜，林子感觉就像过了很多天似的，先是回了阳间家里，遇到了那么多不可思议的事情儿。特别是小伙伴们，第二次与自己见面时，僵硬的表情和恐怖的气氛，让自己如坐针毡，打从心眼里难受！还有东子，他现在还好吗？有没有被人欺负？护城河里的小鱼小虾们，还都在吗？水不会真的干枯了吧？那对相亲相爱漂亮的太平鸟儿，还好吧！春天了，到了做窝、下蛋、喂养小鸟宝宝的时候了，希望它们都能够平安啊！虽然没有看见家人，也
    
                    
    • 
                    
  • UI学习——cell的复用和自定义cell
                        Magnetic_h
ui学习
                        
    目录cell的复用手动（非注册）自动（注册）自定义cellcell的复用在iOS开发中，单元格复用是一种提高表格（UITableView）和集合视图（UICollectionView）滚动性能的技术。当一个UITableViewCell或UICollectionViewCell首次需要显示时，如果没有可复用的单元格，则视图会创建一个新的单元格。一旦这个单元格滚动出屏幕，它就不会被销毁。相反，它被添
    
                    
    • 
                    
  • 微服务下功能权限与数据权限的设计与实现
                        nbsaas-boot
微服务java架构
                        
    在微服务架构下，系统的功能权限和数据权限控制显得尤为重要。随着系统规模的扩大和微服务数量的增加，如何保证不同用户和服务之间的访问权限准确、细粒度地控制，成为设计安全策略的关键。本文将讨论如何在微服务体系中设计和实现功能权限与数据权限控制。1.功能权限与数据权限的定义功能权限：指用户或系统角色对特定功能的访问权限。通常是某个用户角色能否执行某个操作，比如查看订单、创建订单、修改用户资料等。数据权限：
    
                    
    • 
                    
  • 学点心理知识，呵护孩子健康
                        静候花开_7090

                        
    昨天听了华中师范大学教育管理学系副教授张玲老师的《哪里才是学生心理健康的最后庇护所，超越教育与技术的思考》的讲座。今天又重新学习了一遍，收获匪浅。张玲博士也注意到了当今社会上的孩子由于心理问题导致的自残、自杀及伤害他人等恶性事件。她向我们普及了一个重要的命题，她说心理健康的一些基本命题，我们与我们通常的一些教育命题是不同的，她还举了几个例子，让我们明白我们原来以为的健康并非心理学上的健康。比如如果
    
                    
    • 
                    
  • 《投行人生》读书笔记
                        小蘑菇的树洞

                        
    《投行人生》----作者詹姆斯-A-朗德摩根斯坦利副主席40年的职业洞见-很短小精悍的篇幅，比较适合初入职场的新人。第一部分成功的职业生涯需要规划1.情商归为适应能力分享与协作同理心适应能力，更多的是自我意识，你有能力识别自己的情并分辨这些情绪如何影响你的思想和行为。2.对于初入职场的人的建议，细节，截止日期和数据很重要截止日期，一种有效的方法是请老板为你所有的任务进行优先级排序。和老板喝咖啡的好
    
                    
    • 
                    
  • Long类型前后端数据不一致
                        igotyback
前端
                        
    响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
    
                    
    • 
                    
  • 店群合一模式下的社区团购新发展——结合链动 2+1 模式、AI 智能名片与 S2B2C 商城小程序源码
                        说私域
人工智能小程序
                        
    摘要：本文探讨了店群合一的社区团购平台在当今商业环境中的重要性和优势。通过分析店群合一模式如何将互联网社群与线下终端紧密结合，阐述了链动2+1模式、AI智能名片和S2B2C商城小程序源码在这一模式中的应用价值。这些创新元素的结合为社区团购带来了新的机遇，提升了用户信任感、拓展了营销渠道，并实现了线上线下的完美融合。一、引言随着互联网技术的不断发展，社区团购作为一种新兴的商业模式，在满足消费者日常需
    
                    
    • 
                    
  • 2021-08-26
                        影幽

                        
    在生活中，女人与男人的感悟往往有所不同。人生最大的舞台就是生活，大幕随时都可能拉开，关键是你愿不愿意表演都无法躲避。在生活中，遇事不要急躁，不要急于下结论，尤其生气时不要做决断，要学会换位思考，大事化小小事化了，把复杂的事情尽量简单处理，千万不要把简单的事情复杂化。永远不要扭曲，别人善意，无药可救。昨天是张过期的支票，明天是张信用卡，只有今天才是现金，要善加利用！执着的攀登者不必去与别人比较自己的
    
                    
    • 
                    
  • 高级编程--XML+socket练习题
                        masa010
java开发语言
                        
    1.北京华北2114.8万人上海华东2,500万人广州华南1292.68万人成都华西1417万人（1）使用dom4j将信息存入xml中（2）读取信息，并打印控制台（3）添加一个city节点与子节点（4）使用socketTCP协议编写服务端与客户端，客户端输入城市ID，服务器响应相应城市信息（5）使用socketTCP协议编写服务端与客户端，客户端要求用户输入city对象，服务端接收并使用dom4j
    
                    
    • 
                    
  • 2018-07-23-催眠日作业-#不一样的31天#-66小鹿
                        小鹿_33

                        
    预言日：人总是在逃避命运的路上，与之不期而遇。心理学上有个著名的名词，叫做自证预言；经济学上也有一个很著名的定律叫做，墨菲定律；在灵修派上，还有一个很著名的法则，叫做吸引力法则。这3个领域的词，虽然看起来不太一样，但是他们都在告诉人们一个现象：你越担心什么，就越有可能会发生什么。同样的道理，你越想得到什么，就应该要积极地去创造什么。无论是自证预言，墨菲定律还是吸引力法则，对人都有正反2个维度的影响
    
                    
    • 
                    
  • 回溯 Leetcode 332 重新安排行程
                        mmaerd
Leetcode刷题学习记录leetcode算法职场和发展
                        
    重新安排行程Leetcode332学习记录自代码随想录给你一份航线列表tickets，其中tickets[i]=[fromi,toi]表示飞机出发和降落的机场地点。请你对该行程进行重新规划排序。所有这些机票都属于一个从JFK（肯尼迪国际机场）出发的先生，所以该行程必须从JFK开始。如果存在多种有效的行程，请你按字典排序返回最小的行程组合。例如，行程[“JFK”,“LGA”]与[“JFK”,“LGB
    
                    
    • 
                    
  • 每日一题——第九十题
                        互联网打工人no1
C语言程序设计每日一练c语言
                        
    题目：判断子串是否与主串匹配#include#include#include//////判断子串是否在主串中匹配//////主串///子串///boolisSubstring(constchar*str,constchar*substr){intlenstr=strlen(str);//计算主串的长度intlenSub=strlen(substr);//计算子串的长度//遍历主字符串，对每个可能得
    
                    
    • 
                    
  • Python数据分析与可视化实战指南
                        William数据分析
pythonpython数据
                        
    在数据驱动的时代，Python因其简洁的语法、强大的库生态系统以及活跃的社区，成为了数据分析与可视化的首选语言。本文将通过一个详细的案例，带领大家学习如何使用Python进行数据分析，并通过可视化来直观呈现分析结果。一、环境准备1.1安装必要库在开始数据分析和可视化之前，我们需要安装一些常用的库。主要包括pandas、numpy、matplotlib和seaborn等。这些库分别用于数据处理、数学
    
                    
    • 
                    
  • 《庄子.达生9》
                        钱江潮369

                        
    【原文】孔子观于吕梁，县水三十仞，流沫四十里，鼋鼍鱼鳖之所不能游也。见一丈夫游之，以为有苦而欲死也，使弟子并流而拯之。数百步而出，被发行歌而游于塘下。孔子从而问焉，曰：“吾以子为鬼，察子则人也。请问，‘蹈水有道乎’”曰：“亡，吾无道。吾始乎故，长乎性，成乎命。与齐俱入，与汩偕出，从水之道而不为私焉。此吾所以蹈之也。”孔子曰：“何谓始乎故，长乎性，成乎命？”曰：“吾生于陵而安于陵，故也；长于水而安于
    
                    
    • 
                    
  • 水泥质量纠纷案代理词
                        徐宝峰律师

                        
    贵州领航建设有限公司诉贵州纳雍隆庆乌江水泥有限公司产品质量纠纷案代理词尊敬的审判长、审判员：贵州千里律师事务所接受被告贵州纳雍隆庆乌江水泥有限公司的委托，指派我担任其诉讼代理人，参加本案的诉讼活动。下面，我结合本案事实和相关法律规定发表如下代理意见，供合议庭评议案件时参考：原告应当举证证明其遭受的损失与被告生产的水泥质量的因果关系。首先水泥是一种粉状水硬性无机胶凝材料。加水搅拌后成浆体，能在空气中
    
                    
    • 
                    
  • Goolge earth studio 进阶4——路径修改与平滑
                        陟彼高冈yu
Googleearthstudio进阶教程旅游
                        
    如果我们希望在大约中途时获得更多的城市鸟瞰视角。可以将相机拖动到这里并创建一个新的关键帧。camera_target_clip_7EarthStudio会自动平滑我们的路径，所以当我们通过这个关键帧时，不是一个生硬的角度，而是一个平滑的曲线。camera_target_clip_8路径上有贝塞尔控制手柄，允许我们调整路径的形状。右键单击，我们可以选择“平滑路径”，这是默认的自动平滑算法，或者我们可
    
                    
    • 
                    
  • 18-115 一切思考不能有效转化为行动，都TM是扯淡！
                        成长时间线

                        
    7月25号写了一篇关于为什么会断更如此严重的反思，然而，之后日更仅仅维持了一周，又出现了这次更严重的现象。从8月2号到昨天8月6号，5天！又是5天没有更文！虽然这次断更时间和上次一样，那为什么说这次更严重？因为上次之后就分析了问题的原因，以及应该如何解决，按理说应该会好转，然而，没过几天严重断更的现象再次出现，想想，经过反思，问题依然没有解决与改变，这让我有些担忧。到底是哪里出了问题，难道我就真的
    
                    
    • 
                    
  • 山东大学小树林支教调研团青青仓木队——翟晓楠
                        山东大学青青仓木队

                        
    过了半年，又一次启程，又一次回到支教的初心之地。比起上一次的试探与不安，我更多了一丝稳重与熟练。心境、处境也都随着半个学期的过去而变得不同，半个学期中，身体上的，心理上的，太多的逆境让我变得步履维艰，曲曲折折，弯弯绕绕，我仿佛打不起精神，没有胃口，没有动力。感觉走的不顺畅的时候，支教这个旅程，给了我力量。自告奋勇承担起队长这一职务的我，从组织时的复杂和困难的经历，协调各种问题，从无到有，和校长和队
    
                    
    • 
                    
  • 直返最高等级与直返APP：无需邀请码的返利新体验
                        古楼

                        
    随着互联网的普及和电商的兴起，直返模式逐渐成为一种流行的商业模式。在这种模式下，消费者通过购买产品或服务，获得一定的返利，并可以分享给更多的人。其中，直返最高等级和直返APP是直返模式中的重要概念和工具。本文将详细介绍直返最高等级的概念、直返APP的使用以及与邀请码的关系。【高省】APP（高佣金领导者）是一个自用省钱佣金高，分享推广赚钱多的平台，百度有几百万篇报道，运行三年，稳定可靠。高省APP，
    
                    
    • 
                    
  • DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理
                        STU学生网页设计
网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业
                        
    ️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
    
                    
    • 
                    
  • 2020-04-12每天三百字之连接与替代
                        冷眼看潮

                        
    不知道是不是好为人师，有时候还真想和别人分享一下我对某些现象的看法或者解释。人类社会不断发展进步的过程，就是不断连接与替代的过程。人类发现了火并应用火以后，告别了茹毛饮血的野兽般的原始生活（火烧、烹饪替代了生食）人类用石器代替了完全手工，工具的使用使人类进步一大步。类似这样的替代还有很多，随着科技的发展，有更多的原始的事物被替代，代之以更高效、更先进的技术。在近现代，汽车替代了马车，高速公路和铁路
    
                    
    • 
                    
  • 探索OpenAI和LangChain的适配器集成：轻松切换模型提供商
                        nseejrukjhad
langchaineasyui前端python
                        
    #探索OpenAI和LangChain的适配器集成：轻松切换模型提供商##引言在人工智能和自然语言处理的世界中，OpenAI的模型提供了强大的能力。然而，随着技术的发展，许多人开始探索其他模型以满足特定需求。LangChain作为一个强大的工具，集成了多种模型提供商，通过提供适配器，简化了不同模型之间的转换。本篇文章将介绍如何使用LangChain的适配器与OpenAI集成，以便轻松切换模型提供商
    
                    
    • 
                    
  • 利用Requests Toolkit轻松完成HTTP请求
                        nseejrukjhad
http网络协议网络python
                        
    RequestsToolkit的力量：轻松构建HTTP请求Agent在现代软件开发中，API请求是与外部服务交互的核心。RequestsToolkit提供了一种便捷的方式，帮助开发者构建自动化的HTTP请求Agent。本文旨在详细介绍RequestsToolkit的设置、使用和潜在挑战。引言RequestsToolkit是一个强大的工具包，可用于构建执行HTTP请求的智能代理。这对于想要自动化与外
    
                    
    • 
                    
  • 数组去重
                        好奇的猫猫猫

                        
    整理自js中基础数据结构数组去重问题思考？如何去除数组中重复的项例如数组：[1,3,4,3,5]我们在做去重的时候，一开始想到的肯定是，逐个比较，外面一层循环，内层后一个与前一个一比较，如果是久不将当前这一项放进新的数组，挨个比较完之后返回一个新的去过重复的数组不好的实践方式上述方法效率极低，代码量还多，思考？有没有更好的方法这时候不禁一想当然有了！！！hashtable啊，通过对象的hash办法
    
                    
    • 
                    
  • 春季养肝正当时
                        dxn悟

                        
    重温快乐2023年2月4日立春。春天来了，春暖花开，小鸟欢唱，那在这样的季节我们如何养肝呢？自然界的春季对应中医五行的木，人体五脏肝属木，“木曰曲直”，是以树干曲曲直直地向上、向外伸长舒展的生发姿态，来形容具有生长、升发、条达、舒畅等特征的食物及现象。根据中医天人相应的理念，肝五行属木，喜条达，主疏泄，与春天相应，所以春天最适合养肝。养肝首先要少生气，因为肝喜条达恶抑郁。人体五志肝为怒，生气发怒最
    
                    
    • 
                    
  • 关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript
                        二挡起步
web前端期末大作业javascripthtmlcss旅游风景
                        
    ⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
    
                    
    • 
                                
  • PHP，安卓，UI，java，linux视频教程合集
                                    cocos2d-x小菜
javaUIPHPandroidlinux
                                    
    ╔-----------------------------------╗┆                           
    
                                
    • 
                                
  • 各表中的列名必须唯一。在表 'dbo.XXX' 中多次指定了列名 'XXX'。
                                    bozch
.net.net mvc
                                    
    在.net mvc5中，在执行某一操作的时候，出现了如下错误： 
      各表中的列名必须唯一。在表 'dbo.XXX' 中多次指定了列名 'XXX'。 
经查询当前的操作与错误内容无关，经过对错误信息的排查发现，事故出现在数据库迁移上。 
回想过去： 在迁移之前已经对数据库进行了添加字段操作，再次进行迁移插入XXX字段的时候，就会提示如上错误。  
&
    
                                
    • 
                                
  • Java 对象大小的计算
                                    e200702084
java
                                    
                              Java对象的大小 
 
如何计算一个对象的大小呢？ 
 
 
   
    
                                
    • 
                                
  • Mybatis Spring
                                    171815164
mybatis
                                    
    ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
CustomerService userService = (CustomerService) ac.getBean("customerService");
Customer cust
    
                                
    • 
                                
  • JVM 不稳定参数
                                    g21121
jvm
                                    
            -XX 参数被称为不稳定参数，之所以这么叫是因为此类参数的设置很容易引起JVM 性能上的差异，使JVM 存在极大的不稳定性。当然这是在非合理设置的前提下，如果此类参数设置合理讲大大提高JVM 的性能及稳定性。        可以说“不稳定参数”
    
                                
    • 
                                
  • 用户自动登录网站
                                    永夜-极光
用户
                                    
    1.目标:实现用户登录后,再次登录就自动登录,无需用户名和密码 
2.思路:将用户的信息保存为cookie 
           每次用户访问网站,通过filter拦截所有请求,在filter中读取所有的cookie,如果找到了保存登录信息的cookie,那么在cookie中读取登录信息,然后直接
    
                                
    • 
                                
  • centos7 安装后失去win7的引导记录
                                    程序员是怎么炼成的
操作系统
                                    
    1.使用root身份(必须)打开 /boot/grub2/grub.cfg 2.找到 ### BEGIN /etc/grub.d/30_os-prober ###   在后面添加    menuentry "Windows 7 (loader) (on /dev/sda1)" { 
    
                                
    • 
                                
  • Oracle 10g 官方中文安装帮助文档以及Oracle官方中文教程文档下载
                                    aijuans
oracle
                                    
    Oracle 10g 官方中文安装帮助文档下载：http://download.csdn.net/tag/Oracle%E4%B8%AD%E6%96%87API%EF%BC%8COracle%E4%B8%AD%E6%96%87%E6%96%87%E6%A1%A3%EF%BC%8Coracle%E5%AD%A6%E4%B9%A0%E6%96%87%E6%A1%A3 Oracle 10g 官方中文教程
    
                                
    • 
                                
  • JavaEE开源快速开发平台G4Studio_V3.2发布了
                                    無為子
AOPoraclemysqljavaeeG4Studio
                                    
      
我非常高兴地宣布,今天我们最新的JavaEE开源快速开发平台G4Studio_V3.2版本已经正式发布。大家可以通过如下地址下载。 
  
访问G4Studio网站  
http://www.g4it.org      
G4Studio_V3.2版本变更日志 
功能新增 
(1).新增了系统右下角滑出提示窗口功能。 
(2).新增了文件资源的Zip压缩和解压缩
    
                                
    • 
                                
  • Oracle常用的单行函数应用技巧总结
                                    百合不是茶
日期函数转换函数(核心)数字函数通用函数(核心)字符函数
                                    
    单行函数;   字符函数,数字函数,日期函数,转换函数(核心),通用函数(核心) 
一:字符函数: 
   .UPPER(字符串) 将字符串转为大写
   .LOWER (字符串) 将字符串转为小写 
   .INITCAP(字符串) 将首字母大写
   .LENGTH (字符串) 字符串的长度
   .REPLACE(字符串,'A','_') 将字符串字符A转换成_

    
                                
    • 
                                
  • Mockito异常测试实例
                                    bijian1013
java单元测试mockito
                                    
    Mockito异常测试实例： 
package com.bijian.study;

import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;

import org.junit.Assert;
import org.junit.Test;

import org.mockito.
    
                                
    • 
                                
  • GA与量子恒道统计
                                    Bill_chen
JavaScript浏览器百度Google防火墙
                                    
    前一阵子，统计**网址时，Google Analytics（GA） 和量子恒道统计（也称量子统计），数据有较大的偏差，仔细找相关资料研究了下，总结如下： 
  
为何GA和量子网站统计（量子统计前身为雅虎统计）结果不同？ 
首先：没有一种网站统计工具能保证百分之百的准确出现该问题可能有以下几个原因：（1）不同的统计分析系统的算法机制不同；（2）统计代码放置的位置和前后
    
                                
    • 
                                
  • 【Linux命令三】Top命令
                                    bit1129
linux命令
                                    
    Linux的Top命令类似于Windows的任务管理器，可以查看当前系统的运行情况，包括CPU、内存的使用情况等。如下是一个Top命令的执行结果： 
  
  
top - 21:22:04 up 1 day, 23:49, 1 user, load average: 1.10, 1.66, 1.99
Tasks: 202 total,   4 running, 198 sl
    
                                
    • 
                                
  • spring四种依赖注入方式
                                    白糖_
spring
                                    
       平常的java开发中，程序员在某个类中需要依赖其它类的方法，则通常是new一个依赖类再调用类实例的方法，这种开发存在的问题是new的类实例不好统一管理，spring提出了依赖注入的思想，即依赖类不由程序员实例化，而是通过spring容器帮我们new指定实例并且将实例注入到需要该对象的类中。依赖注入的另一种说法是“控制反转”，通俗的理解是：平常我们new一个实例，这个实例的控制权是我
    
                                
    • 
                                
  • angular.injector
                                    boyitech
AngularJSAngularJS API
                                    
    angular.injector 
   描述:   创建一个injector对象, 调用injector对象的方法可以获得angular的service, 或者用来做依赖注入.        使用方法:   angular.injector(modules, [strictDi])        参数详解:      Param Type Details   mod
    
                                
    • 
                                
  • java-同步访问一个数组Integer[10]，生产者不断地往数组放入整数1000，数组满时等待；消费者不断地将数组里面的数置零，数组空时等待
                                    bylijinnan
Integer
                                    
    

public class PC {

	/**
	 * 题目：生产者-消费者。
	 * 同步访问一个数组Integer[10]，生产者不断地往数组放入整数1000，数组满时等待；消费者不断地将数组里面的数置零，数组空时等待。
	 */
	
	private static final Integer[] val=new Integer[10];
	private static
    
                                
    • 
                                
  • 使用Struts2.2.1配置
                                    Chen.H
apachespringWebxmlstruts
                                    
    Struts2.2.1 需要如下 jar包: commons-fileupload-1.2.1.jar commons-io-1.3.2.jar commons-logging-1.0.4.jar freemarker-2.3.16.jar javassist-3.7.ga.jar ognl-3.0.jar spring.jar 
struts2-core-2.2.1.jar struts2-sp
    
                                
    • 
                                
  • [职业与教育]青春之歌
                                    comsci
教育
                                    
     
 
       每个人都有自己的青春之歌............但是我要说的却不是青春... 
 
       大家如果在自己的职业生涯没有给自己以后创业留一点点机会,仅仅凭学历和人脉关系,是难以在竞争激烈的市场中生存下去的.... 
 
  &nbs
    
                                
    • 
                                
  • oracle连接(join)中使用using关键字
                                    daizj
JOINoraclesqlusing
                                    
    在oracle连接(join)中使用using关键字 
34. View the Exhibit and examine the structure of the ORDERS and ORDER_ITEMS tables. 
Evaluate the following SQL statement: 
SELECT oi.order_id, product_id, order_date 
FRO
    
                                
    • 
                                
  • NIO示例
                                    daysinsun
nio
                                    
    NIO服务端代码： 
 

public class NIOServer {
	
	private Selector selector;

	
	public void startServer(int port) throws IOException {

		ServerSocketChannel serverChannel = ServerSocketChannel.open(
    
                                
    • 
                                
  • C语言学习homework1
                                    dcj3sjt126com
chomework
                                    
    0、 课堂练习做完 
1、使用sizeof计算出你所知道的所有的类型占用的空间。 
int x; 
sizeof(x); 
  
sizeof(int); 
  
# include <stdio.h>

int main(void)
{
	int x1;
	char x2;
	double x3;
	float x4;

	printf(&quo
    
                                
    • 
                                
  • select in order by , mysql排序
                                    dcj3sjt126com
mysql
                                    
    If i select like this: 
SELECT id FROM users WHERE id IN(3,4,8,1); 
This by default will select users in this order 
1,3,4,8, 
I would like to select them in the same order that i put IN() values so: 
    
                                
    • 
                                
  • 页面校验-新建项目
                                    fanxiaolong
页面校验
                                    
    $(document).ready(
	function() {
			var flag = true;
		$('#changeform').submit(function() {
			var projectScValNull = true;
			var s ="";
			var parent_id = $("#parent_id").v
    
                                
    • 
                                
  • Ehcache（02）——ehcache.xml简介
                                    234390216
ehcacheehcache.xml简介
                                    
    ehcache.xml简介 
  
       ehcache.xml文件是用来定义Ehcache的配置信息的，更准确的来说它是定义CacheManager的配置信息的。根据之前我们在《Ehcache简介》一文中对CacheManager的介绍我们知道一切Ehcache的应用都是从CacheManager开始的。在不指定配置信
    
                                
    • 
                                
  • junit 4.11中三个新功能
                                    jackyrong
java
                                    
    junit 4.11中两个新增的功能，首先是注解中可以参数化，比如 
 
 


import static org.junit.Assert.assertEquals;
 
import java.util.Arrays;
 
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runn
    
                                
    • 
                                
  • 国外程序员爱用苹果Mac电脑的10大理由
                                    php教程分享
windowsPHPunixMicrosoftperl
                                    
    Mac 在国外很受欢迎，尤其是在 设计/web开发/IT 人员圈子里。普通用户喜欢 Mac 可以理解，毕竟 Mac 设计美观，简单好用，没有病毒。那么为什么专业人士也对 Mac 情有独钟呢？从个人使用经验来看我想有下面几个原因： 
1、Mac OS X 是基于 Unix 的 
这一点太重要了，尤其是对开发人员，至少对于我来说很重要，这意味着Unix 下一堆好用的工具都可以随手捡到。如果你是个 wi
    
                                
    • 
                                
  • 位运算、异或的实际应用
                                    wenjinglian
位运算
                                    
    一． 位操作基础，用一张表描述位操作符的应用规则并详细解释。 
      二． 常用位操作小技巧，有判断奇偶、交换两数、变换符号、求绝对值。 
      三． 位操作与空间压缩，针对筛素数进行空间压缩。 
   &n
    
                                
    • 
                                
  • weblogic部署项目出现的一些问题（持续补充中……）
                                    Everyday都不同
weblogic部署失败
                                    
    好吧，weblogic的问题确实…… 
  
问题一： 
org.springframework.beans.factory.BeanDefinitionStoreException: Failed to read candidate component class: URL [zip:E:/weblogic/user_projects/domains/base_domain/serve
    
                                
    • 
                                
  • tomcat7性能调优（01）
                                    toknowme
tomcat7
                                    
      
    
Tomcat优化：   1、最大连接数最大线程等设置    
<Connector port="8082" protocol="HTTP/1.1" 
               useBodyEncodingForURI="t
    
                                
    • 
                                
  • PO VO DAO DTO BO TO概念与区别
                                    xp9802
javaDAO设计模式bean领域模型
                                    
    O/R Mapping 是 Object Relational Mapping（对象关系映射）的缩写。通俗点讲，就是将对象与关系数据库绑定，用对象来表示关系数据。在O/R Mapping的世界里，有两个基本的也是重要的东东需要了解，即VO，PO。 
它们的关系应该是相互独立的，一个VO可以只是PO的部分，也可以是多个PO构成，同样也可以等同于一个PO（指的是他们的属性）。这样，PO独立出来，数据持
    
                                
    •