有关于map，泛型，collections的概念以及用法的讲解

1.有关于map接口：

map接口常用的hashmap以及treemap
以及有关于properties
map接口简介：map接口是一种双列集合，他的每个元素都包含一个键对象key和一个值对象values，值和键之间存在这一种对应的关系，称之为映射。从map集合之中访问元素时，只要指定了key，就能找到值value
使用较多的用法：
put(Object key,Object value)以及get(Object key,Object value)
put方法时存入元素，get方法时取出元素
keySet()和values()方法用于获取map中所有的键和值

有关于hashmap，是map接口的一个实现类，用于存储键值映射关系，但必须保证不会重复键；hashmap特征是：键相同，值覆盖
使用一个例子：

import java.util.*;
public class imp{
 public static void mian(String []args){
  Map map = new Map();
map.put("1","smalls");
map.put("2","bigs");
System.out.println("1:"+map.get("1"));
System.out.println("2:"+map.get("2"));
}
}

他的输出是：

1：smalls
2:bigs

添加一个新元素

import java.util.*;
public class imp{
 public static void mian(String []args){
  Map map = new Map();
map.put("1","smalls");
map.put("2","bigs");
map.put("2","sl");
System.out.println("1:"+map.get("1"));
System.out.println("2:"+map.get("2"));
}
}

输出是：

1：smalls
2:sl

map的
keySet获得存储在map中所有键的set集合
entrySet()获得存储在map中所有映射的set集合
注意：使用hashmap集合迭代出来的元素的顺序是与存入的顺序是不一致的
例如

import java.util.*;
public class imp{
 public static void mian(String []args){
  Map map = new Map();
map.put("1","smalls");
map.put("2","bigs");
Set entrySet = map.entrySet();
Iterator it =entrySet.iterator();
while(it.hasNaxt()){
Map.Entry entry =(Map.Entry)(it.next());
Object key = entry.getKey();
Object value = entry.getValue();
System.out.println(key+":"+value);
}
}
}

输出的结果：

2：bigs
1:smalls

如果想要解决这个问题就需要使用map当中的LinkedHashMap来解决

import java.util.*;
public class imp{
 public static void mian(String []args){
  Map map = new LinkedHashMap();
map.put("1","smalls");
map.put("2","bigs");
Set keySet = map.keySet();
Iterator it =entrySet.iterator();
while(it.hasNaxt()){
Map.Entry entry =(Map.Entry)(it.next());
Object key = it.next();
Object value = map.get(key);
System.out.println(key+":"+value);
}
}
}

结果是：

1：smalls
2:bigs

TreeMap:与hashmap同样的是存储键值存储的，必须保证不能出现相同的键
使用hashmap时使用链表进行连接的
而treemap是使用二叉树进行连接的
例子：

import java.util.*;
public class imp{
 public static void mian(String []args){
  TreeMap tm = new TreeMap();
map.put("1","smalls");
map.put("2","bigs");
Set keySet = tm.keySet();
Iterator it =entrySet.iterator();
while(it.hasNaxt()){
Object key = it.next();
Object value = tm.get(key);
System.out.println(key+":"+value);
}
}
}

实现的值是

1：smalls
2:bigs

map当中的properties:
在map接口当中还有hashtable，和hashmap特别的相似
区别是Hashtable的线程是安全的，只不过Hashtable存取元素的时候速度很慢

priperties是hashtable的子类，主要作用是存储字符串类型的键和值
在程序当中通常使用properties来对配置项进行存取

import java.util.*;
public class imp{
 public static void mian(String []args){
 Peoperties p = new properties();
p.setProperty("backgroup-color","red");
p.setProperty("Font-size","14px");
p.setProperty("Language","chinese");
Enumeration names = p.propetyName();
while(names.hasmoreElements()){
String key= (String)names.nextElements();
String value =  p.getProperty(key);
System.out.println(key+":"+value);
}
}
}

执行的结果是

backgroup-color=red
Fort-size=14px
Language=chinese

2.泛型：

有关于泛型，以前发过，可是没有一些了解就总是稀里糊涂的
举一个编译不能通过的例子

import java.util.*;
public class imp{
 public static void mian(String []args){
ArrayList list = new ArrayList();
list.add("Mygile");
list.add("Yourboy");
list.add(1);
for(Object obj:list){
String str = (String)obj;
System.out.printn(obj);
}
}
}

这一段会出错，原因在于Integer 不能转化成String类型
不能将1转化成String类型
因此就引入泛型的概念
泛型目的：限定方法操作的数据类型
一般的格式就是

ArrayList<参数化类型>list= new ArrayList<参数化类型>();

自定义泛型:需要定义save()以及get()方法
例如：

class cachepool<T>{
T temp;
public void save(T temp){
this.temp=temp;
}
public void get(){
return temp;
}
}
public class emp{
public static void main(String []args){
cachepool<Integer> pool = new cachepool<Integer>();
pool.save(new Integer(1));
 Integer temp = pool.get();
System.out.println(temp);
}
}

最终的输出结果是

1

3.collections工具类

1.用于排序操作

import java.util.*;
public void emp{
public static void main(String []args）{
ArrayList list== new ArratList();
Collections.addAll(list,"C","Z","B","K");
System.out.println("排序前："+list);
Collections.reverse(list);//反转集合
System.out.println("反转后："+list);
Collections.sort(list);//按自然顺序排列
System.out.println("按自然顺序排序后："+list);
Collection.shuffle(list);//对元素进行随机排序
System.out.println("洗牌后："+list);

}
}

输出结果

排序前：[C,Z,B,K]
翻转后：[K,B,Z,C]
按自然顺序排列后：[B,C.K.Z]
洗牌后：[K,C,B,Z]

之外还有
swap(List list ,int i,int j):是将List当中i与j的位置进行交换
2.查找替换

import java.util.*;
public void emp{
public static void main(String []args）{
ArrayList list== new ArratList();
Collections.addAll(list,-3,2,9,5,8);
System.out.println("集合中的元素："+list);
System.out.println("集合中最大的元素："+Collections.max(list));
System.out.println("集合中最小的元素："+Collection.min(list));
Collections.replaceAll(list,8,0);
System.out.println("替换后的集合："+list);

}
}

输出结果是：

集合中的元素：[-3,2，9,5,8]
集合中最大的元素：9
集合中最小的元素：-3
替换后的集合：[-3,2,9,5,0]