[黑马程序员]（第10-15天）集合类（下）

------- android培训、 java培训、期待与您交流！ ----------

HashMap里还有最后一个东西：LinkedHashMap
与LinkedList一样都是使用双向链表来维护内部元素的关系，使得Map元素的迭代的顺序与存入的顺序一致。。所以它的特点就是：迭代出来的元素顺序和存入的顺序一致




public class Example18 {
public void static main(String[] args){
Map map = new LinkedHashMap();
map.put("1","qqq");
map.put("2","www");
map.put("3","eee");

//获取全部键的集合
Set keys = map.keySet();
//获取迭代器
Iterator it = keys.iterator();
while(it.hasNext()){
Object key = it.next();
Object value = map.get(key);
System.out.println(value);
}
}
}



TreeMap:通过二叉树的原理来保证键的唯一性，与TreeSet集合存储的原理一样，因此TreeMap中所有的键都是按照某种顺序排列的,其中最关键的还是比较器
一般根据String类型来排序，String类实现了Comparable接口，因此会默认按照自然顺序进行排序，当然也可以自定义选择器。


一般情况：
class Example19{
public void static main(String[] args){
Map map = new TreeMap(); //new一个TreeMap
map.put("1","feriosa"); //向Map中放入键值对
map.put("2","max");
map.put("3","nux");

Set keys = map.keySet(); //得到全部键的集合
Iterator it  = keys.iterator(); //得到迭代器
while(it.hasNext()){ //开始迭代
Object key = it.next();
Object value = map.get(key) //得到键所对应的值
}


}
}


如前所述，会按照String类型来排序(默认为从小到大)


自定义选择器的情况：(从大到小)
class Example20{
public void static main(String[] args){
Map map = new TreeMap(new MyComparator()) //传入自定义选择器的实例
map.put("1","feriosa");
map.put("2","max");
map.put("3","nux");

Set keys = map.keySet(); //得到键的Set集合
Iterator it = keys.iterator(); //得到迭代器
while(it.hasNext()){ //开始迭代
Object key = keys.next();
Object value = map.get(key);
System.out.println(value);


}
}


class MyComparator implements Comparator { //自定义选择器
public int compare(Object o1, Object o2){
String s1 = (String) o1;
String s2 = (String) o2; //强转为String类型

return s1.compareTo(s2); //返回较大值
}
}




jdk5.0的新特性---泛型


泛型：参数化类型---使用<参数化类型>的方式指定该类中方法操作的数据类型
public class Example23{
public void static main(String[] args){
ArrayList list = new ArrayList();
list.add("Feriosa");
list.add("max");
list.add(1);
for(Object obj ： list){
String str = (String) obj;
}
}
}






public class Example24{
public void static main(String[] args){
ArrayList<String> list = new ArrayList<String>();
list.add("Feriosa");
list.add("max");
for(String str : list){
System.out.println(str);
}
}
}
使用“参数化类型”的方式指定该类中方法操作的数据类型
使用“参数化类型”的方式指定该类中方法操作的数据类型
使用“参数化类型”的方式指定该类中方法操作的数据类型
这样做的好处是：在编译的时候就可以解决错误，避免在程序运行时发生错误


自定义泛型：


在定义一个类的时候使用<T>申明参数类型，它的一些方法的参数类型或者返回值类型也都申明为T


class cachePool<T> {
T temp;
public void save(T temp){
this.temp = temp;
}
public T get(){
return temp;
}
}


全类中只能出现一种数据类型---T


class Example25{
public void static main(Sring[] args){
cachePool<Integer> cp  = new cachePool<Integer>; //传入Integer
cp.savez(new Integer(111));
Integer i  = cp.get;
}
}




Collections工具类：


根据api文档呢，有大概这几个常用的静态方法：
排序：
（这里复习一下学习循环语句时学的那几段有关排序和选择的代码）


首先明确一下这些方法是干嘛的：
选择排序+冒泡排序---》排序
二分法---》查找（如果数组是无序的，简单遍历查找就ok，如果数组是有序的，那么二分查找就比较好）




之前见到的一个排序api:Arrays.sort()---刚看了一下下一小节，arrays工具类是专门用来操作数组的，而Collections是用来操作集合的


Collections的排序：
static<T> boolean addAll(Collection<?super T> c , T...elements)---将所有指定元素添加到指定的collection中---感觉有了addAll(),不用再一个个添加了
static void reverse(List list)---反转
static void shuffle(List list)---随机排序（“洗牌”）；
static void sort(List list)---按自然顺序排序
static void swap(List list , int i , int j )---将指定集合中i处元素和j处元素进行交换


public class Example26{
public void static main(String[] args){
ArrayList list = new ArrayList();
Collections.addAll(list,"feriosa","max","nux");
Collections.reverse(list);
Collections.shuffle(list);
Collections..sort(list);
Collections.swap(list,0,1);
}
}


查找和替换操作：
static int binarySearch（List list , Object key)---使用二分法搜索指定的对象在List集合中的索引，查找的List集合中的元素必须是有序的
static Object max(Collection col)
static Object min(Collection col)
static boolean replaceAll(List list, Object oldVal , Object newVal)










ok,Arrays.sort()表示数组的排序，那么逻辑思路上有两种方法---》选择法和冒泡法
其实这两种方法是路上只差一点，代码上也只差几行
选择法：依次拿数组的每一个去与它后面的每一个去比较，用大的换小的，这样一直比下去，就是左小又大
冒泡法：左边一直两两相比，留下在右边相对最大的


直接点说就是：
选择法是右边的依次和左边的比，左边留下最小的
冒泡法是总是从左边两个两个相比，然后留在右边相对最大的




代码上for(int x = 0; x < arr.length -1 ; x++)过后：
选择法：for(int y  = x + 1 ; y < arr.length ; y++)
冒泡法:for(int y = 0 ; y < arr.length  - 1- x ; y++)


这两句代码之后：
选择法：
if(arr[x] > arr[y]){
temp = arr[x];
arr[x] = arr[y];
arr[y] = temp;
}
冒泡法：
if(arr[y]>arr[y+1]){
temp = arr[y];
arr[y] = arr[y+1];
arr[y+1] = temp;
}




(选择法还有一个优化版本，即先记录每一轮比较完成之后最值的角标，然后最后才用swap(int[] arr , int x, int y)来实现交换


详见代码：
public static void selectSort(int[] arr){
for(int x = 0 ;  x < arr.length - 1 ;  x++){
arr[x] = arrx;
index = x;
for(int y = x + 1; y < arr.length ; y ++){
if(arrx > arr[y]){
arrx = arr[y];
index= y ;
}
}
if(index != x )
swap(arr,x , index);
}
}


public static void swap(int[] arr, int x , int y ){
int temp; 
temp = arr[x];
arr[x] = arr[y];
arr[y] = temp;
}




终于搞定了这几个排序方法（两个---选择和冒泡）
还有一个binarySearch(Object[] , Object key)对应的二分法：
其实二分法超级简单(但要注意其中使用了一个while循环）


public int binarySearch(int[] arr, int x) {
int max = arr.length -1 ; 
int min = 0 ; 
int mid  =(min + max) / 2 ; 


while(min != max){
if(arr[mid] > x){
max = mid -1 ; 
}else if(arr[mid]< x){
min = mid +1 ; 
}else if (max < min ){
return -1;
}
mid = (max +ｍin)/2;
}
return mid;
}


或者：
public int binarySearch(int[] arr , int x ){
int max  = arr.length -1 ; 
int min  = 0 ;
int mid ;


while(min < max){
mid = (min +max)>>1;

if(arr[mid] > x ){
max = mid -1 ; 
}else if (arr[mid] < x){
min = mid +1 ; 
}else{
return mid;
}
}

return -1; //这种情况是min>= max,直接方法-1即可
}


好现在再来看Arrays类的常有静态方法：
Arrays.sort(int[] arr)---排序（类似选择法或者冒泡法）
Arrays.binarySearch(Object[] a, Object key)---查询（ 类似二分法）
Arrays.copyOfRange(Object[] original, int from, int to)---拷贝元素（在不破环原数组的情况下）
Arrays.fill(Object[] a, Object val)---填充元素
Arrays.toString(int[] arr)---将数组转化成为字符串




等一下，在Map类中还有最后一个常用实现类没有学---HashTable(Properties)
Hashtable与HashMap十分相似，区别在于Hashtable是线程安全的，存取元素很慢。Properties是它的一个子类，用来处理存取应用的配置项。
注意：Properties要用到Enumeration枚举（上一次见它是在Vector那儿，
Enumeration e = vector.elements())
在这儿，Enumeration e  = p.propertyNames();
setProperty()+getProperty()就是全部了。


class Example22 {
public static void main(String[] args){
Properties p = new Properties();
p.setProperty("font-size","15px");
p.setProperty("Language","Putonghua");
//获取Enumeration所有键的枚举
Enumeration e = p.prepertyNames();
while(p.hasMoreElements()){
String key = e.nextElement();
String value = p.getProperty(key);
System.out.println(key+":"+value);
}
}
}


这样，集合类搞定。