1.TreeMap。
1.1TreeMap也是可以排序的：自然排序，定制排序。此时的排序是针对于TreeMap中的key来讲的，所有的key构成TreeSet。
1.2所存储的key必须是同一类创建的对象。
2.Collections 常用方法。
- reverse(List)：反转List中元素的顺序。 shuffle(List)：对List集合元素进行随机排序。
- sort(List)：根据元素的自然顺序对指定List集合元素按升序排序。
- sort(List,Comparator)：根据指定的Comparator产生的顺序对List集合元素进行排序。
- swap(List,int,int)：将指定list集合中的i处元素和j处元素进行交换。
- Object max(Collection)：根据元素的自然顺序，返回给定集合中的最大元素。
- Object max(Collection,Comparator)：根据Comparator指定的顺序，返回给定集合中的最大元素。
- Object min(Collection)：根据元素的自然顺序，返回给定集合中的最小元素。
- Object min(Collection,Comparator)：根据Comparator指定的顺序，返回给定集合中的最小元素。
- int frequency(Collection,Object)：返回指定集合中指定元素的出现次数。
- void copy(List dest,List src)：将src中的内容复制到dest中。
- boolean replaceAll(List list,Object oldVal,Object new Val)：使用性值替换List对象的。
3.泛型。
泛型是JDK5.0新增特性。
1.泛型参数只能使用引用类型变量来充当，不能使用基本数据类型。
2.集合中，如果没有使用泛型，则默认为Object类型。
如果集合中使用泛型，则集合的相关属性、方法中，凡是使用到类或接口泛型参数的地方，都调整为具体的泛型类型。
3.什么时候使用泛型？首先，类或接口应该声明为泛型类、泛型接口。其次，在实例化类时，就可以指明泛型参数的类型。
4.在提供泛型类的子类时，可以指明泛型参数的类型，一旦指明，子类继承父类的结构中，凡是使用泛型参数的地方都调整为具体的泛型的类型。
5.泛型声明不能使用static关键字修饰。
6.泛型不能充当异常类型，不能在catch中使用泛型参数。
3.1在集合中使用泛型前的例子。
public void test1(){
List list = new ArrayList();
list.add(89);
list.add(54);
list.add(76);
list.add(345);
list.add(56);
//问题一：类型不安全。
list.add("AA");
for(int i = 0;i<list.size();i++){
Object obj = list.get(i);
//问题二：需要强转，一方面繁琐，一方面可能报ClassCastException
int sorce = (int) obj;
System.out.println(sorce);
}
}
3.2在集合中使用泛型后的例子。（重点）
public void test2(){
List<Integer> list = new ArrayList<Integer>();
list.add(23);
list.add(324);
// list.add("sdfjs");
Iterator<Integer> iterator = list.iterator();
while(iterator.hasNext())
System.out.println(iterator.next());
}
public void test3(){
HashMap<String,Integer> map = new HashMap<>();//类型推断。类似于： int[] arr = {1,2,3};
map.put("Tom", 12);
map.put("LiLei",34 );
map.put("HanMeimei", 34);
map.put("Jim", 5);
map.put("Jerry", 45);
Set<Map.Entry<String, Integer>> entrySet = map.entrySet();
Iterator<Entry<String, Integer>> iterator = entrySet.iterator();
while(iterator.hasNext()){
Entry<String, Integer> next = iterator.next();
System.out.println(next.getKey()+"--->"+next.getValue());
}
}
3.3如何自定义泛型类、泛型接口、泛型方法。
package genericTest;
import java.util.List;
/**
* 自定义泛型类
* @author DengDan E-mail:1173922872@qq.com
* @version CreateTime:2018年10月5日 下午4:35:39
* @param <T>
*/
public class Order<T> {//T:泛型参数
String orderName;
int orderId;
T t;
public Order(){}
public Order(String orderName,int orderId,T t){
this.orderName = orderName;
this.orderId = orderId;
this.t = t;
}
public String getOrderName() {
return orderName;
}
public void setOrderName(String orderName) {
this.orderName = orderName;
}
public int getOrderId() {
return orderId;
}
public void setOrderId(int orderId) {
this.orderId = orderId;
}
// 不是泛型方法
public T getT() {
return t;
}
// 不是泛型方法
public void setT(T t) {
this.t = t;
}
public void show(){
System.out.println("name = "+orderName + ",t = "+t);
}
// 泛型方法：泛型方法所在的类，不一定是泛型类，普通类也可以。
// 在返回值前面加上 <E>,代表泛型方法。
// 泛型方法的泛型参数，是在方法调用时指明的。
// 可以使用static修饰泛型方法。
public static <E> List<E> fromArrayToList(E[] arr,List<E> list){
for(E e:arr)
list.add(e);
return list;
}
}
3.4泛型在继承方面的体现。（重点）
package genericTest;
public class SubOrder<T> extends Order<T> {}
如果A类是B类的父类，则List < A > 不是List< B >的父类，他们是并列结构的。
推广：G< A >也不是G< B >的父类。
3.5通配符的使用。（重点）
通配符：?
比如：List<?>是List<A>的父类，其中A代表任何一个确定的类。
推广：G<?>是G<A>的父类。
不可以向声明为通配符的结构中写入数据，唯独可以写入null。
可以被读声明为通配符的结构中的数据。
有限制条件的通配符的使用：
? extends A:
可以将G<B>或G<A>赋值给G<? extends A >。其中B是A类的子类。
? super A:
可以将G<B>或G<A>赋值给G<? super A >。其中B是A类的父类。
public void test(){
List<?> list = null;
List<? extends Number> list1 = null;
List<? super Number> list2 = null;
List<Object> list3 = null;
List<Number> list4 = null;
List<Integer> list5 = null;
//list1 = list3;//不能赋值
list1 = list4;
list1 = list5;
list2 = list3;
list2 = list4;
//list2 = list5;//不能赋值
}