hash

首先，每隔一段时间要对经常用到的表进行统计分析（analyze table），让oracle分析出最合适的执行计划； 如果要一直监控sql的执行计划，可以使用trace工具，这个是对session级运行的， exec dbms_system.set_sql_trace_in_session(SID,SERIAL#,t

嵌套循环（Nested Loops （NL））假如有A、B两张表进行嵌套循环连接，那么Oracle会首先从A表中提取一条记录，然后去B表中查找相应的匹配记录，如果有的话，就把该条记录的信息推到等待返回的结果集中，然后再去从A表中提取第二条记录，去在B表中找第二条匹配的记录，如果符合就推到返回的结果集中，依次类推，直到A表中的数据全部被处理完成，将结果集返回，就完成了嵌套循环连接的操作。（散列）哈希连接（Hash Join （HJ））假如有A、B两张表进行哈希连接，那么ORACLE会首先将B表在内存中建立一棵以散列表形式存在的查询二叉树C，然后开始读取A表的第一条记录，从C中去找匹配的记录，如果有，则推到结果集中。再提取A中的第二条记录，如果有，则推到结果集中，以此类推，直到A中没有记录，返回结果集。（归并）排序合并连接(Sort Merge Join (SMJ) )假如有A、B两张表进行排序合并连接，ORACLE会首先将A表进行排序，形成一张临时的“表”C，然后将B进行排序，形成一张临时的“表”D，然后将C与D进行合并操作，返回结果集。如果从预获取的数据量的角度而言，如果B表参与计算的数据量比较小的话，则嵌套循环连接的效率就是比较高的，因为可以很少的IO就可以获取到最终的结果集。但是如果数据量比较大的话，hash join和sort merge join是比较有优势的。如果从索引的角度而言，索引可以提高nested loops的效率，因为从B表获取数据进行操作，就类似于从单表中查询数据一样，table access full和by index的效率肯定是不一样的，但是这个也取决于B的参与计算的数据量，如果B表的数据都在可以被一次抓取的数据块的大小之内的话，那么索引未必会被使用到。如果从内存的角度上，同样的数据量nested loops的内存占用应该是最小的，sort merge 应该是最大的，而hash join内存消耗在中间。只是一种感官的直觉，具体没有测试过，因为sort merge 需要创建两个排序表，而hash join则需要对B表创建一棵查询树。怎么从hash的角度上来看呢？估计三种表都有hash的使用，使用hash更多的是为了提高查询的效率，比如8=power（2,3），如果使用hash，可能需要创建一棵hash树，就增大了空间的消耗，如果table access full的话，需要最少扫描1次，最多扫描8次。如果使用hash，则最少1次，最多3次，就可以了，使用空间获取时间上的优势。在这个里面，至少感觉到使用到hash的有nested loops中的索引和hash join。

#include "stdafx.h"#include <iostream>#include <hash_map>#include <string>using namespace std;int _tmain(int argc, _TCHAR* argv[]){ stdext::hash_map<std::string, float> hm; hm.insert(std::make_pair<std::string, float>("A", 70.0)); hm.insert(std::make_pair<std::string, float>("C", 75.0)); hm.insert(std::make_pair<std::string, float>("B", 80.0)); stdext::hash_map<std::string, float>::iterator it; for(it = hm.begin(); it!= hm.end(); ++it) { cout <<it->first<<" "<<it->second << std::endl; } return 0;}

一般情况下尽量少返回特殊的数据类型，最好是返回原始数据类型，比如说String、int等，哪怕麻烦点儿，也不会出什么错。建议你将其转换为String类型返回试试。我最近做项目也是用到了myeclipse9中的jax-ws将javabean自动生成webservice，由于前面尝试过多次，返回String等基本的数据类型，或者不返回值时才可以正常生成，万般无奈就把Resultset转换为xml，然后将xml内容转换为字符串返回了。

// 1. 最小树形化容量阈值：即 当哈希表中的容量 > 该值时，才允许树形化链表 （即 将链表 转换成红黑树） // 否则，若桶内元素太多时，则直接扩容，而不是树形化 // 为了避免进行扩容、树形化选择的冲突，这个值不能小于 4 * TREEIFY_THRESHOLD static final int MIN_TREEIFY_CAPACITY = 64; // 2. 桶的树化阈值：即 链表转成红黑树的阈值，在存储数据时，当链表长度 > 该值时，则将链表转换成红黑树 static final int TREEIFY_THRESHOLD = 8; // 3. 桶的链表还原阈值：即 红黑树转为链表的阈值，当在扩容（resize（））时（此时HashMap的数据存储位置会重新计算），在重新计算存储位置后，当原有的红黑树内数量 < 6时，则将 红黑树转换成链表 static final int UNTREEIFY_THRESHOLD = 6;

想象你有一个魔法箱子（HashMap），你可以把东西放进去，并且给每个东西贴上标签（键）以便稍后找到它们。箱子的内部是由一系列抽屉组成，每个抽屉都有一个唯一的标签（哈希码）。当你要放入一样东西时，首先你会生成一个标签（哈希码），这个标签会告诉你应该将东西放入哪个抽屉。假设你想放入一本书，并给它贴上标签 "科学书"，然后根据这个标签（哈希码），你找到对应的抽屉并把书放进去。现在，如果你想找回这本书，你只需要记得它的标签 "科学书"，然后根据这个标签（哈希码）再次找到对应的抽屉，从抽屉里拿出书来。这样你就能快速找到你之前放入箱子的东西。然而，有时候不同的东西可能会有相同的标签（哈希码），这就是所谓的哈希碰撞。在箱子内部，为了解决这个问题，每个抽屉都是一个链表，可以存放多个东西。当发生哈希碰撞时，新的东西会被添加到链表中，而不是新建一个抽屉。当箱子的负载（放入的东西数量）逐渐增加时，为了保持箱子的高效性能，箱子会自动增大，并重新调整抽屉的布局，确保箱子里的抽屉数量适合放入的东西的数量。这就是 Java 中 HashMap 的底层原理。它利用哈希函数将键映射到特定的索引位置，然后在该位置存储值。如果存在哈希碰撞，它会使用链表来处理冲突。当箱子内的东西越来越多时，箱子会自动调整大小，以保持高效性能。这种数据结构使得 HashMap 在大多数情况下能够快速查找和插入数据。

没密码,直接回车可通过.

理论上绝对是可以的。不过要加上新的属性可能增加存储空间（如多维数组，或者像JAVA那样的类数组）。 就像树可以线索化（而且有多种线索化都是用链表实现的），也可以按层输出这个可以看成数组，但是为了进行确定可能需要额外的空间来实现你的结

jre编译成这样了

第一个是O(n)，因为是遍历整个集合 ，第二个是O(m*n)，看他们提供的源码实现就可知道，两重for循环

这样理解：因为数组是引用型，test3 = hash_arrayHashSets[0];test3已经指向hash_arrayHashSets[0]这个实体， test3.add("c")，会在hash_arrayHashSets[0]增加一个元素“C”，这样实体hash_arrayHashSets[0]已经改变了。

1、HashMap线程不安全原因： 原因： JDK1.7 中，由于多线程对HashMap进行扩容，调用了HashMap#transfer ()，具体原因：某个线程执行过程中，被挂起，其他线程已经完成数据迁移，等CPU资源释放后被挂起的线程重新执行之前的逻辑，数据已经被改变，造成死循环、数据丢失。

1 HashMap和HashSet的区别是Java面试中最常被问到的问题。如果没有涉及到Collection框架以及多线程的面试，可以说是不完整。而Collection框架的问题不涉及到HashSet和HashMap，也可以说是不完整。HashMap和HashSet都是collection框架的一部分，它们让我们能够使用对象的集合。collection框架有自己的接口和实现，主要分为Set接口，List接口和Queue接口。它们有各自的特点，Set的集合里不允许对象有重复的值，List允许有重复，它对集合中的对象进行索引，Queue的工作原理是FCFS算法(First Come, First Serve)。23 首先让我们来看看什么是HashMap和HashSet，然后再来比较它们之间的分别。4 什么是HashSet56 HashSet实现了Set接口，它不允许集合中有重复的值，当我们提到HashSet时，第一件事情就是在将对象存储在HashSet之前，要先确保对象重写equals()和hashCode()方法，这样才能比较对象的值是否相等，以确保set中没有储存相等的对象。如果我们没有重写这两个方法，将会使用这个方法的默认实现。78 public boolean add(Object o)方法用来在Set中添加元素，当元素值重复时则会立即返回false，如果成功添加的话会返回true。9 什么是HashMap10 11 HashMap实现了Map接口，Map接口对键值对进行映射。Map中不允许重复的键。Map接口有两个基本的实现，HashMap和TreeMap。TreeMap保存了对象的排列次序，而HashMap则不能。HashMap允许键和值为null。HashMap是非synchronized的，但collection框架提供方法能保证HashMap synchronized，这样多个线程同时访问HashMap时，能保证只有一个线程更改Map。12 13 public Object put(Object Key,Object value)方法用来将元素添加到map中。14 15 你可以阅读这篇文章看看HashMap的工作原理，以及这篇文章看看HashMap和HashTable的区别。16 HashSet和HashMap的区别17 *HashMap* *HashSet*18 HashMap实现了Map接口 HashSet实现了Set接口19 HashMap储存键值对 HashSet仅仅存储对象20 使用put()方法将元素放入map中 使用add()方法将元素放入set中21 HashMap中使用键对象来计算hashcode值 HashSet使用成员对象来计算hashcode值，对于两个对象来说hashcode可能相同，所以equals()方法用来判断对象的相等性，如果两个对象不同的话，那么返回false22 HashMap比较快，因为是使用唯一的键来获取对象 HashSet较HashMap来说比较慢

concurrenthashmap是弱一致的，iterator 都是弱一致性的，两者的迭代器的一致性不同的。当删除了第7个元素的时候，B会感知到已删除，所以B的后续迭代都是真实的数据。

一直以来只是知道HashMap是线程不安全的，但是到底HashMap为什么线程不安全，多线程并发的时候在什么情况下可能出现问题？HashMap底层是一个Entry数组，当发生hash冲突的时候，hashmap是采用链表的方式来解决的，在对应的数组位置存放链表的头结点。对链表而言，新加入的节点会从头结点加入。javadoc中关于hashmap的一段描述如下：此实现不是同步的。如果多个线程同时访问一个哈希映射，而其中至少一个线程从结构上修改了该映射，则它必须 保持外部同步。（结构上的修改是指添加或删除一个或多个映射关系的任何操作；仅改变与实例已经包含的键关联的值不是结构上的修改。）这一般通过对自然封装该映射的对象进行同步操作来完成。如果不存在这样的对象，则应该使用 Collections.synchronizedMap 方法来“包装”该映射。最好在创建时完成这一操作，以防止对映射进行意外的非同步访问，如下所示： Map m = Collections.synchronizedMap(new HashMap(...));1、[java] view plain copyvoid addEntry(int hash, K key, V value, int bucketIndex) { Entry<K,V> e = table[bucketIndex]; table[bucketIndex] = new Entry<K,V>(hash, key, value, e); if (size++ >= threshold) resize(2 * table.length); } 在hashmap做put操作的时候会调用到以上的方法。现在假如A线程和B线程同时对同一个数组位置调用addEntry，两个线程会同时得到现在的头结点，然后A写入新的头结点之后，B也写入新的头结点，那B的写入操作就会覆盖A的写入操作造成A的写入操作丢失2、[java] view plain copyfinal Entry<K,V> removeEntryForKey(Object key) { int hash = (key == null) ? 0 : hash(key.hashCode()); int i = indexFor(hash, table.length); Entry<K,V> prev = table[i]; Entry<K,V> e = prev; while (e != null) { Entry<K,V> next = e.next; Object k; if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) { modCount++; size--; if (prev == e) table[i] = next; else prev.next = next; e.recordRemoval(this); return e; } prev = e; e = next; } return e; } 删除键值对的代码如上：当多个线程同时操作同一个数组位置的时候，也都会先取得现在状态下该位置存储的头结点，然后各自去进行计算操作，之后再把结果写会到该数组位置去，其实写回的时候可能其他的线程已经就把这个位置给修改过了，就会覆盖其他线程的修改3、addEntry中当加入新的键值对后键值对总数量超过门限值的时候会调用一个resize操作，代码如下：[java] view plain copyvoid resize(int newCapacity) { Entry[] oldTable = table; int oldCapacity = oldTable.length; if (oldCapacity == MAXIMUM_CAPACITY) { threshold = Integer.MAX_VALUE; return; } Entry[] newTable = new Entry[newCapacity]; transfer(newTable); table = newTable; threshold = (int)(newCapacity * loadFactor); } 这个操作会新生成一个新的容量的数组，然后对原数组的所有键值对重新进行计算和写入新的数组，之后指向新生成的数组。当多个线程同时检测到总数量超过门限值的时候就会同时调用resize操作，各自生成新的数组并rehash后赋给该map底层的数组table，结果最终只有最后一个线程生成的新数组被赋给table变量，其他线程的均会丢失。而且当某些线程已经完成赋值而其他线程刚开始的时候，就会用已经被赋值的table作为原始数组，这样也会有问题。

该题可以在baidu ,有很多解答.我这需要说明下 这个是面试常 问的但hashtable 基本被淘汰了 ,可用concurrentMap 替代

大概是不同的object计算出的hascode不同

两者都是非线程安全，前者无排序，后者会自动排序

ConcurrentHashMap的弱一致性主要是为了提升效率，是一致性与效率之间的一种权衡。要成为强一致性，就得到处使用锁，甚至是全局锁，这就与Hashtable和同步的HashMap一样了。

HashMap的原理介绍x0dx0ax0dx0a此乃老生常谈，不作仔细解说。x0dx0a一句话概括之：HashMap是一个散列表，它存储的内容是键值对(key-value)映射。x0dx0ax0dx0aJava 7 中HashMap的源码分析x0dx0ax0dx0a首先是HashMap的构造函数代码块1中，根据初始化的Capacity与loadFactor（加载因子）初始化HashMap.x0dx0a//代码块1x0dx0a public HashMap(int initialCapacity, float loadFactor) {x0dx0a if (initialCapacity < 0)x0dx0a throw new IllegalArgumentException("Illegal initial capacity: " +x0dx0a initialCapacity);x0dx0a if (initialCapacity > MAXIMUM_CAPACITY)x0dx0a initialCapacity = MAXIMUM_CAPACITY;x0dx0a if (loadFactor <= 0 || Float.isNaN(loadFactor))x0dx0a throw new IllegalArgumentException("Illegal load factor: " +loadFactor);x0dx0ax0dx0a this.loadFactor = loadFactor;x0dx0a threshold = initialCapacity;x0dx0a init();x0dx0a }x0dx0ax0dx0aJava7中对于的put方法实现相对比较简单，首先根据 key1 的key值计算hash值，再根据该hash值与table的length确定该key所在的index,如果当前位置的Entry不为null，则在该Entry链中遍历，如果找到hash值和key值都相同，则将值value覆盖，返回oldValue；如果当前位置的Entry为null，则直接addEntry。x0dx0a代码块2x0dx0apublic V put(K key, V value) {x0dx0a if (table == EMPTY_TABLE) {x0dx0a inflateTable(threshold);x0dx0a }x0dx0a if (key == null)x0dx0a return putForNullKey(value);x0dx0a int hash = hash(key);x0dx0a int i = indexFor(hash, table.length);x0dx0a for (Entry e = table[i]; e != null; e = e.next) {x0dx0a Object k;x0dx0a if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {x0dx0a V oldValue = e.value;x0dx0a e.value = value;x0dx0a e.recordAccess(this);x0dx0a return oldValue;x0dx0a }x0dx0a }x0dx0ax0dx0a modCount++;x0dx0a addEntry(hash, key, value, i);x0dx0a return null;x0dx0a }x0dx0ax0dx0a//addEntry方法中会检查当前table是否需要resizex0dx0a void addEntry(int hash, K key, V value, int bucketIndex) {x0dx0a if ((size >= threshold) && (null != table[bucketIndex])) {x0dx0a resize(2 * table.length); //当前map中的size 如果大于threshole的阈值，则将resize将table的length扩大2倍。x0dx0a hash = (null != key) ? hash(key) : 0;x0dx0a bucketIndex = indexFor(hash, table.length);x0dx0a }x0dx0ax0dx0a createEntry(hash, key, value, bucketIndex);x0dx0a }x0dx0ax0dx0aJava7 中resize（）方法的实现比较简单，将OldTable的长度扩展，并且将oldTable中的Entry根据rehash的标记重新计算hash值和index移动到newTable中去。代码如代码块3中所示，x0dx0a//代码块3 --JDK7中HashMap.resize()方法x0dx0avoid resize(int newCapacity) {x0dx0a Entry[] oldTable = table;x0dx0a int oldCapacity = oldTable.length;x0dx0a if (oldCapacity == MAXIMUM_CAPACITY) {x0dx0a threshold = Integer.MAX_VALUE;x0dx0a return;x0dx0a }x0dx0ax0dx0a Entry[] newTable = new Entry[newCapacity];x0dx0a transfer(newTable, initHashSeedAsNeeded(newCapacity));x0dx0a table = newTable;x0dx0a threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);x0dx0a }x0dx0ax0dx0a /**x0dx0a * 将当前table的Entry转移到新的table中x0dx0a */x0dx0a void transfer(Entry[] newTable, boolean rehash) {x0dx0a int newCapacity = newTable.length;x0dx0a for (Entry e : table) {x0dx0a while(null != e) {x0dx0a Entry next = e.next;x0dx0a if (rehash) {x0dx0a e.hash = null == e.key ? 0 : hash(e.key);x0dx0a }x0dx0a int i = indexFor(e.hash, newCapacity);x0dx0a e.next = newTable[i];x0dx0a newTable[i] = e;x0dx0a e = next;x0dx0a }x0dx0a }x0dx0a }x0dx0ax0dx0aHashMap性能的有两个参数：初始容量(initialCapacity) 和加载因子(loadFactor)。容量 是哈希表中桶的数量，初始容量只是哈希表在创建时的容量。加载因子 是哈希表在其容量自动增加之前可以达到多满的一种尺度。当哈希表中的条目数超出了加载因子与当前容量的乘积时，则要对该哈希表进行 rehash 操作（即重建内部数据结构），从而哈希表将具有大约两倍的桶数。x0dx0a根据源码分析可以看出：在Java7 中 HashMap的entry是按照index索引存储的，遇到hash冲突的时候采用拉链法解决冲突，将冲突的key和value插入到链表list中。x0dx0a然而这种解决方法会有一个缺点，假如key值都冲突，HashMap会退化成一个链表，get的复杂度会变成O(n)。x0dx0a在Java8中为了优化该最坏情况下的性能，采用了平衡树来存放这些hash冲突的键值对，性能由此可以提升至O(logn)。x0dx0a代码块4 -- JDK8中HashMap中常量定义x0dx0a static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; x0dx0a static final int TREEIFY_THRESHOLD = 8; // 是否将list转换成tree的阈值x0dx0a static final int UNTREEIFY_THRESHOLD = 6; // 在resize操作中，决定是否untreeify的阈值x0dx0a static final int MIN_TREEIFY_CAPACITY = 64; // 决定是否转换成tree的最小容量x0dx0a static final float DEFAULT_LOAD_FACTOR = 0.75f; // default的加载因子x0dx0ax0dx0a在Java 8 HashMap的put方法实现如代码块5所示，x0dx0a代码块5 --JDK8 HashMap.put方法x0dx0a public V put(K key, V value) {x0dx0a return putVal(hash(key), key, value, false, true);x0dx0a }x0dx0ax0dx0a final V putVal(int hash, K key, V value, boolean onlyIfAbsent,x0dx0a boolean evict) {x0dx0a Node[] tab; Node p; int n, i;x0dx0a if ((tab = table) == null || (n = tab.length) == 0)x0dx0a n = (tab = resize()).length; //table为空的时候，n为table的长度x0dx0a if ((p = tab[i = (n - 1) & hash]) == null)x0dx0a tab[i] = newNode(hash, key, value, null); // (n - 1) & hash 与Java7中indexFor方法的实现相同，若i位置上的值为空，则新建一个Node，table[i]指向该Node。x0dx0a else {x0dx0a // 若i位置上的值不为空，判断当前位置上的Node p 是否与要插入的key的hash和key相同x0dx0a Node e; K k;x0dx0a if (p.hash == hash &&x0dx0a ((k = p.key) == key || (key != null && key.equals(k))))x0dx0a e = p;//相同则覆盖之x0dx0a else if (p instanceof TreeNode)x0dx0a // 不同，且当前位置上的的node p已经是TreeNode的实例，则再该树上插入新的node。x0dx0a e = ((TreeNode)p).putTreeVal(this, tab, hash, key, value);x0dx0a else {x0dx0a // 在i位置上的链表中找到p.next为null的位置，binCount计算出当前链表的长度，如果继续将冲突的节点插入到该链表中，会使链表的长度大于tree化的阈值，则将链表转换成tree。x0dx0a for (int binCount = 0; ; ++binCount) {x0dx0a if ((e = p.next) == null) {x0dx0a p.next = newNode(hash, key, value, null);x0dx0a if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1stx0dx0a treeifyBin(tab, hash);x0dx0a break;x0dx0a }x0dx0a if (e.hash == hash &&x0dx0a ((k = e.key) == key || (key != null && key.equals(k))))x0dx0a break;x0dx0a p = e;x0dx0a }x0dx0a }x0dx0a if (e != null) { // existing mapping for keyx0dx0a V oldValue = e.value;x0dx0a if (!onlyIfAbsent || oldValue == null)x0dx0a e.value = value;x0dx0a afterNodeAccess(e);x0dx0a return oldValue;x0dx0a }x0dx0a }x0dx0a ++modCount;x0dx0a if (++size > threshold)x0dx0a resize();x0dx0a afterNodeInsertion(evict);x0dx0a return null;x0dx0a }x0dx0ax0dx0a再看下resize方法，由于需要考虑hash冲突解决时采用的可能是list 也可能是balance tree的方式，因此resize方法相比JDK7中复杂了一些,x0dx0a代码块6 -- JDK8的resize方法x0dx0a inal Node[] resize() {x0dx0a Node[] oldTab = table;x0dx0a int oldCap = (oldTab == null) ? 0 : oldTab.length;x0dx0a int oldThr = threshold;x0dx0a int newCap, newThr = 0;x0dx0a if (oldCap > 0) {x0dx0a if (oldCap >= MAXIMUM_CAPACITY) {x0dx0a threshold = Integer.MAX_VALUE;//如果超过最大容量，无法再扩充tablex0dx0a return oldTab;x0dx0a }x0dx0a else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&x0dx0a oldCap >= DEFAULT_INITIAL_CAPACITY)x0dx0a newThr = oldThr << 1; // threshold门槛扩大至2倍x0dx0a }x0dx0a else if (oldThr > 0) // initial capacity was placed in thresholdx0dx0a newCap = oldThr;x0dx0a else { // zero initial threshold signifies using defaultsx0dx0a newCap = DEFAULT_INITIAL_CAPACITY;x0dx0a newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);x0dx0a }x0dx0a if (newThr == 0) {x0dx0a float ft = (float)newCap * loadFactor;x0dx0a newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?x0dx0a (int)ft : Integer.MAX_VALUE);x0dx0a }x0dx0a threshold = newThr;x0dx0a @SuppressWarnings({"rawtypes","unchecked"})x0dx0a Node[] newTab = (Node[])new Node[newCap];// 创建容量为newCap的newTab，并将oldTab中的Node迁移过来，这里需要考虑链表和tree两种情况。

首页所有文章资讯Web架构基础技术书籍教程Java小组工具资源谈谈HashMap线程不安全的体现2016/10/18|分类：基础技术|6条评论|标签：HASHMAP,并发分享到：26原文出处：HoseeHashMap的原理以及如何实现，之前在JDK7与JDK8中HashMap的实现中已经说明了。那么，为什么说HashMap是线程不安全的呢？它在多线程环境下，会发生什么情况呢？1.resize死循环我们都知道HashMap初始容量大小为16,一般来说，当有数据要插入时，都会检查容量有没有超过设定的thredhold，如果超过，需要增大Hash表的尺寸，但是这样一来，整个Hash表里的元素都需要被重算一遍。这叫rehash，这个成本相当的大。voidresize(intnewCapacity){Entry[]oldTable=table;intoldCapacity=oldTable.length;if(oldCapacity==MAXIMUM_CAPACITY){threshold=Integer.MAX_VALUE;return;}Entry[]newTable=newEntry[newCapacity];transfer(newTable,initHashSeedAsNeeded(newCapacity));table=newTable;threshold=(int)Math.min(newCapacity*loadFactor,MAXIMUM_CAPACITY+1);}voidtransfer(Entry[]newTable,booleanrehash){intnewCapacity=newTable.length;for(Entrye:table){while(null!=e){Entrynext=e.next;if(rehash){e.hash=null==e.key?0:hash(e.key);}inti=indexFor(e.hash,newCapacity);e.next=newTable[i];newTable[i]=e;e=next;}}}大概看下transfer：对索引数组中的元素遍历对链表上的每一个节点遍历：用next取得要转移那个元素的下一个，将e转移到新Hash表的头部，使用头插法插入节点。循环2，直到链表节点全部转移循环1，直到所有索引数组全部转移经过这几步，我们会发现转移的时候是逆序的。假如转移前链表顺序是1->2->3，那么转移后就会变成3->2->1。这时候就有点头绪了，死锁问题不就是因为1->2的同时2->1造成的吗？所以，HashMap的死锁问题就出在这个transfer()函数上。

去看看这个帖子吧，或许对你有所帮助http://www.cnblogs.com/yxysuanfa/p/6932010.html

HashMap的原理介绍此乃老生常谈，不作仔细解说。一句话概括之：HashMap是一个散列表，它存储的内容是键值对(key-value)映射。Java 7 中HashMap的源码分析首先是HashMap的构造函数代码块1中，根据初始化的Capacity与loadFactor（加载因子）初始化HashMap.//代码块1 public HashMap(int initialCapacity, float loadFactor) { if (initialCapacity < 0) throw new IllegalArgumentException("Illegal initial capacity: " + initialCapacity); if (initialCapacity > MAXIMUM_CAPACITY) initialCapacity = MAXIMUM_CAPACITY; if (loadFactor <= 0 || Float.isNaN(loadFactor)) throw new IllegalArgumentException("Illegal load factor: " +loadFactor); this.loadFactor = loadFactor; threshold = initialCapacity; init(); }Java7中对于<key1,value1>的put方法实现相对比较简单，首先根据 key1 的key值计算hash值，再根据该hash值与table的length确定该key所在的index,如果当前位置的Entry不为null，则在该Entry链中遍历，如果找到hash值和key值都相同，则将值value覆盖，返回oldValue；如果当前位置的Entry为null，则直接addEntry。代码块2public V put(K key, V value) { if (table == EMPTY_TABLE) { inflateTable(threshold); } if (key == null) return putForNullKey(value); int hash = hash(key); int i = indexFor(hash, table.length); for (Entry<K,V> e = table[i]; e != null; e = e.next) { Object k; if (e.hash == hash && ((k = e.key) == key || key.equals(k))) { V oldValue = e.value; e.value = value; e.recordAccess(this); return oldValue; } } modCount++; addEntry(hash, key, value, i); return null; }//addEntry方法中会检查当前table是否需要resize void addEntry(int hash, K key, V value, int bucketIndex) { if ((size >= threshold) && (null != table[bucketIndex])) { resize(2 * table.length); //当前map中的size 如果大于threshole的阈值，则将resize将table的length扩大2倍。 hash = (null != key) ? hash(key) : 0; bucketIndex = indexFor(hash, table.length); } createEntry(hash, key, value, bucketIndex); }Java7 中resize（）方法的实现比较简单，将OldTable的长度扩展，并且将oldTable中的Entry根据rehash的标记重新计算hash值和index移动到newTable中去。代码如代码块3中所示，//代码块3 --JDK7中HashMap.resize()方法void resize(int newCapacity) { Entry[] oldTable = table; int oldCapacity = oldTable.length; if (oldCapacity == MAXIMUM_CAPACITY) { threshold = Integer.MAX_VALUE; return; } Entry[] newTable = new Entry[newCapacity]; transfer(newTable, initHashSeedAsNeeded(newCapacity)); table = newTable; threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1); } /** * 将当前table的Entry转移到新的table中 */ void transfer(Entry[] newTable, boolean rehash) { int newCapacity = newTable.length; for (Entry<K,V> e : table) { while(null != e) { Entry<K,V> next = e.next; if (rehash) { e.hash = null == e.key ? 0 : hash(e.key); } int i = indexFor(e.hash, newCapacity); e.next = newTable[i]; newTable[i] = e; e = next; } } }HashMap性能的有两个参数：初始容量(initialCapacity) 和加载因子(loadFactor)。容量 是哈希表中桶的数量，初始容量只是哈希表在创建时的容量。加载因子 是哈希表在其容量自动增加之前可以达到多满的一种尺度。当哈希表中的条目数超出了加载因子与当前容量的乘积时，则要对该哈希表进行 rehash 操作（即重建内部数据结构），从而哈希表将具有大约两倍的桶数。根据源码分析可以看出：在Java7 中 HashMap的entry是按照index索引存储的，遇到hash冲突的时候采用拉链法解决冲突，将冲突的key和value插入到链表list中。然而这种解决方法会有一个缺点，假如key值都冲突，HashMap会退化成一个链表，get的复杂度会变成O(n)。在Java8中为了优化该最坏情况下的性能，采用了平衡树来存放这些hash冲突的键值对，性能由此可以提升至O(logn)。代码块4 -- JDK8中HashMap中常量定义 static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; static final int TREEIFY_THRESHOLD = 8; // 是否将list转换成tree的阈值 static final int UNTREEIFY_THRESHOLD = 6; // 在resize操作中，决定是否untreeify的阈值 static final int MIN_TREEIFY_CAPACITY = 64; // 决定是否转换成tree的最小容量 static final float DEFAULT_LOAD_FACTOR = 0.75f; // default的加载因子在Java 8 HashMap的put方法实现如代码块5所示，代码块5 --JDK8 HashMap.put方法 public V put(K key, V value) { return putVal(hash(key), key, value, false, true); } final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) { Node<K,V>[] tab; Node<K,V> p; int n, i; if ((tab = table) == null || (n = tab.length) == 0) n = (tab = resize()).length; //table为空的时候，n为table的长度 if ((p = tab[i = (n - 1) & hash]) == null) tab[i] = newNode(hash, key, value, null); // (n - 1) & hash 与Java7中indexFor方法的实现相同，若i位置上的值为空，则新建一个Node，table[i]指向该Node。 else { // 若i位置上的值不为空，判断当前位置上的Node p 是否与要插入的key的hash和key相同 Node<K,V> e; K k; if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k)))) e = p;//相同则覆盖之 else if (p instanceof TreeNode) // 不同，且当前位置上的的node p已经是TreeNode的实例，则再该树上插入新的node。 e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value); else { // 在i位置上的链表中找到p.next为null的位置，binCount计算出当前链表的长度，如果继续将冲突的节点插入到该链表中，会使链表的长度大于tree化的阈值，则将链表转换成tree。 for (int binCount = 0; ; ++binCount) { if ((e = p.next) == null) { p.next = newNode(hash, key, value, null); if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st treeifyBin(tab, hash); break; } if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) break; p = e; } } if (e != null) { // existing mapping for key V oldValue = e.value; if (!onlyIfAbsent || oldValue == null) e.value = value; afterNodeAccess(e); return oldValue; } } ++modCount; if (++size > threshold) resize(); afterNodeInsertion(evict); return null; }再看下resize方法，由于需要考虑hash冲突解决时采用的可能是list 也可能是balance tree的方式，因此resize方法相比JDK7中复杂了一些,代码块6 -- JDK8的resize方法 inal Node<K,V>[] resize() { Node<K,V>[] oldTab = table; int oldCap = (oldTab == null) ? 0 : oldTab.length; int oldThr = threshold; int newCap, newThr = 0; if (oldCap > 0) { if (oldCap >= MAXIMUM_CAPACITY) { threshold = Integer.MAX_VALUE;//如果超过最大容量，无法再扩充table return oldTab; } else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY && oldCap >= DEFAULT_INITIAL_CAPACITY) newThr = oldThr << 1; // threshold门槛扩大至2倍 } else if (oldThr > 0) // initial capacity was placed in threshold newCap = oldThr; else { // zero initial threshold signifies using defaults newCap = DEFAULT_INITIAL_CAPACITY; newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY); } if (newThr == 0) { float ft = (float)newCap * loadFactor; newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ? (int)ft : Integer.MAX_VALUE); } threshold = newThr; @SuppressWarnings({"rawtypes","unchecked"}) Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];// 创建容量为newCap的newTab，并将oldTab中的Node迁移过来，这里需要考虑链表和tree两种情况。

什么是HashSetHashSet实现了Set接口，它不允许集合中有重复的值，当我们提到HashSet时，第一件事情就是在将对象存储在HashSet之前，要先确保对象重写equals()和hashCode()方法，这样才能比较对象的值是否相等，以确保set中没有储存相等的对象。如果我们没有重写这两个方法，将会使用这个方法的默认实现。public boolean add(Object o)方法用来在Set中添加元素，当元素值重复时则会立即返回false，如果成功添加的话会返回true。什么是HashMapHashMap实现了Map接口，Map接口对键值对进行映射。Map中不允许重复的键。Map接口有两个基本的实现，HashMap和TreeMap。TreeMap保存了对象的排列次序，而HashMap则不能。HashMap允许键和值为null。HashMap是非synchronized的，但collection框架提供方法能保证HashMap synchronized，这样多个线程同时访问HashMap时，能保证只有一个线程更改Map。public Object put(Object Key,Object value)方法用来将元素添加到map中。你可以阅读这篇文章看看HashMap的工作原理，以及这篇文章看看HashMap和HashTable的区别。HashSet和HashMap的区别*HashMap* *HashSet* HashMap实现了Map接口 HashSet实现了Set接口 HashMap储存键值对 HashSet仅仅存储对象 使用put()方法将元素放入map中 使用add()方法将元素放入set中 HashMap中使用键对象来计算hashcode值 HashSet使用成员对象来计算hashcode值，对于两个对象来说hashcode可能相同，所以equals()方法用来判断对象的相等性，如果两个对象不同的话，那么返回false HashMap比较快，因为是使用唯一的键来获取对象 HashSet较HashMap来说比较慢

一、继承父类不同Hashtable继承自Dictionary类，而HashMap继承自AbstractMap类；但二者都实现了Map接口。二、线程的安全性1、HashTable是同步（方法中使用了Synchronize)的；而HashMap是未同步（方法中缺省Synchronize）的。2、Hashtable线程安全，因为它每个方法中都加入了Synchronize，在多线程并发的环境下，可以直接使用Hashtable，不需自己在加同步；HashMap线程不安全，因为HashMap底层是一个Entry数组，当发生hashmap冲突的时候，hashmap是采用链表的方式来解决的，在对应的数组位置存放链表的头结点。对链表而言，新加入的节点会从头结点加入。三、是否有contains方法1、HashTable有一个contains(Object value)方法，功能和containsValue方法（Object value)功能一样。2、HashMap把Hashtable的contains方法去掉了，改成containsValue和containsKey。四、可否允许有null值key、value都是对象，但是不能拥有重复key值，value值可以重复出现。1、Hashtable中，key和value都不允许出现null值。2、HashMap允许null值（key和value都可以），因为在HashMap中null可以作为健，而它对应的值可以有多个null。五、遍历方式内部实现不同1.HashTable使用Enumeration，HashMap使用Iterator。

并不能保证,但是可以通过判断,得到现在有无数据,若有,进入下一层。

HashTable不就可以吗。

http://blog.csdn.net/rickiyeat/article/details/52708794

首先介绍一下什么是Map.在数组中我们是通过数组下标来对其内容索引的，而在Map中我们通过对象来对对象进行索引，用来索引的对象叫做key,其对应的对象叫做value.这就是我们平时说的键值对。　　HashMap通过hashcode对其内容进行快速查找，而 TreeMap中所有的元素都保持着某种固定的顺序，如果你需要得到一个有序的结果你就应该使用TreeMap（HashMap中元素的排列顺序是不固定的）。　　HashMap 非线程安全 TreeMap 非线程安全　　线程安全　　在Java里，线程安全一般体现在两个方面：　　1、多个thread对同一个java实例的访问（read和modify）不会相互干扰，它主要体现在关键字synchronized.如ArrayList和Vector,HashMap和Hashtable　　（后者每个方法前都有synchronized关键字）。如果你在interator一个List对象时，其它线程remove一个element,问题就出现了。　　2、每个线程都有自己的字段，而不会在多个线程之间共享。它主要体现在java.lang.ThreadLocal类，而没有Java关键字支持，如像static、transient那样。　　1.AbstractMap抽象类和SortedMap接口　　AbstractMap抽象类：（HashMap继承AbstractMap）覆盖了equals（）和hashCode（）方法以确保两个相等映射返回相同的哈希码。如果两个映射大小相等、包含同样的键且每个键在这两个映射中对应的值都相同，则这两个映射相等。映射的哈希码是映射元素哈希码的总和，其中每个元素是Map.Entry接口的一个实现。因此，不论映射内部顺序如何，两个相等映射会报告相同的哈希码。　　SortedMap接口：（TreeMap继承自SortedMap）它用来保持键的有序顺序。SortedMap接口为映像的视图（子集），包括两个端点提供了访问方法。除了排序是作用于映射的键以外，处理SortedMap和处理SortedSet一样。添加到SortedMap实现类的元素必须实现Comparable接口，否则您必须给它的构造函数提供一个Comparator接口的实现。TreeMap类是它的唯一一份实现。　　2.两种常规Map实现　　HashMap:基于哈希表实现。使用HashMap要求添加的键类明确定义了hashCode（）和equals（）[可以重写hashCode（）和equals（）],为了优化HashMap空间的使用，您可以调优初始容量和负载因子。　　（1）HashMap（）： 构建一个空的哈希映像　　（2）HashMap（Map m）： 构建一个哈希映像，并且添加映像m的所有映射　　（3）HashMap（int initialCapacity）： 构建一个拥有特定容量的空的哈希映像　　（4）HashMap（int initialCapacity, float loadFactor）： 构建一个拥有特定容量和加载因子的空的哈希映像　　TreeMap:基于红黑树实现。TreeMap没有调优选项，因为该树总处于平衡状态。　　（1）TreeMap（）：构建一个空的映像树　　（2）TreeMap（Map m）： 构建一个映像树，并且添加映像m中所有元素　　（3）TreeMap（Comparator c）： 构建一个映像树，并且使用特定的比较器对关键字进行排序　　（4）TreeMap（SortedMap s）： 构建一个映像树，添加映像树s中所有映射，并且使用与有序映像s相同的比较器排序　　3.两种常规Map性能　　HashMap:适用于在Map中插入、删除和定位元素。　　Treemap:适用于按自然顺序或自定义顺序遍历键（key）。　　4.总结　　HashMap通常比TreeMap快一点（树和哈希表的数据结构使然），建议多使用HashMap,在需要排序的Map时候才用TreeMap.　　import java.util.HashMap;　　import java.util.Hashtable;　　import java.util.Iterator;　　import java.util.Map;　　import java.util.TreeMap;　　public class HashMaps {　　public static void main（String[] args） {　　Map<String, String> map = new HashMap<String, String>（）；　　map.put（"a", "aaa"）；　　map.put（"b", "bbb"）；　　map.put（"c", "ccc"）；　　map.put（"d", "ddd"）；　　Iterator<String> iterator = map.keySet（）。iterator（）；　　while （iterator.hasNext（）） {　　Object key = iterator.next（）；　　System.out.println（"map.get（key） is :" + map.get（key））；　　}　　// 定义HashTable,用来测试　　Hashtable<String, String> tab = new Hashtable<String, String>（）；　　tab.put（"a", "aaa"）；　　tab.put（"b", "bbb"）；　　tab.put（"c", "ccc"）；　　tab.put（"d", "ddd"）；　　Iterator<String> iterator_1 = tab.keySet（）。iterator（）；　　while （iterator_1.hasNext（）） {　　Object key = iterator_1.next（）；　　System.out.println（"tab.get（key） is :" + tab.get（key））；　　}　　TreeMap<String, String> tmp = new TreeMap<String, String>（）；　　tmp.put（"a", "aaa"）；　　tmp.put（"b", "bbb"）；　　tmp.put（"c", "ccc"）；　　tmp.put（"d", "cdc"）；　　Iterator<String> iterator_2 = tmp.keySet（）。iterator（）；　　while （iterator_2.hasNext（）） {　　Object key = iterator_2.next（）；　　System.out.println（"tmp.get（key） is :" + tmp.get（key））；　　}　　}　　}　　运行结果如下：　　map.get（key） is :ddd　　map.get（key） is :bbb　　map.get（key） is :ccc　　map.get（key） is :aaa　　tab.get（key） is :bbb　　tab.get（key） is :aaa　　tab.get（key） is :ddd　　tab.get（key） is :ccc　　tmp.get（key） is :aaa　　tmp.get（key） is :bbb　　tmp.get（key） is :ccc　　tmp.get（key） is :cdc　　HashMap的结果是没有排序的，而TreeMap输出的结果是排好序的。　　下面就要进入本文的主题了。先举个例子说明一下怎样使用HashMap:　　import java.util.*;　　public class Exp1 {　　public static void main（String[] args）{　　HashMap h1=new HashMap（）；　　Random r1=new Random（）；　　for （int i=0;i<1000;i++）{　　Integer t=new Integer（r1.nextInt（20））；　　if （h1.containsKey（t））　　（（Ctime）h1.get（t））。count++;　　else　　h1.put（t, new Ctime（））；　　}　　System.out.println（h1）；　　}　　}　　class Ctime{　　int count=1;　　public String toString（）{　　return Integer.toString（count）；　　}　　}　在HashMap中通过get（）来获取value,通过put（）来插入value,ContainsKey（）则用来检验对象是否已经存在。可以看出，和ArrayList的操作相比，HashMap除了通过key索引其内容之外，别的方面差异并不大。　　前面介绍了，HashMap是基于HashCode的，在所有对象的超类Object中有一个HashCode（）方法，但是它和equals方法一样，并不能适用于所有的情况，这样我们就需要重写自己的HashCode（）方法。下面就举这样一个例子：　　import java.util.*;　　public class Exp2 {　　public static void main（String[] args）{　　HashMap h2=new HashMap（）；　　for （int i=0;i<10;i++）　　h2.put（new Element（i）， new Figureout（））；　　System.out.println（"h2:"）；　　System.out.println（"Get the result for Element:"）；　　Element test=new Element（5）；　　if （h2.containsKey（test））　　System.out.println（（Figureout）h2.get（test））；　　else　　System.out.println（"Not found"）；　　}　　}　　class Element{　　int number;　　public Element（int n）{　　number=n;　　}　　}　　class Figureout{　　Random r=new Random（）；　　boolean possible=r.nextDouble（）>0.5;　　public String toString（）{　　if （possible）　　return "OK!";　　else　　return "Impossible!";　　}　　}　　在这个例子中，Element用来索引对象Figureout,也即Element为key,Figureout为value.在Figureout中随机生成一个浮点数，如果它比0.5大，打印"OK!",否则打印"Impossible!".之后查看Element（3）对应的Figureout结果如何。　　结果却发现，无论你运行多少次，得到的结果都是"Not found".也就是说索引Element（3）并不在HashMap中。这怎么可能呢？　　原因得慢慢来说：Element的HashCode方法继承自Object,而Object中的HashCode方法返回的HashCode对应于当前的地址，也就是说对于不同的对象，即使它们的内容完全相同，用HashCode（）返回的值也会不同。这样实际上违背了我们的意图。因为我们在使用 HashMap时，希望利用相同内容的对象索引得到相同的目标对象，这就需要HashCode（）在此时能够返回相同的值。在上面的例子中，我们期望 new Element（i） （i=5）与 Elementtest=newElement（5）是相同的，而实际上这是两个不同的对象，尽管它们的内容相同，但它们在内存中的地址不同。因此很自然的，上面的程序得不到我们设想的结果。下面对Element类更改如下：　　class Element{　　int number;　　public Element（int n）{　　number=n;　　}　　public int hashCode（）{　　return number;　　}　　public boolean equals（Object o）{　　return （o instanceof Element） && （number==（（Element）o）。number）；　　}　　}　　在这里Element覆盖了Object中的hashCode（）和equals（）方法。覆盖hashCode（）使其以number的值作为 hashcode返回，这样对于相同内容的对象来说它们的hashcode也就相同了。而覆盖equals（）是为了在HashMap判断两个key是否相等时使结果有意义（有关重写equals（）的内容可以参考我的另一篇文章《重新编写Object类中的方法》）。修改后的程序运行结果如下：　　h2:　　Get the result for Element:　　Impossible!　　请记住：如果你想有效的使用HashMap,你就必须重写在其的HashCode（）。　　还有两条重写HashCode（）的原则：　　[list=1]　　不必对每个不同的对象都产生一个唯一的hashcode,只要你的HashCode方法使get（）能够得到put（）放进去的内容就可以了。即"不为一原则".　　生成hashcode的算法尽量使hashcode的值分散一些，不要很多hashcode都集中在一个范围内，这样有利于提高HashMap的性能。即"分散原则".至于第二条原则的具体原因，有兴趣者可以参考Bruce Eckel的《Thinking in Java》，在那里有对HashMap内部实现原理的介绍，这里就不赘述了。　　掌握了这两条原则，你就能够用好HashMap编写自己的程序了。不知道大家注意没有，java.lang.Object中提供的三个方法：clone（），equals（）和hashCode（）虽然很典型，但在很多情况下都不能够适用，它们只是简单的由对象的地址得出结果。这就需要我们在自己的程序中重写它们，其实java类库中也重写了千千万万个这样的方法。利用面向对象的多态性--覆盖，Java的设计者很优雅的构建了Java的结构，也更加体现了Java是一门纯OOP语言的特性。

HashMap是Hashtable的轻量级实现(非线程安全的实现)，他们都完成了Map接口，主要区别在于HashMap允许空(null)键值(key),由于非线程安全，效率上可能高于Hashtable。HashMap允许将null作为一个entry的key或者value，而Hashtable不允许。HashMap把Hashtable的contains方法去掉了，改成containsvalue和containsKey。因为contains方法容易让人引起误解。Hashtable继承自Dictionary类，而HashMap是Java1.2引进的Map interface的一个实现。最大的不同是，Hashtable的方法是Synchronize的，而HashMap不是，在多个线程访问Hashtable时，不需要自己为它的方法实现同步，而HashMap 就必须为之提供外同步(如果是ArrayList：List lst = Collections.synchronizedList(new ArrayList());如果是HashMap：Map map = Collections.synchronizedMap(new HashMap());)。Hashtable和HashMap采用的hash/rehash算法都大概一样，所以性能不会有很大的差异。

从结构实现来讲，HashMap是:数组+链表+红黑树（JDK1.8增加了红黑树部分）实现的，如下如所示。

【答案】：Java中的HashMap是以键值对(key-value)的形式存储元素的。HashMap需要一个hash函数，它使用hashCode()和equals()方法来向集合/从集合添加和检索元素。当调用put()方法的时候，HashMap会计算key的hash值，然后把键值对存储在集合中合适的索引上。如果key已经存在了，value会被更新成新值。HashMap的一些重要的特性是它的容量(capacity)，负载因子(load factor)和扩容极限(threshold resizing)。

在Windows下运行应用程序时出现非法操作的提示此类故障引起原因较多，在如下几钟可能:（1） 系统文件被更改或损坏，倘若由此引发则打开一些系统自带的程序时就会出现非法操作，（例如，打开控制面板）（2） 驱动程序未正确安装，此类故障一般表现在显卡驱动程序之止，倘若由此引发，则打开一些游戏程序时就会产生非法操作，有时打开一此网页也会出现这种程况。（3） 内存质量不好，降低内存速度也可能会解决这个问题。（4） 软件不兼容，如，IE 5。5在Windows 98 SE 上，当打开多个网页也会产生非法操作。

很大吧，现在的NOSQL不就是这种原理吗，专门用来处理大数据的。

用hashmap>作为数据结构，然后，添加删除什么的就在hashmap里面的hashset加一个A比如说

看源码去吧

这个是基础题呀，主要看你对常用的东西是否真的了解如果只是会用，而不了解原理，他们就认为你没有专研的精神也就是说潜力不大

上一篇文章 HashMap的底层原理探索 我们分析了JDK1.7中Hashmap的源码实现，但是在JDK1.8的时候HashMap的实现做了很大的变动和优化。1.7和1.7之前HashMap都是“数组+链表”实现的，1.8之后就是“数组+（链表或红黑树）”来实现的了。这里我特地将“链表或红黑树”用一对括号括在一起，因为HashMap底层依旧是一个数组，然后数组中的元素是链表或者红黑树来实现的。 HashMap的实现就先介绍到这，下面就先讲一下红黑树，然后才能理解为什么要用红黑树来优化HashMap，用红黑树有什么好处。 在介绍红黑树之前我们要先理解二叉查找树的数据结构。下面简单介绍一下。 上面这张图就是一个二叉查找树。二叉查找树有如下几条特性 （1）.左子树上所有结点的值均小于或等于它的根结点的值。 （2）.右子树上所有结点的值均大于或等于它的根结点的值。 （3）.左、右子树也分别为二叉排序树 那既然他名字中是有“查找”的，那么他是怎么查找的呢？比如我们要查找10这个元素，查找过程为：首先找到根节点，然后根据二叉查找树的第一二条特性，我们知道要查找的10>9所以是在根节点的右边去查找，找到13，10<13,所以接着在13的左边找，找到11,10<11,继续在11的左边查找，这样就找到了10.这其实就是二分查找的思想。最后我们要查出结果所需的最大次数就是二叉树的高度！（二分查找的思想:找到数组的中间位置的元素v，将数组分成>v和<v两部分，然后将v和要查找的数据进行一个比较，如果大于v那么就在>v的部分再次进行二分查找，否则就在<v的部分进行二分查找，直到找到对应的元素。） 那既然要查出结果所需的最大次数就是二叉树的高度，那这个高度会不会有时候很长呢？ 比如我们依次插入 根节点为9如下五个节点：7,6,5,4,3。依照二叉查找树的特性，结果会变成什么样呢？7,6,5,4,3一个比一个小，那么就会成一条直线，也就是成为了线性的查询，时间复杂度变成了O（N）级别。为了解决这种情况，该红黑树出场了。 红黑树其实就是一种 自平衡 的二叉查找树。他这个自平衡的特性就是对HashMap中链表可能会很长做出的优化。 红黑树是每个节点都带有颜色属性的二叉查找树，颜色或红色或黑色。在二叉查找树强制一般要求以外，对于任何有效的红黑树我们增加了如下的额外要求: 性质1. 节点是红色或黑色。 性质2. 根节点是黑色。 性质3 每个叶节点（NIL节点，空节点）是黑色的。 性质4 每个红色节点的两个子节点都是黑色。(从每个叶子到根的所有路径上不能有两个连续的红色节点) 性质5. 从任一节点到其每个叶子的所有路径都包含相同数目的黑色节点。 下面这棵树就是一个典型的红黑树 红黑树那么多规则，那么在插入和删除元素会不会破坏红黑树的规则呢？什么情况下会破坏？什么情况下不会？ 比如我们向原红黑树插入为14的新节点就不会破坏规则 向原红黑树插入值为21的新节点就破坏了规则 那么红黑树是怎么维护这个二叉查找树的自平衡性的呢？ 红黑树通过 “变色”和“旋转” 来维护红黑树的规则，变色就是让黑的变成红的，红的变成黑的，旋转又分为“左旋转”和“右旋转”。这个比较复杂，容易晕，我们就只要知道红黑树就是通过这种方式来实现它的自平衡性就行了。 JDK1.7的时候是使用一个Entry数组来存储数据，用key的hashcode取模来决定key会被放到数组里的位置，如果hashcode相同，或者hashcode取模后的结果相同（hash collision），那么这些key会被定位到Entry数组的同一个格子里，这些key会形成一个链表。在hashcode特别差的情况下，比方说所有key的hashcode都相同，这个链表可能会很长，那么put/get操作都可能需要遍历这个链表。也就是说时间复杂度在最差情况下会退化到O(n) 红黑树我们大致了解了，他的好处就是他的自平衡性，让他这棵树的最大高度为2log(n+1)，n是树的节点数。那么红黑树的复杂度就只有 O(log n)。 下面我们通过追踪JDK1.8 HashMap的put方法的源码来理解 put方法调用了putVal方法 通过putVal方法可以看到这里的数组和1.7不同，是使用了一个Node数组来存储数据。那这个Node和1.7里面的Entry的区别是什么呢？ HashMap中的红黑树节点 采用的是TreeNode 类 TreeNode和Entry都是Node的子类，也就说Node可能是链表结构，也可能是红黑树结构。 如果插入的key的hashcode相同，那么这些key也会被定位到Node数组的同一个格子里。如果同一个格子里的key不超过8个，使用链表结构存储。如果超过了8个，那么会调用treeifyBin函数，将链表转换为红黑树。 先分析到这。。。。。

Hashtable的实现方法里面都添加了synchronized关键字来确保线程同步，因此相对而言HashMap性能会高一些，我们平时使用时若无特殊需求建议使用HashMap，在多线程环境下若使用HashMap需要使用Collections.synchronizedMap()方法来获取一个线程安全的集合（Collections.synchronizedMap()实现原理是Collections定义了一个SynchronizedMap的内部类，这个类实现了Map接口，在调用方法时使用synchronized来保证线程同步,当然了实际上操作的还是我们传入的HashMap实例，简单的说就是Collections.synchronizedMap()方法帮我们在操作HashMap时自动添加了synchronized来实现线程同步，类似的其它Collections.synchronizedXX方法也是类似原理）

上面的仁兄讲的挺清楚的，回楼主的追问，hash值是不会一样的

HashMap在实际开发中用到的频率非常高，面试中也是热点。所以决定写一篇文章进行分析，希望对想看源码的人起到一些帮助，看之前需要对链表比较熟悉。 以下都是我自己的理解，欢迎讨论，写的不好轻喷。 HashMap中的数据结构为散列表，又名哈希表。在这里我会对散列表进行一个简单的介绍，在此之前我们需要先回顾一下 数组 、 链表 的优缺点。 数组和链表的优缺点取决于他们各自在内存中存储的模式，也就是直接使用 顺序存储 或 链式存储 导致的。无论是数组还是链表，都有明显的缺点。而在实际业务中，我们想要的往往是寻址、删除、插入性能都很好的数据结构，散列表就是这样一种结构，它巧妙的结合了数组与链表的优点，并将其缺点弱化（并不是完全消除） 散列表的做法是将key映射到数组的某个下标，存取的时候通过key获取到下标（index）然后通过下标直接存取。速度极快，而将key映射到下标需要使用 散列函数 ，又名 哈希函数 。说到哈希函数可能有人已经想到了，如何将key映射到数组的下标。 图中计算下标使用到了以下两个函数： 值得注意的是，下标并不是通过hash函数直接得到的，计算下标还要对hash值做index()处理。 Ps：在散列表中，数组的格子叫做 桶 ，下标叫做 桶号 ，桶可以包含一个key-value对，为了方便理解，后文不会使用这两个名词。 以下是哈希碰撞相关的说明： 以下是下标冲突相关的说明： 很多人认为哈希值的碰撞和下标冲突是同一个东西，其实不是的，它们的正确关系是这样的， hashCode发生碰撞，则下标一定冲突；而下标冲突，hashCode并不一定碰撞 上文提到，在jdk1.8以前HashMap的实现是 散列表 = 数组 + 链表 ，但是到目前为止我们还没有看到链表起到的作用。事实上，HashMap引入链表的用意就是解决下标冲突。 下图是引入链表后的散列表： 如上图所示，左边的竖条，是一个大小为16的数组，其中存储的是链表的头结点，我们知道，拥有链表的头结点即可访问整个链表，所以认为这个数组中的每个下标都存储着一个链表。其具体做法是，如果发现下标冲突，则 后插入的节点以链表的形式追加到前一个节点的后面 。 这种使用链表解决冲突的方法叫做： 拉链法 （又叫链地址法）。HashMap使用的就是拉链法，拉链法是冲突发生以后的解决方案。 Q：有了拉链法，就不用担心发生冲突吗？ A：并不是！由于冲突的节点会不停的在链表上追加，大量的冲突会导致单个链表过长，使查询性能降低。所以一个好的散列表的实现应该从源头上减少冲突发生的可能性，冲突发生的概率和哈希函数返回值的均匀程度有直接关系，得到的哈希值越均匀，冲突发生的可能性越小。为了使哈希值更均匀，HashMap内部单独实现了hash()方法。 以上是散列表的存储结构，但是在被运用到HashMap中时还有其他需要注意的地方，这里会详细说明。 现在我们清楚了散列表的存储结构，细心的人应该已经发现了一个问题：Java中数组的长度是固定的， 无论哈希函数是否均匀，随着插入到散列表中数据的增多，在数组长度不变的情况下，链表的长度会不断增加 。这会导致链表查询性能不佳的缺点出现在散列表上，从而使散列表失去原本的意义。为了解决这个问题，HashMap引入了扩容与负载因子。 以下是和扩容相关的一些概念和解释： Ps： 扩容要重新计算下标 ， 扩容要重新计算下标 ， 扩容要重新计算下标 ，因为下标的计算和数组长度有关，长度改变，下标也应当重新计算。 在1.8及其以上的jdk版本中，HashMap又引入了红黑树。 红黑树的引入被用于替换链表，上文说到，如果冲突过多，会导致链表过长，降低查询性能，均匀的hash函数能有效的缓解冲突过多，但是并不能完全避免。所以HashMap加入了另一种解决方案，在往链表后追加节点时，如果发现链表长度达到8，就会将链表转为红黑树，以此提升查询的性能。

回顾一下基本概念： 一. put方法 HashMap使用哈希算法得到数组中保存的位置，然后调用put方法将key-value对保存到table变量中。我们通过图来演示一下存储的过程。 简单解释一下： 我们关注一下这里面最重要的三个方法，hash()，putVal()，resize(). 1. hash方法 我们通过hash方法计算索引，得到数组中保存的位置，看一下源码 我们可以看到HashMap中的hash算法是通过key的hashcode值与其hashcode右移16位后得到的值进行异或运算得到的，那么为什么不直接使用key.hashCode()，而要进行异或操作？我们知道hash的目的是为了得到进行索引，而hash是有可能冲突的，也就是不同的key得到了同样的hash值，这样就很容易产业碰撞，如何减少这种情况的发生呢，就通过上述的hash(Object key)算法将hashcode 与 hashcode的低16位做异或运算，混合了高位和低位得出的最终hash值，冲突的概率就小多了。举个例子： 我们的hash(Object key)算法一个道理，最终的hash值混合了高位和低位的信息，掺杂的元素多了，那么最终hash值的随机性越大，而HashMap的table下标依赖于最终hash值与table.length()-1的&运算，这里的&运算类似于挑包子的过程，自然冲突就小得多了。计算过程如下： 2. putVal方法 通过putVal方法将传递的key-value对添加到数组table中。 3. resize方法 HashMap通过resize()方法进行扩容，容量规则为2的幂次 二. get方法 我们先简单说一下get(Object key)流程，通过传入的key通过hash()算法得到hash值，在通过(n - 1) & hash找到数组下标，如果数组下标所对应的node值正好key一样就返回，否则找到node.next找到下一个节点，看是否是treenNode，如果是，遍历红黑树找到对应node，如果不是遍历链表找到node。我们看一下源码 这几个方法是核心，虽然HashMap还有很多常用方法，不过大体和这几个方法有关，或者实现逻辑相似，这里就不再多说了。 三. 总结 本文在上一章基本概念和底层结构的基础上，从源码的角度讲解了扩容机制以及存取原理，主要分析了put方法和get方法，put方法的核心为hash()，putVal()，resize()，get方法的核心为getNode()。

Java中的HashMap是以键值对(key-value)的形式存储元素的。HashMap需要一个hash函数，它使用hashCode()和equals()方法来向集合/从集合添加和检索元素。当调用put()方法的时候，HashMap会计算key的hash值，然后把键值对存储在集合中合适的索引上。如果key已经存在了，value会被更新成新值。HashMap的一些重要的特性是它的容量(capacity)，负载因子(loadfactor)和扩容极限(thresholdresizing)。

我们常见的有集合数据有三种结构：1、数组结构 2、链表结构 3、哈希表结构 下面我们来看看各自的数据结构的特点： 而我们常见的HashMap就是这样的一种数据结构 （1）、首先将k,v封装到Node对象当中（节点）。 （2）、然后它的底层会调用K的hashCode()方法得出hash值。 （3）、通过哈希表函数/哈希算法，将hash值转换成数组的下标，下标位置上如果没有任何元素，就把Node添加到这个位置上。如果说下标对应的位置上有链表。此时，就会拿着k和链表上每个节点的k进行equal。如果所有的equals方法返回都是false，那么这个新的节点将被添加到链表的末尾。如其中有一个equals返回了true，那么这个节点的value将会被覆盖。 (1)、先调用k的hashCode()方法得出哈希值，并通过哈希算法转换成数组的下标。 (2)、通过上一步哈希算法转换成数组的下标之后，在通过数组下标快速定位到某个位置上。重点理解如果这个位置上什么都没有，则返回null。如果这个位置上有单向链表，那么它就会拿着参数K和单向链表上的每一个节点的K进行equals，如果所有equals方法都返回false，则get方法返回null。如果其中一个节点的K和参数K进行equals返回true，那么此时该节点的value就是我们要找的value了，get方法最终返回这个要找的value。 原因 : 增删是在链表上完成的，而查询只需扫描部分，则效率高。 HashMap集合的key，会先后调用两个方法，hashCode and equals方法，这这两个方法都需要重写。 因为equals方法默认比较的是两个对象的内存地址 https://blog.csdn.net/qq_37840993/article/details/108048597

hashmap底层实现原理是SortedMap接口能够把它保存的记录根据键排序，默认是按键值的升序排序，也可以指定排序的比较器，当用Iterator遍历TreeMap时，得到的记录是排过序的。如果使用排序的映射，建议使用TreeMap。在使用TreeMap时，key必须实现Comparable接口或者在构造TreeMap传入自定义的Comparator，否则会在运行时抛出java.lang.ClassCastException类型的异常。Hashtable是遗留类，很多映射的常用功能与HashMap类似，不同的是它承自Dictionary类，并且是线程安全的，任一时间只有一个线程能写Hashtable从结构实现来讲，HashMap是：数组+链表+红黑树（JDK1.8增加了红黑树部分）实现的。扩展资料从源码可知，HashMap类中有一个非常重要的字段，就是 Node[] table，即哈希桶数组。Node是HashMap的一个内部类，实现了Map.Entry接口，本质是就是一个映射(键值对)，除了K，V，还包含hash和next。HashMap就是使用哈希表来存储的。哈希表为解决冲突，采用链地址法来解决问题，链地址法，简单来说，就是数组加链表的结合。在每个数组元素上都一个链表结构，当数据被Hash后，得到数组下标，把数据放在对应下标元素的链表上。如果哈希桶数组很大，即使较差的Hash算法也会比较分散，如果哈希桶数组数组很小，即使好的Hash算法也会出现较多碰撞，所以就需要在空间成本和时间成本之间权衡，其实就是在根据实际情况确定哈希桶数组的大小，并在此基础上设计好的hash算法减少Hash碰撞。

与特征码的用法一样。在hash前加上“magnet:?xt=urn:btih:”，再复制进迅雷里面，就能得到种子。torrent文件本质上是文本文件，包含Tracker信息和文件信息两部分。Tracker信息主要是BT下载中需要用到的Tracker服务器的地址和针对Tracker服务器的设置，文件信息是根据对目标文件的计算生成的，计算结果根据BitTorrent协议内的B编码规则进行编码。它的主要原理是需要把提供下载的文件虚拟分成大小相等的块，块大小必须为2k的整数次方（由于是虚拟分块，硬盘上并不产生各个块文件），并把每个块的索引信息和Hash验证码写入.torrent文件中；所以，.torrent文件就是被下载文件的“索引”。根据BitTorrent协议，文件发布者会根据要发布的文件生成提供一个种子文件。下载者要下载文件内容，需要先得到相应的种子文件，然后使用BT客户端软件进行下载。

参考论文来源 《Similarity estimation techniques from rounding algorithms》 。 介绍下这个算法主要原理，为了便于理解尽量不使用数学公式，分为这几步(标准做法)： 完整的算指纹的算法： 按照这种市面上的通用做法，传入的map 可以是无序的 有一个小问题提请注意 直接用 1<<n 得到 2 的n 次方到31次方以上就会超出int 的取值范围， 运算时直接用 (long)1<<n 或者 1l << n 就行了 所以 nlp-cn 的算法可以简化如下： 两种方式的比较： 这里先引入一个概念： 抽屉原理 假设我们要寻找海明距离3以内的数值，根据抽屉原理，只要我们将整个64位的二进制串划分为4块，无论如何，匹配的两个simhash code之间 至少 有一块区域是完全相同的，如下图所示： 由于我们无法事先得知完全相同的是哪一块区域，因此我们必须采用存储多份table的方式。在本例的情况下，我们需要存储4份table，并将64位的simhash code等分成4份；对于每一个输入的code，我们通过精确匹配的方式，查找前16位相同的记录作为候选记录，如下图所示： 让我们来总结一下上述算法的实质： 假定我们最大判重海明距离为MAX_HD 1、将64位的二进制串等分成MAX_HD+1块 2、PUT操作：调整上述64位二进制，将任意一块作为前16位，总共有MAX_HD+1种组合，生成MAX_HD+1份table 3、GET操作：采用精确匹配的方式在MAX_HD+1份table中查找前16位，若找不到，说明不重复，做PUT操作；若找到了，则对剩余链做海明距离计算。 4、如果样本库中存有2^34 （差不多10亿）的哈希指纹，则每个table返回2^(34-16)=262144个候选结果，大大减少了海明距离的计算成本 为何要分桶？ 两个字符串通过SimHash码和海明距离比较好判断是否相似，假设计算海明距离的时间为基本操作时间。如果有海量的数据，一一比较计算的次数为 1 + 2 + 3 + ......+ n ，时间复杂度为 O(n^2) 级别。这样的时间复杂度肯定是不能接受的。 构建索引 将SimHashCode添加到索引 查询与索引库中比较的最近的海明距离 其中 bit[n] = 2^n ,索引降低比较时算法时间复杂度的方法是 将SimHashCode 比特位分成8段 其实这里也是用上了抽屉原理的，各位看官自己思考下吧。 分词 -->另写一篇博客说明 需要说明的一点： 分词的时候需要去掉停用词等噪音词，分词是该算法特征抽取的关键一步。

用JCO.createTable，构造函数是不可见的。

Hash，一般翻译做"散列"，也有直接音译为"哈希"的，就是把任意长度的输入（又叫做预映射， pre-image），通过散列算法，变换成固定长度的输出，该输出就是散列值。这种转换是一种压缩映射，也就是，散列值的空间通常远小于输入的空间，不同的输入可能会散列成相同的输出，而不可能从散列值来唯一的确定输入值。 数学表述为：h = H(M) ，其中H( )--单向散列函数，M--任意长度明文，h--固定长度散列值。 在信息安全领域中应用的Hash算法，还需要满足其他关键特性： 第一当然是单向性(one-way)，从预映射，能够简单迅速的得到散列值，而在计算上不可能构造一个预映射，使其散列结果等于某个特定的散列值，即构造相应的M=H-1(h)不可行。这样，散列值就能在统计上唯一的表征输入值，因此，密码学上的 Hash 又被称为"消息摘要(message digest)"，就是要求能方便的将"消息"进行"摘要"，但在"摘要"中无法得到比"摘要"本身更多的关于"消息"的信息。 第二是抗冲突性(collision-resistant)，即在统计上无法产生2个散列值相同的预映射。给定M，计算上无法找到M"，满足H(M)=H(M") ，此谓弱抗冲突性；计算上也难以寻找一对任意的M和M"，使满足H(M)=H(M") ，此谓强抗冲突性。要求"强抗冲突性"主要是为了防范所谓"生日攻击(birthday attack)"，在一个10人的团体中，你能找到和你生日相同的人的概率是2.4%，而在同一团体中，有2人生日相同的概率是11.7%。类似的，当预映射的空间很大的情况下，算法必须有足够的强度来保证不能轻易找到"相同生日"的人。 第三是映射分布均匀性和差分分布均匀性，散列结果中，为 0 的 bit 和为 1 的 bit ，其总数应该大致相等；输入中一个 bit 的变化，散列结果中将有一半以上的 bit 改变，这又叫做"雪崩效应(avalanche effect)"；要实现使散列结果中出现 1bit 的变化，则输入中至少有一半以上的 bit 必须发生变化。其实质是必须使输入中每一个 bit 的信息，尽量均匀的反映到输出的每一个 bit 上去；输出中的每一个 bit，都是输入中尽可能多 bit 的信息一起作用的结果。 Damgard 和 Merkle 定义了所谓"压缩函数(compression function)"，就是将一个固定长度输入，变换成较短的固定长度的输出，这对密码学实践上 Hash 函数的设计产生了很大的影响。Hash函数就是被设计为基于通过特定压缩函数的不断重复"压缩"输入的分组和前一次压缩处理的结果的过程，直到整个消息都被压缩完毕，最后的输出作为整个消息的散列值。尽管还缺乏严格的证明，但绝大多数业界的研究者都同意，如果压缩函数是安全的，那么以上述形式散列任意长度的消息也将是安全的。这就是所谓 Damgard/Merkle 结构： 在下图中，任意长度的消息被分拆成符合压缩函数输入要求的分组，最后一个分组可能需要在末尾添上特定的填充字节，这些分组将被顺序处理，除了第一个消息分组将与散列初始化值一起作为压缩函数的输入外，当前分组将和前一个分组的压缩函数输出一起被作为这一次压缩的输入，而其输出又将被作为下一个分组压缩函数输入的一部分，直到最后一个压缩函数的输出，将被作为整个消息散列的结果。 MD5 和 SHA1 可以说是目前应用最广泛的Hash算法，而它们都是以 MD4 为基础设计的。 1) MD4 MD4(RFC 1320)是 MIT 的 Ronald L. Rivest 在 1990 年设计的，MD 是 Message Digest 的缩写。它适用在32位字长的处理器上用高速软件实现--它是基于 32 位操作数的位操作来实现的。它的安全性不像RSA那样基于数学假设，尽管 Den Boer、Bosselaers 和 Dobbertin 很快就用分析和差分成功的攻击了它3轮变换中的 2 轮，证明了它并不像期望的那样安全，但它的整个算法并没有真正被破解过，Rivest 也很快进行了改进。 下面是一些MD4散列结果的例子： MD4 ("") = 31d6cfe0d16ae931b73c59d7e0c089c0 MD4 ("a") = bde52cb31de33e46245e05fbdbd6fb24 MD4 ("abc") = a448017aaf21d8525fc10ae87aa6729d MD4 ("message digest") = d9130a8164549fe818874806e1c7014b MD4 ("abcdefghijklmnopqrstuvwxyz") = d79e1c308aa5bbcdeea8ed63df412da9 MD4 ("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789") = 043f8582f241db351ce627e153e7f0e4 MD4 ("12345678901234567890123456789012345678901234567890123456789012345678901234567890") = e33b4ddc9c38f2199c3e7b164fcc0536 2) MD5 MD5(RFC 1321)是 Rivest 于1991年对MD4的改进版本。它对输入仍以512位分组，其输出是4个32位字的级联，与 MD4 相同。它较MD4所做的改进是： 1) 加入了第四轮 2) 每一步都有唯一的加法常数； 3) 第二轮中的G函数从((X ∧ Y) ∨ (X ∧ Z) ∨ (Y ∧ Z)) 变为 ((X ∧ Z) ∨ (Y ∧ ～Z))以减小其对称性； 4) 每一步都加入了前一步的结果，以加快"雪崩效应"； 5) 改变了第2轮和第3轮中访问输入子分组的顺序，减小了形式的相似程度； 6) 近似优化了每轮的循环左移位移量，以期加快"雪崩效应"，各轮的循环左移都不同。 尽管MD5比MD4来得复杂，并且速度较之要慢一点，但更安全，在抗分析和抗差分方面表现更好。 消息首先被拆成若干个512位的分组，其中最后512位一个分组是"消息尾+填充字节(100...0)+64 位消息长度"，以确保对于不同长度的消息，该分组不相同。64位消息长度的限制导致了MD5安全的输入长度必须小于264bit，因为大于64位的长度信息将被忽略。而4个32位寄存器字初始化为A=0x01234567，B=0x89abcdef，C=0xfedcba98，D=0x76543210，它们将始终参与运算并形成最终的散列结果。 接着各个512位消息分组以16个32位字的形式进入算法的主循环，512位消息分组的个数据决定了循环的次数。主循环有4轮，每轮分别用到了非线性函数 F(X, Y, Z) = (X ∧ Y) ∨ (～X ∧ Z) G(X, Y, Z) = (X ∧ Z) ∨ (Y ∧ ～Z) H(X, Y, Z) =X ⊕ Y ⊕ Z I(X, Y, Z) = X ⊕ (Y ∨ ～Z) 这4轮变换是对进入主循环的512位消息分组的16个32位字分别进行如下操作：将A、B、C、D的副本a、b、c、d中的3个经F、G、H、I运算后的结果与第4个相加，再加上32位字和一个32位字的加法常数，并将所得之值循环左移若干位，最后将所得结果加上a、b、c、d之一，并回送至ABCD，由此完成一次循环。 所用的加法常数由这样一张表T[i]来定义，其中i为1...64，T[i]是i的正弦绝对值之4294967296次方的整数部分，这样做是为了通过正弦函数和幂函数来进一步消除变换中的线性性。 当所有512位分组都运算完毕后，ABCD的级联将被输出为MD5散列的结果。下面是一些MD5散列结果的例子： MD5 ("") = d41d8cd98f00b204e9800998ecf8427e MD5 ("a") = 0cc175b9c0f1b6a831c399e269772661 MD5 ("abc") = 900150983cd24fb0d6963f7d28e17f72 MD5 ("message digest") = f96b697d7cb7938d525a2f31aaf161d0 MD5 ("abcdefghijklmnopqrstuvwxyz") = c3fcd3d76192e4007dfb496cca67e13b MD5 ("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789") = d174ab98d277d9f5a5611c2c9f419d9f MD5 ("12345678901234567890123456789012345678901234567890123456789012345678901234567890") = 57edf4a22be3c955ac49da2e2107b67a 参考相应RFC文档可以得到MD4、MD5算法的详细描述和算法的C源代码。 3) SHA1 及其他 SHA1是由NIST NSA设计为同DSA一起使用的，访问http://www.itl.nist.gov/fipspubs可以得到它的详细规范--[/url]"FIPS PUB 180-1 SECURE HASH STANDARD"。它对长度小于264的输入，产生长度为160bit的散列值，因此抗穷举(brute-force)性更好。SHA-1 设计时基于和MD4相同原理,并且模仿了该算法。因为它将产生160bit的散列值，因此它有5个参与运算的32位寄存器字，消息分组和填充方式与MD5相同，主循环也同样是4轮，但每轮进行20次操作，非线性运算、移位和加法运算也与MD5类似，但非线性函数、加法常数和循环左移操作的设计有一些区别，可以参考上面提到的规范来了解这些细节。下面是一些SHA1散列结果的例子： SHA1 ("abc") = a9993e36 4706816a ba3e2571 7850c26c 9cd0d89d SHA1 ("abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq") = 84983e44 1c3bd26e baae4aa1 f95129e5 e54670f1 其他一些知名的Hash算法还有MD2、N-Hash、RIPE-MD、HAVAL等等。上面提到的这些都属于"纯"Hash算法。还有另2类Hash算法，一类就是基于对称分组算法的单向散列算法，典型的例子是基于DES的所谓Davies-Meyer算法，另外还有经IDEA改进的Davies-Meyer算法，它们两者目前都被认为是安全的算法。另一类是基于模运算/离散对数的，也就是基于公开密钥算法的，但因为其运算开销太大，而缺乏很好的应用前景。 没有通过分析和差分攻击考验的算法，大多都已经夭折在实验室里了，因此，如果目前流行的Hash算法能完全符合密码学意义上的单向性和抗冲突性，就保证了只有穷举，才是破坏Hash运算安全特性的唯一方法。为了对抗弱抗冲突性，我们可能要穷举个数和散列值空间长度一样大的输入，即尝试2^128或2^160个不同的输入，目前一台高档个人电脑可能需要10^25年才能完成这一艰巨的工作，即使是最高端的并行系统，这也不是在几千年里的干得完的事。而因为"生日攻击"有效的降低了需要穷举的空间，将其降低为大约1.2*2^64或1.2*2^80，所以，强抗冲突性是决定Hash算法安全性的关键。 在NIST新的 Advanced Encryption Standard (AES)中，使用了长度为128、192、256bit 的密钥，因此相应的设计了 SHA256、SHA384、SHA512，它们将提供更好的安全性。 Hash算法在信息安全方面的应用主要体现在以下的3个方面： 1) 文件校验 我们比较熟悉的校验算法有奇偶校验和CRC校验，这2种校验并没有抗数据篡改的能力，它们一定程度上能检测并纠正数据传输中的信道误码，但却不能防止对数据的恶意破坏。 MD5 Hash算法的"数字指纹"特性，使它成为目前应用最广泛的一种文件完整性校验和(Checksum)算法，不少Unix系统有提供计算md5 checksum的命令。它常被用在下面的2种情况下： 第一是文件传送后的校验，将得到的目标文件计算 md5 checksum，与源文件的md5 checksum 比对，由两者 md5 checksum 的一致性，可以从统计上保证2个文件的每一个码元也是完全相同的。这可以检验文件传输过程中是否出现错误，更重要的是可以保证文件在传输过程中未被恶意篡改。一个很典型的应用是ftp服务，用户可以用来保证多次断点续传，特别是从镜像站点下载的文件的正确性。 更出色的解决方法是所谓的代码签名，文件的提供者在提供文件的同时，提供对文件Hash值用自己的代码签名密钥进行数字签名的值，及自己的代码签名证书。文件的接受者不仅能验证文件的完整性，还可以依据自己对证书签发者和证书拥有者的信任程度，决定是否接受该文件。浏览器在下载运行插件和java小程序时，使用的就是这样的模式。 第二是用作保存二进制文件系统的数字指纹，以便检测文件系统是否未经允许的被修改。不少系统管理/系统安全软件都提供这一文件系统完整性评估的功能，在系统初始安装完毕后，建立对文件系统的基础校验和数据库，因为散列校验和的长度很小，它们可以方便的被存放在容量很小的存储介质上。此后，可以定期或根据需要，再次计算文件系统的校验和，一旦发现与原来保存的值有不匹配，说明该文件已经被非法修改，或者是被病毒感染，或者被木马程序替代。TripWire就提供了一个此类应用的典型例子。 更完美的方法是使用"MAC"。"MAC" 是一个与Hash密切相关的名词，即信息鉴权码(Message Authority Code)。它是与密钥相关的Hash值，必须拥有该密钥才能检验该Hash值。文件系统的数字指纹也许会被保存在不可信任的介质上，只对拥有该密钥者提供可鉴别性。并且在文件的数字指纹有可能需要被修改的情况下，只有密钥的拥有者可以计算出新的散列值，而企图破坏文件完整性者却不能得逞。 2) 数字签名 Hash 算法也是现代密码体系中的一个重要组成部分。由于非对称算法的运算速度较慢，所以在数字签名协议中，单向散列函数扮演了一个重要的角色。 在这种签名协议中，双方必须事先协商好双方都支持的Hash函数和签名算法。 签名方先对该数据文件进行计算其散列值，然后再对很短的散列值结果--如Md5是16个字节，SHA1是20字节，用非对称算法进行数字签名操作。对方在验证签名时，也是先对该数据文件进行计算其散列值，然后再用非对称算法验证数字签名。 对 Hash 值，又称"数字摘要"进行数字签名，在统计上可以认为与对文件本身进行数字签名是等效的。而且这样的协议还有其他的优点： 首先，数据文件本身可以同它的散列值分开保存，签名验证也可以脱离数据文件本身的存在而进行。 再者，有些情况下签名密钥可能与解密密钥是同一个，也就是说，如果对一个数据文件签名，与对其进行非对称的解密操作是相同的操作，这是相当危险的，恶意的破坏者可能将一个试图骗你将其解密的文件，充当一个要求你签名的文件发送给你。因此，在对任何数据文件进行数字签名时，只有对其Hash值进行签名才是安全的。 3) 鉴权协议 如下的鉴权协议又被称作"挑战--认证模式：在传输信道是可被侦听，但不可被篡改的情况下，这是一种简单而安全的方法。 需要鉴权的一方，向将被鉴权的一方发送随机串（"挑战"），被鉴权方将该随机串和自己的鉴权口令字一起进行 Hash 运算后，返还鉴权方，鉴权方将收到的Hash值与在己端用该随机串和对方的鉴权口令字进行 Hash 运算的结果相比较（"认证"），如相同，则可在统计上认为对方拥有该口令字，即通过鉴权。 POP3协议中就有这一应用的典型例子： S: +OK POP3 server ready <1896.697170952@dbc.mtview.ca.us> C: APOP mrose c4c9334bac560ecc979e58001b3e22fb S: +OK maildrop has 1 message (369 octets) 在上面的一段POP3协议会话中，双方都共享的对称密钥（鉴权口令字）是tanstaaf，服务器发出的挑战是<1896.697170952@dbc.mtview.ca.us>，客户端对挑战的应答是MD5("<1896.697170952@dbc.mtview.ca.us>tanstaaf") = c4c9334bac560ecc979e58001b3e22fb，这个正确的应答使其通过了认证。 散列算法长期以来一直在计算机科学中大量应用，随着现代密码学的发展，单向散列函数已经成为信息安全领域中一个重要的结构模块，我们有理由深入研究其设计理论和应用方法。

HashMap的工作原理是近年来常见的Java面试题。几乎每个Java程序员都知道HashMap，都知道哪里要用HashMap，知道HashTable和HashMap之间的区别，那么为何这道面试题如此特殊呢？是因为这道题考察的深度很深。这题经常出现在高级或中高级面试中。投资银行更喜欢问这个问题，甚至会要求你实现HashMap来考察你的编程能力。ConcurrentHashMap和其它同步集合的引入让这道题变得更加复杂。让我们开始探索的旅程吧！

HashMap的实现原理：首先有一个每个元素都是链表（可能表述不准确）的数组，当添加一个元素（key-value）时，就首先计算元素key的hash值，以此确定插入数组中的位置，但是可能存在同一hash值的元素已经被放在数组同一位置了。这时就添加到同一hash值的元素的后面，他们在数组的同一位置，但是形成了链表，同一各链表上的Hash值是相同的，所以说数组存放的是链表。而当链表长度太长时，链表就转换为红黑树，这样大大提高了查找的效率。当链表数组的容量超过初始容量的0.75时，再散列将链表数组扩大2倍，把原链表数组的搬移到新的数组中。扩展资料HashMap和Hashtable的区别1、HashMap可以接受为null的键值（key）和值（value），而Hashtable则不行。2、HashMap是非synchronized，而Hashtable是synchronized。意味着Hashtable是线程安全的，多个线程可以共享一个Hashtable；而如果没有正确的同步的话，多个线程是不能共享HashMap的。3、由于Hashtable是线程安全的也是synchronized，所以在单线程环境下它比HashMap要慢。如果不需要同步，只需要单一线程，那么使用HashMap性能要好过Hashtable。5、HashMap不能保证随着时间的推移Map中的元素次序是不变的。

HashMap的实现原理：首先有一个每个元素都是链表（可能表述不准确）的数组，当添加一个元素（key-value）时，就首先计算元素key的hash值，以此确定插入数组中的位置，但是可能存在同一hash值的元素已经被放在数组同一位置了。这时就添加到同一hash值的元素的后面，他们在数组的同一位置，但是形成了链表，同一各链表上的Hash值是相同的，所以说数组存放的是链表。而当链表长度太长时，链表就转换为红黑树，这样大大提高了查找的效率。当链表数组的容量超过初始容量的0.75时，再散列将链表数组扩大2倍，把原链表数组的搬移到新的数组中。HashMap和哈希表的关系1、HashMap可以接受为null的键值（key）和值（value），而Hashtable则不行。2、HashMap是非synchronized，而Hashtable是synchronized。意味着Hashtable是线程安全的，多个线程可以共享一个Hashtable；而如果没有正确的同步的话，多个线程是不能共享HashMap的。3、由于Hashtable是线程安全的也是synchronized，所以在单线程环境下它比HashMap要慢。如果不需要同步，只需要单一线程，那么使用HashMap性能要好过Hashtable。5、HashMap不能保证随着时间的推移Map中的元素次序是不变的。

JoanneTakahashiJoanneTakahashi是一名演员，其代表作品《未来战争》《楼梯》《S.F.W.》。外文名：JoanneTakahashi职业：演员合作人物：AnthonyDoublin代表作品：《未来战争》主要作品电影作品电视剧作品人物关系

delphi7以后的版本不清楚，在这个版本中可以用TList代替，Items中可以添加任意对象和结构体指针。取出来的内容必须强制转换，没有泛型的定义。

我的是卸载了open drcom 就没事了 点开有个卸载协议的 你看看

hastags在Instagram可以说是很重要了，为自己的帖子增加一些最受欢迎的hashtags,拥有相同的hashtag的帖子，在搜索结果中也会相对于的得以展现，得到更高的曝光量，但同时竞争也会比较激烈，毕竟很受欢迎嘛， 以下列出的是在Instagram平台上较高的hashtag 标签 市场marketing 的hashtag 1. #marketing 2. #marketingtips 3. #b2cmarketing 4. #b2bmarketing 5. #strategy 6. #mktg 7. #digitalmarketing 8. #marketingstrategy 9. #mobilemarketing 10. #socialmediamarketing 11. #promotion 促销之类的hashtag 1. #contest 2. #[yourbrand]contest 3. #contests 4. #contestalert 5. #contestentry 6. #sweepstakes 7. #[yourbrand]sweepstakes 8. #giveaway 9. #[yourbrandgiveaway] 10. #giveaways 11. #winitwednesday 12. #competition 13. #win 14. #[yourbrand]win 餐馆的hashtag ps:一些做相关周边产品线的可以适当挑选符合本身的hashtag 1. #food 2. #foodie 3. #yummy 4. #nom 5. #hungry 6. #cleaneating 7. #paleo 8. #vegetarian 9. #delish 10. #wine 11. #pizza 12. #pasta 13. #sushi 14. #cocktails 15. #happyhour 时尚零售类的 1. #shopaholics 2. #shoppingaddict 3. #currentlywearing 4. #instastyle 5. #fashionaddict 6. #styleblogger 7. #styleinspo 8. #whatiwore 9. #ootd 10. #gooddeal 音乐的hashtags 1. #musically 2. #musician 3. #singer 4. #singing 5. #talentedmusicians 6. #music 7. #classical 8. #guitar 最受欢迎的100个hashtags【通用】 100. #birthday 99. #red 98. #workout 97. #sweet 96. #wedding 95. #blackandwhite 94. #instalove 93. #fit 92. #instafood 91. #instasize 90. #flowers 89. #iphonesia 88. #tweetgram 87. #design 86. #instafollow 85. #my 84. #webstagram 83. #followback 82. #christmas 81. #work 80. #blue 79. #instacool 78. #work 77. #blue 76. #pink 75. #black 74. #gym 73. #motivation 72. #yummy 71. #healthy 70. #instacool 69. #hot 68. #iphoneonly 67. #instapic 66. #funny 65. #instagram 64. #night 63. #baby 62. #ootd 61. #makeup 60. #cat 59. #girls 58. #cool 57. #lol 56. #party 55. #foodporn 54. #tflers 53. #hair 52. #photo 51. #sunset 50. #vsco 49. #dog 48. #lfl 47. #pretty 46. #f4f 45. #travel 44. #sky 43. #music 42. #swag 41. #followforfollow 40. #beach 39. #beauty 38. #sun 37. #vscocam 36. #bestoftheday 35. #fitness 34. #life 33. #amazing 32. #follow4follow 31. #nofilter 30. #style 29. #instagood 28. #nature 27. #likeforlike 26. #family 25. #art 24. #food 23. #instalike 22. #igers 21. #repost 20. #smile 19. #tagforlikes 18. #fun 17. #girl 16. #instadaily 15. #friends 12. #summer 13. #picoftheday 12. #selfie 11. #follow 10. #followme 9. #fashion 8. #happy 7. #me 6. #cute 5. #beautiful 4. #tbt 3. #photooftheday 2. #instagood 1.#love其他hashtag调研工具网站：这两个网站主要针对instagram,大家在发布的时候可以参考一下。 https://top-hashtags.com/instagram/ http://www.tagblender.net/

你确定这是哈希算法？

前面加magnet:?xt=urn:btih:

自己探索更有意思，用eclipse调试一下呗，看一下values返回的对象是什么类：System.out.println(map.values().getClass().getName());

MD5和SHA-1 HASH 的相同点包括：1. 都是通过对数据进行计算来生成一个校验值，该校验值用来校验数据的完整性。2. 都可以用于安全领域，如文件校验、数字签名等。MD5和SHA-1 HASH 的不同点包括：1. 安全性不同：SHA-1的安全性比MD5高。2. 校验值的长度不同：MD5校验位的长度是16个字节（128位），SHA-1是20个字节（160位）。3. 运行速度不同：SHA-1的运行速度比MD5慢。

利用一种算法将每个文件对应一串码值，利用这串码值可以判断两文件是否相同。

// 说明：Hash函数（即散列函数）在程序设计中的应用目标 ------ 把一个对象通过某种转换机制对应到一个//size_t类型（即unsigned long）的整型值。// 而应用Hash函数的领域主要是 hash表（应用非常广）、密码等领域。// 实现说明：// ⑴、这里使用了函数对象以及泛型技术，使得对所有类型的对象（关键字）都适用。// ⑵、常用类型有对应的偏特化，比如string、char*、各种整形等。// ⑶、版本可扩展，如果你对某种类型有特殊的需要，可以在后面实现专门化。// ⑷、以下实现一般放在头文件中，任何包含它的都可使用hash函数对象。//------------------------------------实现------------------------------------------------#include <string>using std::string;inlinesize_thash_str(const char* s){unsigned long res = 0;for (; *s; ++s)res = 5 * res + *s;returnsize_t(res);}template <class Key>struct hash{size_toperator () (const Key& k) const;};// 一般的对象，比如：vector< queue<string> >；的对象，需要强制转化template < class Key >size_thash<Key>::operator () (const Key& k) const{size_tres = 0;size_tlen = sizeof(Key);const char* p = reinterpret_cast<const char*>(&k);while (len--){res = (res<<1）^*p++;}return res;}// 偏特化template<>size_thash< string >::operator () (const string& str) const{return hash_str(str.c_str());}typedef char* PChar;template<>size_thash<PChar>::operator () (const PChar& s) const{return hash_str(s);}typedef const char* PCChar;template<>size_thash<PCChar>::operator () (const PCChar& s) const{return hash_str(s);}template<> size_t hash<char>::operator () (const char& x) const { return x; }template<> size_t hash<unsigned char>::operator () (const unsigned char& x) const { return x; }template<> size_t hash<signed char>::operator () (const signed char& x) const { return x; }template<> size_t hash<short>::operator () (const short& x) const { return x; }template<> size_t hash<unsigned short>::operator () (const unsigned short& x) const { return x; }template<> size_t hash<int>::operator () (const int& x) const { return x; }template<> size_t hash<unsigned int>::operator () (const unsigned int& x) const { return x; }template<> size_t hash<long>::operator () (const long& x) const { return x; }template<> size_t hash<unsigned long>::operator () (const unsigned long& x) const { return x; }// 使用说明：//// ⑴、使用时首先由于是泛型，所以要加上关键字类型。//// ⑵、其次要有一个函数对象，可以临时、局部、全局的，只要在作用域就可以。//// ⑶、应用函数对象作用于对应类型的对象。//----------------------- hash函数使用举例 -------------------------#include <iostream>#include <vector>#include <string>using namespace std;int main(){vector<string> vstr⑵；vstr[0] = "sjw";vstr[1] = "suninf";hash<string> strhash; // 局部函数对象cout << " Hash value: " << strhash(vstr[0]) << endl;cout << " Hash value: " << strhash(vstr[1]) << endl;cout << " Hash value: " << hash< vector<string> >() (vstr) << endl;cout << " Hash value: " << hash<int>() （100） << endl; // hash<int>() 临时函数对象return 0;}

一致性哈希算法是在1997年由麻省理工学院提出的一种分布式哈希（DHT）算法。其设计目标是为了解决因特网中的热点（Hot spot)问题，初衷和CARP十分类似。一致性Hash是一种特殊的Hash算法，由于其均衡性、持久性的映射特点，被广泛的应用于负载均衡领域，如nginx和memcached都采用了一致性Hash来作为集群负载均衡的方案。一致性哈希算法的目标是，当K个请求key发起请求时。后台增减节点，只会引起K/N的key发生重新映射。即一致性哈希算法，在后台节点稳定时，同一key的每次请求映射到的节点是一样的。而当后台节点增减时，该算法尽量将K个key映射到与之前相同的节点上。优点可扩展性。一致性哈希算法保证了增加或减少服务器时，数据存储的改变最少，相比传统哈希算法大大节省了数据移动的开销。更好地适应数据的快速增长。采用一致性哈希算法分布数据，当数据不断增长时，部分虚拟节点中可能包含很多数据、造成数据在虚拟节点上分布不均衡，此时可以将包含数据多的虚拟节点分裂，这种分裂仅仅是将原有的虚拟节点一分为二、不需要对全部的数据进行重新哈希和划分。虚拟节点分裂后，如果物理服务器的负载仍然不均衡，只需在服务器之间调整部分虚拟节点的存储分布。这样可以随数据的增长而动态的扩展物理服务器的数量，且代价远比传统哈希算法重新分布所有数据要小很多。以上内容参考：百度百科-一致性哈希

　　方法/步骤　　1　　首先要查看文件的 hash值，我们需要借助于工具，百度搜索：hash 工具　　2　　下载完成后打开它　　3　　打开后点击“浏览”按钮　　4　　载入你要查看 hash值的文件，小编以 win7 x64 文件为例来说明　　5　　耐心等待载入完成，载入时间的视你文件大小而定　　6　　完成后我们可以看到相关信息了，其中 MD5、SHA1、CRC32 等值都是唯一的　　7　　为了确认文件是标准原版，我们需要与公布的文件 hash值进行对比，如图，对比发现 SHA1 是一样的，说明这个文件就是官方公布的原版（修改时间是你下载此文件的时间，没有参考价值）

1.[hash]是文件的哈希值，用来打版本号的，[chunkhash]是模块的哈希值，同样可以放在模块的文件名中。2.webpack自带生成hash的功能，可以绑定事件拿到hash对应表。

复制粘贴到迅雷，不是很复杂

*nix系系统：ES(Unix)例子: IvS7aeT4NzQPM说明：Linux或者其他linux内核系统中长度: 13 个字符描述：第1、2位为salt，例子中的"Iv"位salt，后面的为hash值系统：MD5(Unix)例子：$1$12345678$XM4P3PrKBgKNnTaqG9P0T/说明：Linux或者其他linux内核系统中长度：34个字符描述：开始的$1$位为加密标志，后面8位12345678为加密使用的salt,后面的为hash加密算法：2000次循环调用MD5加密系统：SHA-512(Unix)例子：$6$12345678$U6Yv5E1lWn6mEESzKen42o6rbEm说明：Linux或者其他linux内核系统中长度: 13 个字符描述：开始的$6$位为加密标志，后面8位为salt，后面的为hash加密算法：5000次的SHA-512加密系统：SHA-256(Unix)例子：$5$12345678$jBWLgeYZbSvREnuBr5s3gp13vqi说明：Linux或者其他linux内核系统中长度: 55 个字符描述：开始的$5$位为加密标志，后面8位为salt，后面的为hash加密算法：5000次的SHA-256加密系统：MD5(APR)例子：$apr1$12345678$auQSX8Mvzt.tdBi4y6Xgj.说明：Linux或者其他linux内核系统中长度：37个字符描述：开始的$apr1$位为加密标志，后面8位为salt，后面的为hash加密算法：2000次循环调用MD5加密windows系统：windows例子：Admin:b474d48cdfc4974d86ef4d24904cdd91长度：98个字符加密算法：MD4(MD4(Unicode($pass)).Unicode(strtolower($username)))mysql系统：mysql例子：606717496665bcba说明：老版本的MySql中长度：8字节（16个字符）说明：包括两个字节，且每个字的值不超过0x7fffffff系统：MySQL5例子：*E6CC90B878B948C35E92B003C792C46C58C4AF40说明：较新版本的MySQL长度：20字节（40位）加密算法：SHA-1(SHA-1($pass))其他系统：系统：MD5(WordPress)例子：$P$B123456780BhGFYSlUqGyE6ErKErL01说明：WordPress使用的md5长度：34个字符描述：$P$表示加密类型，然后跟着一位字符，经常是字符‘B"，后面是8位salt，后面是就是hash加密算法：8192次md5循环加密系统：MD5(phpBB3)说明：phpBB 3.x.x.使用例子：$H$9123456785DAERgALpsri.D9z3ht120长度：34个字符描述：开始的$H$为加密标志，后面跟着一个字符，一般的都是字符‘9"，然后是8位salt，然后是hash 值加密算法：2048次循环调用MD5加密系统：RAdmin v2.x说明：Remote Administrator v2.x版本中例子：5e32cceaafed5cc80866737dfb212d7f长度：16字节（32个字符）加密算法：字符用0填充到100字节后，将填充过后的字符经过md5加密得到（32位值）md5加密标准MD5例子：c4ca4238a0b923820dcc509a6f75849b使用范围：phpBB v2.x, Joomla 的 1.0.13版本前，及其他cmd长度：16个字符其他的加salt及变形类似：md5($salt.$pass)例子:f190ce9ac8445d249747cab7be43f7d5:12md5(md5($pass))例子:28c8edde3d61a0411511d3b1866f0636md5(md5($pass).$salt)例子:6011527690eddca23580955c216b1fd2:wQ6md5(md5($salt).md5($pass))例子: 81f87275dd805aa018df8befe09fe9f8:wH6_Smd5(md5($salt).$pass)例子: 816a14db44578f516cbaef25bd8d8296:1234

hash函数　　Hash，一般翻译做"散列"，也有直接音译为"哈希"的，就是把任意长度的输入（又叫做预映射， pre-image），通过散列算法，变换成固定长度的输出，该输出就是散列值。这种转换是一种压缩映射，也就是，散列值的空间通常远小于输入的空间，不同的输入可能会散列成相同的输出，而不可能从散列值来唯一的确定输入值。　　简单的说就是一种将任意长度的消息压缩到某一固定长度的消息摘要的函数。　　HASH主要用于信息安全领域中加密算法，他把一些不同长度的信息转化成杂乱的128位的编码里,叫做HASH值. 也可以说，hash就是找到一种数据内容和数据存放地址之间的映射关系　　了解了hash基本定义，就不能不提到一些著名的hash算法，MD5 和 SHA1 可以说是目前应用最广泛的Hash算法，而它们都是以 MD4 为基础设计的。那么他们都是什么意思呢？　　这里简单说一下：　　1) MD4 　　MD4(RFC 1320)是 MIT 的 Ronald L. Rivest 在 1990 年设计的，MD 是 Message Digest 的缩写。它适用在32位字长的处理器上用高速软件实现--它是基于 32 位操作数的位操作来实现的。　　2) MD5 　　MD5(RFC 1321)是 Rivest 于1991年对MD4的改进版本。它对输入仍以512位分组，其输出是4个32位字的级联，与 MD4 相同。MD5比MD4来得复杂，并且速度较之要慢一点，但更安全，在抗分析和抗差分方面表现更好　　3) SHA1 及其他 　　SHA1是由NIST NSA设计为同DSA一起使用的，它对长度小于264的输入，产生长度为160bit的散列值，因此抗穷举(brute-force)性更好。SHA-1 设计时基于和MD4相同原理,并且模仿了该算法。　　那么这些Hash算法到底有什么用呢？　　Hash算法在信息安全方面的应用主要体现在以下的3个方面： 　　1) 文件校验 　　我们比较熟悉的校验算法有奇偶校验和CRC校验，这2种校验并没有抗数据篡改的能力，它们一定程度上能检测并纠正数据传输中的信道误码，但却不能防止对数据的恶意破坏。 　　MD5 Hash算法的"数字指纹"特性，使它成为目前应用最广泛的一种文件完整性校验和(Checksum)算法，不少Unix系统有提供计算md5 checksum的命令。　　2) 数字签名 　　Hash 算法也是现代密码体系中的一个重要组成部分。由于非对称算法的运算速度较慢，所以在数字签名协议中，单向散列函数扮演了一个重要的角色。 对 Hash 值，又称"数字摘要"进行数字签名，在统计上可以认为与对文件本身进行数字签名是等效的。而且这样的协议还有其他的优点。　　3) 鉴权协议 　　如下的鉴权协议又被称作"挑战--认证模式：在传输信道是可被侦听，但不可被篡改的情况下，这是一种简单而安全的方法。　　hash函数在程序设计中的实现　　// 说明：Hash函数（即散列函数）在程序设计中的应用目标 ------ 把一个对象通过某种转换机制对应到一个　　// size_t类型（即unsigned long）的整型值。　　// 而应用Hash函数的领域主要是 hash表（应用非常广）、密码等领域。　　// 实现说明：　　// （1）、这里使用了函数对象以及泛型技术，使得对所有类型的对象（关键字）都适用。　　// （2）、常用类型有对应的偏特化，比如string、char*、各种整形等。　　// （3）、版本可扩展，如果你对某种类型有特殊的需要，可以在后面实现专门化。　　// （4）、以下实现一般放在头文件中，任何包含它的都可使用hash函数对象。　　//------------------------------------实现------------------------------------------------　　#include <string>　　using std::string;　　inline size_t hash_str( const char* s )　　{　　unsigned long res = 0; 　　for ( ; *s; ++s )　　res = 5 * res + *s;　　return size_t(res);　　}　　template <class Key> 　　struct hash 　　{ 　　size_t operator () ( const Key& k ) const;　　};　　// 一般的对象，比如：vector< queue<string> >的对象，需要强制转化　　template < class Key >　　size_t hash<Key>::operator () ( const Key& k ) const　　{　　size_t res = 0;　　size_t len = sizeof( Key );　　const char* p = reinterpret_cast<const char*>( &k );　　while ( len-- )　　{　　res = (res<<1)^*p++;　　}　　return res;　　}　　// 偏特化　　template<>　　size_t hash< string >::operator () ( const string& str ) const　　{　　return hash_str( str.c_str() );　　}　　typedef char* PChar;　　template<>　　size_t hash<PChar>::operator () ( const PChar& s ) const　　{　　return hash_str(s);　　}　　typedef const char* PCChar;　　template<>　　size_t hash<PCChar>::operator () ( const PCChar& s ) const　　{　　return hash_str(s);　　}　　template<> size_t hash<char>::operator () ( const char& x ) const { return x; }　　template<> size_t hash<unsigned char>::operator () ( const unsigned char& x ) const { return x; }　　template<> size_t hash<signed char>::operator () ( const signed char& x ) const { return x; }　　template<> size_t hash<short>::operator () ( const short& x ) const { return x; }　　template<> size_t hash<unsigned short>::operator () ( const unsigned short& x ) const { return x; }　　template<> size_t hash<int>::operator () ( const int& x ) const { return x; }　　template<> size_t hash<unsigned int>::operator () ( const unsigned int& x ) const { return x; }　　template<> size_t hash<long>::operator () ( const long& x ) const { return x; }　　template<> size_t hash<unsigned long>::operator () ( const unsigned long& x ) const { return x; }　　// 使用说明：　　// 　　// （1）、使用时首先由于是泛型，所以要加上关键字类型。　　// 　　// （2）、其次要有一个函数对象，可以临时、局部、全局的，只要在作用域就可以。　　// 　　// （3）、应用函数对象作用于对应类型的对象。　　//----------------------- hash函数使用举例 -------------------------　　#include <iostream>　　#include <vector>　　#include <string>　　using namespace std;　　int main()　　{　　vector<string> vstr(2);　　vstr[0] = "sjw";　　vstr[1] = "suninf";　　hash<string> strhash; // 局部函数对象　　cout << " Hash value: " << strhash( vstr[0] ) << endl;　　cout << " Hash value: " << strhash( vstr[1] ) << endl;　　cout << " Hash value: " << hash< vector<string> >() ( vstr ) << endl;　　cout << " Hash value: " << hash<int>() ( 100 ) << endl; // hash<int>() 临时函数对象　　return 0;　　}

很负责任的告诉你，HashMap是采用hash算法进行对象存储映射的一个集合对象，hash只是一种散列数算法，在一定范围内，甚至是全范围内，hash值都是唯一不重复的。

你问的应该是电驴里的文件hash那是电驴特有的共享ID只要那个不变,你改文件名什么的都可以一样在电驴上共享 eMule里什么是HASH？ 很多御骡多年的老骡手可能和我一样给新手讲不清楚这个问题，在此我翻查了一些资料，并结合eMule的特性，给大家解释一下 首先我们经常挂在嘴上的就是Hash、UserHash、文件Hash等等这样的词汇 其实Hash翻译成中文是 哈希 在编程上又称作 哈希函数 那么这个函数在eMule 这个P2P软件中起到了什么作用呢？ 这里我们需要了解一个概念MD（MD2、MD4、MD5） 我们都知道电影、音乐、软件等等都是以文件的形式储存在计算机器上的 但是我们有时候并没有必要看到文件的全部，或者是一部分才能了解这个文件 就好像看一本书一样，只要知道目录，就知道整本书大概的内容了 那么就由90年代初由MIT Laboratory for Computer Science和RSA Data Security Inc的Ronald L. Rivest开发 出一套Message-Digest Algorithm <MD>（信息-摘要算法）来； 同时我们引入了哈希函数（HASH） HASH（哈希）函数提供了这样一种计算过程：输入一个长度不固定的字符串，返回一串定长度的字符串，又称HASH值。 单向HASH函数用于产生信息摘要。 当我们将一个文件放入eMule的共享文件里的时候 我们就开始了这样的算法步骤（大家都能体会到，硬盘狂转－提取文件信息的时候吧） 最终通过这一系列的算法我们得到了一个128个二进制位 ps: hash算法更多的是用来校验文件的完整性 当第一个人把自己的共享文件变成HASH值的时候，向服务器进行的提交 同时可能还有很多提交者，那么他们的HASH值就进入了服务器的一个动态列表里 列表中存放着的是拥有这些同样文件的用户的IP 、PORT等等地址信息 当另外的用户需要下载或者搜索时，服务器就把这个信息传递给需要的用户 那么这个用户就知道到底应该去哪里下载喽 当完成协议验证等等程序流程后，两个小骡骡就开始了点对点的传播

Redis hash 是一个 string 类型的 field（字段） 和 value（值） 的映射表，hash 特别适合用于存储对象。 Redis 中每个 hash 可以存储 232 - 1 键值对（40多亿）。 hash类型可以理解为map集合，{key1:value1,key2:value2} 实例 Hash 的应用场景： 将一个用户作为一个 hash ，然后其属性和值就作为内部的 k-v 集合进行存储 例如 user:1 代表第 1 个用户，然后这个用户具有 name，age，job 这些字段，因为 redis 效率很高，因此适合将属性值经常变动的对象作为 hash 存储 个人理解和便于学习，进行了简单分类！ 分为以下几类： 下表列出了 redis hash 基本的相关命令： 更多命令请参考： https://redis.io/commands

你可以看括号里的例子：HASH是信息安全领域中加密算法，他把一些不同长度的信息转化成杂乱的128位的编码里,叫做HASH值.也可以说，hash就是找到一种数据内容和数据存放地址之间的映射关系（就像摩斯电码一样电报嘀嘀嘀想几下如果那几下有3长1短，那么在通信双方都有的小本子里找3长1短代表什么字就行了），而md5hash就是以md5加密算法的hash值，要破解的时候就要以md5加密算法逆向进行...（也就是说平时说的md5码也就是md5hash码只不过为了简便把hash给省略了）这就是联系吧~常见的加密算法有sha-1hash，md5hash，havalhash，ripemdhash

PTH，即Pass-The-Hash，首先我们来说下为什么要使用HASH传递，一是再目标机>=win server 2012时，lsass.exe进程中是抓不到明文密码的，二是随着信息安全意识的提高，弱口令情况逐渐降低，我们经常会遇到拿到hash却解不开的情况，综上，只有hash，我们依然可以正常登录。 PTH攻击最酷的地方并不是hash传递利用的过程，而是hash的获取过程，所以接下来90%的篇幅为hash获取的内容，开工！ mimikatz的原生命令在这里有些不在适用，但记得hash获取命令： mimikatz_command -f samdump::hashes 导出SAM数据： 使用mimikatz提取hash： 首先同普通PC的Hash获取思路，但是不一样的是，你要晓得两件事情 NTDS.dit获取域控hash 这个思路在域渗透中尤为重要，因为这里面包含着所有域用户的hash，当然该思路只对DC生效。 我这里域用户只有几个，文件高达36M。 接下来我们需要提取用户hash,推荐NTDSDumpEx： 同样，再推荐个工具，还是我们多次提到过的python第三方库 impacket 下的secretsdump。 为什么要再提一遍secretsdump呢，因为它可以直接导出，说白了，就是把我们的手工任务自动执行一边，放在最后说也是为了让大家明白它的工作原理。 首先它会导出本地SAM中的hash： 然后是所有域内用户的IP，全部获取成功。 首先恭喜在读的你，终于熬到了扣题的环节，这里我们提两种方式。 or 显然，其实它只需要NThash部分就好啦。 这就是内网渗透中的PTH操作，与其说是漏洞，其实他是验证逻辑中的一部分，希望本文可以提供给域管一些来自对立面的加固思路，感谢一位不愿透露姓名内网渗透大佬的全程指导，鞠躬。

Hash 索引的查询效率要远高于 B-Tree 索引。可能很多人又有疑问了，既然 Hash 索引的效率要比 B-Tree 高很多，为什么大家不都用 Hash 索引而还要使用 B-Tree 索引呢？任何事物都是有两面性的，Hash 索引也一样，虽然 Hash 索引效率高，但是 Hash 索引本身由于其特殊性也带来了很多限制和弊端，主要有以下这些。（1）Hash 索引仅仅能满足"=","IN"和"<=>"查询，不能使用范围查询。由于 Hash 索引比较的是进行 Hash 运算之后的 Hash 值，所以它只能用于等值的过滤，不能用于基于范围的过滤，因为经过相应的 Hash 算法处理之后的 Hash 值的大小关系，并不能保证和Hash运算前完全一样。（2）Hash 索引无法被用来避免数据的排序操作。由于 Hash 索引中存放的是经过 Hash 计算之后的 Hash 值，而且Hash值的大小关系并不一定和 Hash 运算前的键值完全一样，所以数据库无法利用索引的数据来避免任何排序运算；（3）Hash 索引不能利用部分索引键查询。对于组合索引，Hash 索引在计算 Hash 值的时候是组合索引键合并后再一起计算 Hash 值，而不是单独计算 Hash 值，所以通过组合索引的前面一个或几个索引键进行查询的时候，Hash 索引也无法被利用。（4）Hash 索引在任何时候都不能避免表扫描。前面已经知道，Hash 索引是将索引键通过 Hash 运算之后，将 Hash运算结果的 Hash 值和所对应的行指针信息存放于一个 Hash 表中，由于不同索引键存在相同 Hash 值，所以即使取满足某个 Hash 键值的数据的记录条数，也无法从 Hash 索引中直接完成查询，还是要通过访问表中的实际数据进行相应的比较，并得到相应的结果。（5）Hash 索引遇到大量Hash值相等的情况后性能并不一定就会比B-Tree索引高。对于选择性比较低的索引键，如果创建 Hash 索引，那么将会存在大量记录指针信息存于同一个 Hash 值相关联。这样要定位某一条记录时就会非常麻烦，会浪费多次表数据的访问，而造成整体性能低下。

Hash，一般翻译做“散列”，也有直接音译为“哈希”的，就是把任意长度的输入通过散列算法变换成固定长度的输出，该输出就是散列值。这种转换是一种压缩映射，也就是，散列值的空间通常远小于输入的空间，不同的输入可能会散列成相同的输出，所以不可能从散列值来确定唯一的输入值。简单的说就是一种将任意长度的消息压缩到某一固定长度的消息摘要的函数。 MD5信息摘要算法 （英语：MD5 Message-Digest Algorithm），一种被广泛使用的 密码散列函数 ，可以产生出一个128位（16 字节 ）的散列值（hash value），用于确保信息传输完整一致。2004年，证实MD5算法无法防止碰撞（collision）（如网站： CMD5 ），因此不适用于安全性认证，如 SSL 公开密钥认证或是 数字签名 等用途。 MD5 是哈希算法的一种。 密码加密常见的有以下几种方式： HMAC是密钥相关的哈希运算消息认证码（Hash-based Message Authentication Code）的缩写，并在 IPSec 和其他网络协议（如 SSL ）中得以广泛应用，现在已经成为事实上的Internet安全标准。它可以与任何迭代散列函数捆绑使用。 如上图中，共有两个流程： 授权设备登录流程： 1、输入账号过后，就把账号作为参数向服务器发送请求 2、服务器根据账号生成对应的key，并传递给客户端 3、客户端拿到key，进行HMAC运算，并将运算结果的哈希值传给服务器 其他设备登录流程： 1、输入账号过后，在本地缓存中找服务器传过来的key，有就登录，没有就把账号作为参数向服务器发送请求 2、服务器要先看这个账号是否开启了设备锁，没有开启就不允许登录，开启了，就向授权设备发送请求，是否授权，如果授权，就将这个账号的key传给其他客户端 3、客户端拿到key，进行HMAC运算，并将运算结果的哈希值传给服务器 但是在这之中有一个潜在的安全隐患问题： 当别人拿到账号和传递的哈希值过后，也就能拿到登录权限，从而不安全。 为了防止上面的问题，注册流程不变，服务器还是保存的有加了key的HMAC哈希值。 1、只是登录的时候，客户端将哈希值与时间戳拼接过后，进行MD5加密，再传给服务器。 2、服务器将注册保存的账号对应的HMAC哈希值，分别与当前时间，和前一分钟拼接再MD5加密，再和客户端传过来的进行匹配，匹配成功则登录成功，否则不成功。 3、注意这里的时间戳是服务器给的时间戳。 常见的加密算法： 应用模式： AES加密解密都是用到的CCCrypt函数，并且需要导入 CommonCrypto 框架。

Hash，一般翻译做"散列"，也有直接音译为"哈希"的，就是把任意长度的输入（又叫做预映射， pre-image），通过散列算法，变换成固定长度的输出，该输出就是散列值。这种转换是一种压缩映射，也就是，散列值的空间通常远小于输入的空间，不同的输入可能会散列成相同的输出，而不可能从散列值来唯一的确定输入值。简单的说就是一种将任意长度的消息压缩到某一固定长度的消息摘要的函数。HASH主要用于信息安全领域中加密算法，它把一些不同长度的信息转化成杂乱的128位的编码里，叫做HASH值. 也可以说，hash就是找到一种数据内容和数据存放地址之间的映射关系。Hash算法在信息安全方面的应用主要体现在以下的3个方面：文件校验、数字签名、鉴权协议程程序实现// 说明：Hash函数（即散列函数）在程序设计中的应用目标 ------ 把一个对象通过某种转换机制对应到一个//size_t类型（即unsigned long）的整型值。// 而应用Hash函数的领域主要是 hash表（应用非常广）、密码等领域。// 实现说明：// ⑴、这里使用了函数对象以及泛型技术，使得对所有类型的对象（关键字）都适用。// ⑵、常用类型有对应的偏特化，比如string、char*、各种整形等。// ⑶、版本可扩展，如果你对某种类型有特殊的需要，可以在后面实现专门化。// ⑷、以下实现一般放在头文件中，任何包含它的都可使用hash函数对象。//------------------------------------实现------------------------------------------------#include <string>using std::string;inlinesize_thash_str(const char* s){unsigned long res = 0;for (; *s; ++s)res = 5 * res + *s;returnsize_t(res);}template <class Key>struct hash{size_toperator () (const Key& k) const;};// 一般的对象，比如：vector< queue<string> >；的对象，需要强制转化template < class Key >size_thash<Key>::operator () (const Key& k) const{size_tres = 0;size_tlen = sizeof(Key);const char* p = reinterpret_cast<const char*>(&k);while (len--){res = (res<<1）^*p++;}return res;}// 偏特化template<>size_thash< string >::operator () (const string& str) const{return hash_str(str.c_str());}typedef char* PChar;template<>size_thash<PChar>::operator () (const PChar& s) const{return hash_str(s);}typedef const char* PCChar;template<>size_thash<PCChar>::operator () (const PCChar& s) const{return hash_str(s);}template<> size_t hash<char>::operator () (const char& x) const { return x; }template<> size_t hash<unsigned char>::operator () (const unsigned char& x) const { return x; }template<> size_t hash<signed char>::operator () (const signed char& x) const { return x; }template<> size_t hash<short>::operator () (const short& x) const { return x; }template<> size_t hash<unsigned short>::operator () (const unsigned short& x) const { return x; }template<> size_t hash<int>::operator () (const int& x) const { return x; }template<> size_t hash<unsigned int>::operator () (const unsigned int& x) const { return x; }template<> size_t hash<long>::operator () (const long& x) const { return x; }template<> size_t hash<unsigned long>::operator () (const unsigned long& x) const { return x; }// 使用说明：//// ⑴、使用时首先由于是泛型，所以要加上关键字类型。//// ⑵、其次要有一个函数对象，可以临时、局部、全局的，只要在作用域就可以。//// ⑶、应用函数对象作用于对应类型的对象。//----------------------- hash函数使用举例 -------------------------#include <iostream>#include <vector>#include <string>using namespace std;int main(){vector<string> vstr⑵；vstr[0] = "sjw";vstr[1] = "suninf";hash<string> strhash; // 局部函数对象cout << " Hash value: " << strhash(vstr[0]) << endl;cout << " Hash value: " << strhash(vstr[1]) << endl;cout << " Hash value: " << hash< vector<string> >() (vstr) << endl;cout << " Hash value: " << hash<int>() （100） << endl; // hash<int>() 临时函数对象return 0;}

讲解哈希表，就需要与一般的数组作对比的讲，这样更能说明哈希表。我们都知道，数组是一个下标（数字）与一个值得对应，给出数组某一合法下标，就会得到数组在这个下标下存储的值；而哈希表就类似是用名字代替下标的一个特殊的数组。只要给出哈希表中某一个合法名字的值，就能找到与这个名字对应的，哈希表中的一个值。举个例子说明数组与哈希表：有一个数组array，他有3个元素，这个数组存储了3个城市的当天的气温，array[0]=“-1摄氏度”，array[1]=“3摄氏度”，array[2]=“12摄氏度”，这样的数组，除了程序员以外，几乎没有人知道，那个城市的气温是多少，但是如果用哈希表存储，就能一目了然了。哈希表 hashhash.add（“北京”，“-1摄氏度”），hash.add（“上海”，“3摄氏度”），hash.add(“广州”，“12摄氏度”），看到了吧，这样，城市名字就和相应的气温对应上了，哈希表中，第一个参数就是哈希表元素的坐标，又叫键名，第2个参数就是值，又叫键值。哈希表也可以和数组一样，能够动态的随机存储，但是比一般数组要能节省空间，但是浪费了时间。

相同处：1.二者均是多对一的数据加密模式。（也就是说将一定量的数据加密成一个固定长度的数据）2.二者的加密方式均为单向加密，也就是加密不可逆。3.二者多用于数据加密和文件以及数据的完整性验证不同处：1.MD5目前存在很大的安全隐患，通过一些方法可以将MD5暴力破解，同样对于SHA1的算法现在同样存在这样的问题。2.SHA2算法由于相对于SHA1来说，加密数据位数的上升大大增加了破解的难度，使得安全性能要远远高于MD5

Hash，一般翻译做"散列"，也有直接音译为"哈希"的，就是把任意长度的输入（又叫做预映射， pre-image），通过散列算法，变换成固定长度的输出，该输出就是散列值。

太复杂了吧