HashMap,HashTable,TreeMap区别和用法
java为数据结构中的映射定义了一个接口java.util.Map，而HashMap Hashtable和TreeMap就是它的实现类。Map是将键映射到值的对象，一个映射不能包含重复的键；每个键最多只能映射一个一个值。
Hashtable 与 HashMap类似,但是主要有6点不同。
1. 继承的父类不同。Hashtable继承自Dictionary类，而HashMap继承自AbstractMap类。但二者都实现了Map接口。
2.线程安全性不同。HashTable的方法是同步的，HashMap不支持线程的同步，即任一时刻可以有多个线程同时写HashMap;可能会导致数据的不一致。
如果需要同步，可以用Collections的synchronizedMap方法使HashMap具有同步的能力.，这个区别就像Vector和ArrayList一样。
3.key和value是否允许null值
HashTable的key和value都不允许null值,。 HashMap的 key 和 value 允许null值， 但是key值只能有一个null值，允许多条记录的值为Null。因为hashmap如果key值相同，新的key, value将替代旧的。
4. 是否提供contains方法
HashMap包含了containsvalue和containsKey 方法，不包含有contains，而 HashTable只有一个 contains(Object value) 功能 和 HashMap中的 containsValue(Object value)功能一样。
5. 内部实现使用的数组初始化和扩容方式不同。HashTable中hash数组默认大小是11，增加的方式是 old*2+1。HashMap中hash数组的默认大小是16，而且一定是2的指数。
6. hash值不同 . 哈希值的使用不同，HashTable直接使用对象的hashCode。而HashMap重新计算hash值。
hashmap和treemap什么区别？底层数据结构是什么？
无序： 不保证元素迭代顺序是按照插入时的顺序。
1. 底层实现不同。HashMap：数组方式存储key/value 。TreeMap：基于红黑二叉树的NavigableMap的实现，两个线程都不安全
2. HashMap 键允许为空，TreeMap键不能为空。
3.判断重复元素（指的键）不同，HashMap的键重复标准为重写equals() 和HashCode() , TreeMap 的键重复标准是比较器返回为0.
存入TreeMap的元素应当实现Comparable接口或者实现Comparator接口，两个相比较的key不得抛出classCastException。主要用于存入元素的时候对元素进行自动排序，迭代输出的时候就按排序顺序输出
4.TreeMap无序的，保存的记录根据键排序,默认是升序排序，也可以指定排序的比较器，当用Iterator 遍历TreeMap时，得到的记录是排过序的。而HashMap 是无须的 ，自然排序。
5.TreeMap添加的类型取决于第一个添加的键的类型（加上泛型就没有区别了）
TreeMap tmp=new TreeMap(); Iterator iterator_2 = tmp.keySet().iterator(); while (iterator_2.hasNext()) { Object key = iterator_2.next(); System.out.println(“tmp.get(key) is :”+tmp.get(key));
}
hashMap 底层原理：参考： https://blog.csdn.net/u010010428/article/details/51258238
HashMap 在底层将 key-value 当成一个整体进行处理，这个整体就是一个 Entry 对象。HashMap 底层采用一个 Entry[] 数组来保存所有的 key-value 对，
当 put() 需要存储一个 Entry 对象时，会根据hash算法来决定其在数组中的存储位置，再根据equals方法决定其在该数组位置上的链表中的存储位置；
当 get() 需要取出一个Entry时，也会根据hash算法找到其在数组中的存储位置，再根据equals方法从该位置上的链表中取出该Entry。
HashMap数组扩容时，原数组中的数据必须重新计算其在新数组中的位置，并放进去，这就是resize，这是一个非常消耗性能的操作，故预设元素的个数能够有效的提高HashMap的性能。
Map集合中HashMap
package HashMap类的常用方法; import java.util.Collection; import java.util.Collections; import java.util.HashMap; import java.util.Map; import java.util.Map.Entry; import java.util.Set; public class Test { public static void main(String[] args) { //1.继承关系 Map接口定义了键映射到值的规则，而AbstractMap类提供 Map 接口的骨干实现。 /* public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable */ //2.构造函数 涉及到底层原理，暂时不做解释 /* HashMap()：构造一个具有默认初始容量 (16) 和默认加载因子 (0.75) 的空 HashMap。 HashMap(int initialCapacity)：构造一个带指定初始容量和默认加载因子 (0.75) 的空 HashMap。 HashMap(int initialCapacity, float loadFactor)：构造一个带指定初始容量和加载因子的空 HashMap。 */ //3.实现了Map接口的常用方法 /* 1. Set entrySet() (返回当前Map中所有的entry对象(Entry对象就包装了key，values)，使用Set存储起来。) 2. Set keySet() 返回Map当中所有的key，存储到一个Set集合当中。 3. Collection values() 返回所有的values，存储到一个Collection。什么返回Collection？ 因为values 有重复，如果返回Set,就不能含有重复的元素. 4. Object get(Object key) 通过key查找对应的值。 */ //举例： Map map = new HashMap(); map.put(1, "我好"); map.put(2, "你好"); map.put(3, "大家好"); map.put(4, "啦啦啦"); map.put(5, "么么哒"); /* Set set = map.entrySet(); System.out.println(set); // [1=我好, 2=你好, 3=大家好, 4=啦啦啦, 5=么么哒] Set keys = map.keySet(); System.out.println(keys); // [1, 2, 3, 4, 5] Collection col = map.values(); System.out.println(col); // [我好, 你好, 大家好, 啦啦啦, 么么哒] Object obj= map.get(5); System.out.println(obj); //么么哒 */ //5.Map的遍历方式 /* 前言： 1. 不能使用普通for循环遍历Map元素，因为没有索引。 2. 使用增强for行不行？ 不能，没有实现Iterable接口，foreach就是通过Iterable接口在序列中进行移动。 3. Map里面并没有获得迭代器的方法；所有不能使用迭代器 方式一： 先通过keySet()方法取到所有key 然后遍历keySet,依次通过Object get(Object key)方法,来查找value。 */ Set keys = map.keySet(); for (Object object : keys) { System.out.print(object+":"+map.get(object));// "1:我好2:你好3:大家好4:啦啦啦5:么么哒" } /* 方式二： 先得到所有的Entry对象，遍历Entry对象的集合，然后依次从Entry对象中调用方法：getKey()，getValue() */ Set set = map.entrySet(); for (Object object : set) { Entry obj = (Entry)object; //需要把Object强制转成 Entry类型 System.out.print(obj.getKey()+":"+obj.getValue());// "1:我好2:你好3:大家好4:啦啦啦5:么么哒" } //6.使用Map集合解决：打印 字符串中 出现最多字符的 次数 /* 实例：Map使用示例: 有如下字符串，String str = “aaaabbbyyyccc”; * 1.统计出str中每一个字符的个数 比如 a - 4 b - 3 * 2.找出并打印，次数最多的字符和次数 */ /* public class Test { public static void main(String[] args) { String str = "aaaabbbyyyccc"; Map map = getChar(str); System.out.println(map); System.out.println(getCharAndValue(map)); } //统计每个字符出现的次数，并存储到map集合中 public static Map getChar(String str){ Map map = null; if(str!=null&&str.length()>0){ map = new HashMap(); for(char ch:str.toCharArray()){ if(map.containsKey(ch)){ map.put(ch, (int)map.get(ch)+1); }else{ map.put(ch, 1); } } } return map; } // 打印次数最多的字符和次数 。 public static String getCharAndValue(Map map){ if(map!=null&&map.size()!=0){ Collection values = map.values(); //方法一： 直接调用Collections里面的max方法 int max = (int)Collections.max(values); //方法二：用Collection中的toArray方法,把Collection转换成数组，然后调用Arrays中的工具方法sort求出 // Object[] arr = values.toArray(); // Arrays.sort(arr); // int max = (int)arr[arr.length-1]; String str = ""; Set set = map.keySet(); for(Object obj : set){ if(map.get(obj).equals(max)){ str = obj + ":"+max; } } return str; } return null; } } */ } }
顺便简单介绍下——泛型
1. 泛型类
public class Point<T> {
private T x;
private T y;
public Point(T x, T y) {
super();
this.x = x;
this.y = y;
}
public T getX() {
return x;
}
public void setX(T x) {
this.x = x;
}
public T getY() {
return y;
}
public void setY(T y) {
this.y = y;
}
}
2.泛型方法：只有在public 与 返回值中间声明了<T>的方法才是泛型方法
public <T> T genericMethod(Class<T> tClass)throws InstantiationException ,
IllegalAccessException{
T instance = tClass.newInstance();
return instance;
}
Object obj = genericMethod(Class.forName("com.test.test"));
3. 泛型的上限、下限
?号 ：表示通配符，不确定的类型，可以表示任意类型【? extends Object】 ；
? extends Number ：表示通配符?的上限 ，必须是Number及Number的子类
? Super Number: 表示通配符?的下限，必须是Number及Number的父类
public class GenericTest {
public static void main(String[] args) {
GenericTest test = new GenericTest();
test.test(new ArrayList<Integer>());
test.test2(new ArrayList<Object>());
}
public void test(List<? extends Number> list){ }
public void test2(List<? super Number> list) { }
}
4、 泛型的优点
编译时类型检查，消除强制类型转换，没有泛型的返回，我们可以认为是一个Object，在使用时需要对其进行强制转换，在转换过程中，非常容易出现ClassCastException。