ha

such little是“如此小的”的意思，表示少时修饰可数名词；so little表示很少，通常修饰不可数名词。

such一般用来限定名词，意思是“如此的一个事物”。而so限定形容词，意思是“如此什么什么的（一个事物）”这里先分析清楚第一个little的意义。显然这里它的含义不是数量上的少（否则不可能跟可数名词复数worms连用，应用few）,而是体积上的小。即littleworms合在一起表达“小虫子”的意思，那么当然用such.第二个little从整句话意思判断应该是数量上的少，所以修饰了不可数的grain。在这里强调它们吃的谷粒之少，强调little，所以用so.

jre编译成这样了

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

what is的缩写形式为：whats whats 读音：英 [wts] 美 [hwɑts] 释义：what is 或 what has 的常用口语形式，尤当 has 为助动词时 扩展资料 　　语法：what作关系代词时，其含意是“所…的事(物)”。可用来引导主语从句，表语从句，宾语从句或同位语从句。当引导主语从句，其所指的名词必定是单数。主语是单数时，谓语动词一般是单数，但有时因谓语动词之后有复数名词，谓语动词也可用复数。 　　例句： 　　What"s the trouble with the machine? 　　这机器出了什么故障？ 　　What"s the form when you apply for a research grant? 　　申请科研补助金按常规应该怎么办？

这样理解：因为数组是引用型，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来说比较慢

一直以来只是知道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作为原始数组，这样也会有问题。

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

该题可以在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碰撞。

那将是所罗门•格润迪的一周。

病句。

一个中文支持好点，一个中文支持差点儿。一个升级快点，一个升级慢点。如果是新手，就用红旗好了，简单，易用.如果非要用外国的就用mandrake ，也简单，易用，不过需要美化一下字体，而红旗不用，装好了就是比较漂亮的，因此我删了红帽用红旗了

redhat是红帽子是国外的老牌linux了，不过他现在已经不做桌桌面系统了。现在还有服务器版本的。最新的redhat是9.0而redflag是我国的红旗，还在发行。最新的是6.0.说实话，redflag不怎么样。如果想用linux你就先用ubuntu吧

StephanLara外文名：StephanLara职业：演员代表作品：野草莓合作人物：DominiqueChoisy

Dear Customer,We would like to invite you to a dinner party held by our firm. You will meet the senior executives and other clients of our firm at the party. We guarantee that night will be happy and enjoyable.We look forward to seeing you on Saturday. Please bring this invitation with you; it is necessary for admittance.Yours SincerelyZhangli-------------------------------------------------------------------------------------------------------------------------供您参考！谢谢！

surname：姓。max 8 characters:最多为8个字符。即在填表是， 姓的字符不能超过8个。

StephanHersoenStephanHersoen是一名演员，代表作品有《家庭性的编年史》。外文名：StephanHersoen职业：演员代表作品：《家庭性的编年史》合作人物：帕斯卡尔·阿诺德

MikeStephanParkerMikeStephanParke是一名原创音乐师，主要作品有《超速战警二人组》《AlarmfürCobra11-DieAutobahnpolizei》《AlarmfürCobra11-DieAutobahnpolizei》。外文名：MikeStephanParker职业：原创音乐师代表作品：《超速战警二人组》合作人物：LeoZahn

eahjf103

平假名 (ひらがな) や段 ゆ段 よ段 か行 きゃ(kya) きゅ(kyu) きょ(kyo) が行 ぎゃ(gya) ぎゅ(gyu) ぎょ(gyo) さ行 しゃ(sha) しゅ(shu) しょ(sho) ざ行 じゃ(ja) じゅ(ju) じょ(jo) た行 ちゃ(cha) ちゅ(chu) ちょ(cho) だ行 ぢゃ(ja) ぢゅ(ju) ぢょ(jo) な行 にゃ(nya) にゅ(nyu) にょ(nyo) は行 ひゃ(hya) ひゅ(hyu) ひょ(hyo) ば行 びゃ(bya) びゅ(byu) びょ(byo) ぱ行 ぴゃ(pya) ぴゅ(pyu) ぴょ(pyo) ま行 みゃ(mya) みゅ(myu) みょ(myo) ら行 りゃ(rya) りゅ(ryu) りょ(ryo) 片假名 (かたかな) ヤ段 ユ段 ヨ段 カ行 キャ(kya) キュ(kyu) キョ(kyo) ガ行 ギャ(gya) ギュ(gyu) ギョ(gyo) サ行 シャ(sha) シュ(shu) ショ(sho) ザ行 ジャ(ja) ジュ(ju) ジョ(jo) タ行 チャ(cha) チュ(chu) チョ(cho) ダ行 ヂャ(ja) ヂュ(ju) ヂョ(jo) ナ行 ニャ(nya) ニュ(nyu) ニョ(nyo) ハ行 ヒャ(hya) ヒュ(hyu) ヒョ(hyo) バ行 ビャ(bya) ビュ(byu) ビョ(byo) パ行 ピャ(pya) ピュ(pyu) ピョ(pyo) マ行 ミャ(mya) ミュ(myu) ミョ(myo) ラ行 リャ(rya) リュ(ryu) リョ(ryo)起初看到我还以为是韩国语呢！╮(╯▽╰)╭

StephanPasternackiStephanPasternacki是一名原创音乐人，主要作品有《AnnaLucasta》《公主驾到》《婚礼之夜》。外文名：StephanPasternacki职业：原创音乐人代表作品：《AnnaLucasta》合作人物：IrvingRapper电影作品

名字 Stephan 年龄 36 岁 体形 177 厘米 / 55 公斤 国家 泰国 / Bangkok http://www.chinesekisses.de/showfotos.php?l=zh&randm=11&randw=21&id=122110&foto=08/122110_154449-27.jpg

用汉语拼音拼出来读读就能发现区别了：し—— 类似拼音 xi （西）ひ——hi （读音跟英语单词“he”（男的他）基本一样 ）しゃ—— 类似拼音 xia （瞎） ひゃ —— hia (拼音里面没有这样的发音，但是是以声母 h 开头的)しゅ—— 类似拼音 xiu（修）ひゅ—— hiu （h发音类似拼音中的声母h，或类似英语单词huge 的前半部分的读音）しょ—— xi o 两个拼起来ひょ —— hi o两个拼起来赶脚没有语音真的不好解释，不知道这样讲的你懂不懂。。。总的来说，は行的拗音读起来都会带有像汉语拼音的声母“ha”那样的音，而さ行的拗音读起来则带有类似汉语拼音“xi” 那样的音

同学你好，很高兴为您解答！　　Hard Landing硬着陆指由于政府尝试减慢通胀而导致经济进入衰退。　　对于各个投资领域内的专业人员，包括基金经理、证券分析师、财务总监、投资顾问、投资银行家、交易员等等，CFA非常重要；它直接证明了你的职业素养和能力，被投资业看成一个“黄金标准”,这一资格被认为是投资业界中具有专业技能和职业操守的承诺。考生考过CFA对自己将会有很大帮助。　　希望我的回答能帮助您解决问题，如您满意，请采纳为最佳答案哟。　　再次感谢您的提问，更多财会问题欢迎提交给高顿企业知道。高顿祝您生活愉快！

landing charges 起货费，卸货费用; [例句]Landing and delivery charges and pier dues shall be at the expense of the goods unless included in the freight herein provided for.卸货和交货费用以及码头费应算在货主头上，将其算在本合同规定的运费中的除外。

1、observed species指数：observed species指数表示该样品中含有的物种数目。2、chao指数：chao指数估算样品中所含OTU数目的指数。3、ace指数：ace指数评估样本中物种组成的丰富度和均匀度。应答时间：2021-02-05，最新业务变化请以平安银行官网公布为准。 [平安银行我知道]想要知道更多？快来看“平安银行我知道”吧~ https://b.pingan.com.cn/paim/iknow/index.html

不对species具体如下，多指生物上的物种，单复数同形。这里用kind表示种类更好。

Espresso English创始人Shayna Oliveira, founder of Espresso English

ThaiseOliveira外文名：ThaiseOliveira职业：制作人代表作品：未来海岸合作人物：卡里姆·埃诺兹

chassis英文意思为集装箱拖车，split的英文意思为费用，chassis split是集装箱拖车的费用。按照出口拖车运费，一般考虑装货地点距离装运港口的距离。该装货地点有没有其他限制。比如白天不能通行。1、专门用于各种集装箱的运输。能长期的反复使用，具有足够的强度。2、使用集装箱转运货物，可直接在发货人的仓库装货，运到收货人的仓库卸货，中途更换车、船时，无须将货物从箱内取出换装。3、可以进行快速装卸，并可从一种运输工具直接方便地换装到另一种运输工具。4、便于货物的装满和卸空，满足客户的个性化需求。根据客户需要工装保证，质量稳定，性能可靠。扩展资料：1、拖车费就是为疏通交通，拖动车辆所产生的相关费用。通常是指交通交警部门或拖车服务公司，在机动车出现故障或是发生交通事故后，为及时疏通道路、避免道路堵塞，而采取的强制或应车主要求将车辆拖离现场时所产生的费用。2、另外还有一种拖车费是在海运运输中产生的，这种拖车费一般是指在货运公司或货代在目的港送货时，使用集装箱车辆或者平板车辆对货物进行转移所收取的费用，这项费用有时候是包含在海运费中，有时候会单独列出。

They stood for change . 他们主张变革。 Ingenious circuits can be designed that correct for changes in the receiver sensitivity . 设计灵敏的电路，以便校正接收机灵敏度的变化。 More recently, tentative techniques have been explored for changing human behavior directly . 近年来为了直接改变人类的行为曾经探索采取一些实验性的技巧。 Class instance polls the database table for changes 轮询数据库表的更改的频率。 This would be a point to watch for change in trend 这将成为注意趋势变化的一点。 But he also tapped a wider desire for change 而且他还激发了民众希望变革的热情。 Find the utipty for changing the boot order 找到用来修改引导顺序的工具软件。 Tendency of hoping for change in hanyu " s landscape poetry 韩愈山水诗的求变倾向 Provides steps for changing the default look of the 提供有关步骤，说明如何更改 Property to watch only for changes to text files 属性仅监视对文本文件的更改。 [ scene : the subway , phoebe is singing for change [场景：地铁处，菲比在卖唱。 For change request management and defect tracking 用于需求变更管理以及缺陷追踪。 The database is not enabled for change notifications 没有为数据库启用更改通知 The true aim of prediction is helpful for changing 预测的真正目的是有助于应变。 There " s no mechanism for changing the decision 没有任何机制来改变这一决定。 Provides steps for changing the default appearance of a 提供有关步骤，说明如何更改 Regularity for change of technical condition of vehicle 汽车技术状况变化规律 Criteria for changing crank case oil of gasopne automobile 汽油机油换油指标 Control centers for changing message type electric signs 变换信息型电子信号控制中心 Receives event notifications for changes directly from 接收更改的事件通知。 Lcq15 : apppcations for change of land use 立法会十五题：改变土地用途的申请 How to apply re - apply for change e - tax password 如何申请补领更新税务易通行密码？ And i got you for change . " - but it felt good 然后我就拿到了你，作为找零-感觉不错 Code changes for changing the appearance of controls 更改控件外观的代码更改 Please check this page periodically for changes 请定期检查本网页有无变化。 The mode for change management of concurrent engineering 并行工程中变更管理模式研究 Provides steps for changing the default appearance of the 提供有关步骤，说明如何更改 Few tycoons accept the need for change 很少有企业大亨承认有必要进行改革。 Considerations for changing the default keyring 更改缺省keyring的注意事项 Secondly , pressures for changes from the wider economy 第二,来自范围经济变革的压力。 - and i got you for change . " " - but it felt good -然后我就拿到了你，作为找零-感觉不错 Austrapa urges china , india to push for change in burma 澳大利亚促中印就缅施变革施压 Provides events for changes to the output window 为对“输出”窗口所做的更改提供事件。 Ecuk : an engine for change of engineering education 工程教育改革的发动机 Criteria for change of engine oil used in diesel engine 柴油机油换油指标 Apply re - apply for change of e - tax password 申请补领更新税务易通行密码 Making the case for change with this problematic technology 这一有疑问的技术应该改变了 Provides steps for changing properties for relationships 提供用于更改关系属性的步骤。 A user control for changing display modes 用于更改显示模式的用户控件。 Please periodically review our privacy popcy for changes 请定期查阅本公司的隐私条例。 There seem to be several reasons for changing our plans 看来改变我们的计划有几个理由。 Gas cypnders - procedures for change of gas service 气瓶.换气服务程序 Log on to apply re - apply for change e - tax password 登入网上申请补领更新税务易通行密码 Form for change in correspondence and or practising address 更改通讯及/或执业地址的表格 Provides events for changes made to the task pst 为对“任务列表”所做的更改提供事件。 You " ll also find facipties for changing your baby " s nappies 那儿有为婴儿换尿布的设备。 Gas cypnders - procedures for change of gas service 气瓶.换气服务程序 The incidents themselves are just catalysts for change 这些事件的本身是某种变化的催化剂 Provides events for changes to a selection 为选定内容的更改提供事件。 But i am eager for changes now , maybe a marriage 随著时间的流逝，我希望有个家或有个伴？

荣耀NTHAN00支持5g的。荣耀50系列全系标配曲率为75°的超级曲面屏，支持10.7亿色、能呈现出传统手机64倍的丰富色彩。荣耀50的初雪水晶采用了全新的钻彩工艺，营造光影的闪烁之美。

荣耀50的手机型号。荣耀nthan00是荣耀50的手机型号，荣耀50是荣耀于2021年6月16日发布的手机产品，于6月25日正式上市，手机采用6.57英寸OLED屏幕。荣耀50从它的外形上看有时尚感，设计的很精致，支持120Hz刷新率，300Hz触控采样率，还有10.7亿色的显示，带来更流畅、细腻的显示效果。

荣耀50手机出厂时自带屏膜贴膜，没有镜头膜。

今年7月份，因为一些众所周知原因不断延期的华为P50系列正式发布，当时官方称该机共有两种规格，其中一种是搭载华为自家麒麟9000芯片的版本，另一种是搭载高通芯片骁龙888的版本。根据华为京东官方旗舰店显示，目前华为P50的骁龙888版本已经正式上架，商品页面显示该机将于9月29日10:08限量发售，共提供三种配色和两种存储方案，其中8+128GB售价4488元、8+256GB售价4998元。

华为NTHANOO有视频美颜。打开快捷菜单里的相机，在下方的拍摄模式中选择人像，点击美颜，向右拖动圆形按钮，调高美肤级别，然后打开效果，选择合适的光线，设置好后点击录像，在它的上方也会显示美颜图标，找到美颜设置，设置美颜级别，视频美颜就设置好了。华为NTHANOO视频美颜的优点华为手机也是自带美颜效果的，从0到10可以进行不同程度的美颜，大家可以自行调节，而且华为P30Pro的美颜效果是可以带到微信视频里面的，解决微信视频无法美颜的问题，很多用户都不愿意在微信上开视频。如果你使用的是华为手机，现在有个功能，不仅可以在视频的时候美颜，还能共享屏幕，最重要的是还是个免费功能。

现在是什么牌子的录音九原像这种牌子的论剑应该是一种大品牌？我原先这种牌子看起来还不错的

I"d like to be somebody else and not know where I"ve been我想成为别人，想不知道去过哪里I"d like to build myself a house out of plasticine我想用橡皮泥建立自己的房子Shake along with me和我一起摇晃I"ve been driving in my car with my friend Mr. Soft我和我的朋友软弱先生驾驶我的车Mr. Clean and Mr. Ben are living in my loft清洁先生和本先生住在我的阁楼里Shake along with me!和我一起摇晃I"m sorry but I just don"t know I know我很抱歉，但我只是不知道我明白I said I told you so我说我告诉过你But when you"re happy and you"re feeling fine但当你快乐的时候，你感觉很好Then you"ll know it"s the right time然后你将知道这是对的时候It"s the right time这是对的时候To shake along with me!来和我一起摇晃Mister Sifter sold me songs筛子先生曾卖给我歌when I was just sixteen当我还只有十六岁Now he stops at traffic lights现在他停在交通灯前but only when they"re green但只有当它们是绿色的时候PS：翻完了有点不明白，这首歌讲的是充满幻想的青春，年轻的生命要及时挥霍，对软弱刻板的愤世嫉俗么

MelShakerMelShaker是一名演员，主要作品有《关于恶魔的一切》。外文名：MelShaker合作人物：JoshuaGrannell职业：演员代表作品：《关于恶魔的一切》

用处尤克里里的fingershaker使用非常简单，把fingershaker直接套在右手尾指或无名指，上下拨弄琴弦时就会发出“沙沙”声。

over 做结束是是形容词。 end 有名词之义，也有动词之义， 均表示什么什么的结尾，结局。 做动词时： sthsb end up with/in 以什么告终。。 做名词时： in the end最终 at the end of 在什么什么的结尾 记得采纳啊

《shakers》第二部叫《W"z》。《W"z》是由GoHands制作的女性向原创电视动画作品，《握手者》（Hand Shakers）的续篇。

歌曲名:Hush歌手:Kula Shaker专辑:Top of the Pops 1997Na na na naa..na na naa na naa...Na na na naa..na na naa na naa...Well I got a silly little girl, she"s on my mindLook at her, she looks so fineShe"s a best girl i"ve ever hadExcept that she"s gonna make me feel so sadNa na na naa..na na naa na naa...Na na na naa..na na naa na naa...Hush, hush..I heard you"re calling my name nowHush, hush..you broke my heart but that was a dream nowHush, hush..I thought I heard you"re calling my name nowHush, hush..you broke my heart but that was a dream nowEarly in the morning, late in the eveningOh gotta believe me honey, i never was a dreamerHush, hush..I heard you"re calling my name nowHush, hush..you broke my heart but that was a dream nowHush, hush..I thought I heard you"re calling my name nowHush, hush..you broke my heart but that was a dream nowEarly in the morning, late in the eveningOh gotta believe me honey, i never was a dreamerNa na na naa na na naa na naaa..Na na na naa na na naa na naaa..http://music.baidu.com/song/59373684

歌曲名:Shakermaker歌手:Oasis专辑:Familiar To Millions - The HighlightsOASISDefinitely MaybeShakermaker 5:10I"d like to be somebody else and not know where I"ve beenI"d like to build myself a house out of plasticineAH....AH Shake along with meAH....AH Shake along with meI"ve been driving in my car with my friend Mr. SoftMr. Clean and Mr. Ben are living in my loftAH....AH Shake along with meAH....AH Shake along with meI"m sorry but I just don"t know I knowI said I told you soBut when you"re happy and you"re feeling fineThen you"ll know it"s the right timeThen you"ll know It"s the right timeTo shake along with me!shake along with me!shake along with me!Mister Sifter sold me songswhen I was just sixteenNow he stops at traffic lightsbut only when they"re greenAH....AH Shake along with meAH....AH Shake along with meAH....AH Shake along with mehttp://music.baidu.com/song/8736867

中文翻译为：方筛

莎克家具(Shake furniture)是美国的一个著名品牌，设计以简洁的美和纯朴的理念而著称，并带有十九世纪古典家具的色彩。

极限竞速地平线5bone shaker获得可在车展购买也可以在游戏商城中抽奖得到。 bone shaker获得方法介绍： 风火轮bone shaker，5车展购买，俗称铁头，骷髅头，玩家可以在游戏商城中抽奖或通过每次车展进行购买。有的时候还可以免费赠送。还可以通过车展购买或者别的途径。 document.write("

The Low-carbon EconomicNowadays,with more and more serious problems such as the increasing global temperture,the melting ice and the rising sea-levering,people are recognizing the important of developing the low-carbon economic now. There are many ways we can do to reach the loe-carbon economic.Fristly,discovering others fuels which is more clean and more green to instead of the using of carbon.Secondly, we should have the save-energy conscious and do something which we can make,for instance,using the bus ranther than car when you go out,re-use the thing that can be recycle used,reducing the use of plastic bags.Last but not least,we should plant more trees or other greenplants,in which way we can not only improve the environment,but also can make our home more beauty. In my opnion, the most important thing to reach the low-carbon economic is everyone must try their best do what they can do for it.Once everyone have the sence of low-carbon economic and have the action by themselves ,it will be earlier to reach it.

歌曲名:Shaker Hymns歌手:Dry The River专辑:Shallow Bed Live SessionsDry The River - Shaker HymnsWith my family on the right hand sideAnd your family on the leftWe got married in a single bedWe sang shaker hymnsWhen your warhorse grandfather had sungThe whole damn Song of SolomonWe toasted health in the front roomWe whiled away the afternoonMa fleur struck down with sicknessThe young medicine man"s got his face in a bookThere"s more bottles than the trees in green EnglandNot one of them will do my love no goodIn the morning I"m lightBut in the evening I"m heavy nowTry as I might I just can"t keep it steady nowMy loveEndhttp://music.baidu.com/song/13132339