5.11 泛型Generic ，Map接口

容器(Collection)
　　泛型(Generic)(JDK1.5之后才有泛型)
　　　　1, 装入集合的类型都被当作Object对待, 从而失去了自己的实际类型
　　　　2, 集合中秋出来的时候需要转型, 效率低, 易出错

　　　　好处: 增强程序的可读性和稳定性

　　　　注意: <>中定义的类型一定是引用类型 !!!

键：就是你存的值的编号
值：就是你要存放的数据

泛型写法

import java.util.ArrayList;
import java.util.List;

public class Test2 {

       public static void main(String[] args) {
	     List<Book> list = new ArrayList<Book>();   //< >里写什么，方法跟着一块变
	     list.add(new Book());
     }
}

Map 接口　：< >必须存两个类型　

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class Test2 {

	public static void main(String[] args) {
				
	     Map<String,String> map = new HashMap<String, Object>();
             //必须传两个类
	     Map<String, Object> map = new HashMap<String, Object>();
             //Object是传什么类型都可以          
  
	      map.put("a", "小明");             
	      map.put("b", new Book());
              System.out.println(map);    //   打印出b=Book  name=null
	      map.put("c", 123);
	      map.put("a", 456);
                            
     }
}

Map集合 的方法　

　　put(有个返回值Object)   
　　get
　　remove(也有个返回值)
　　containsKey
　　containsValue
　　size      指有几对
　　isEmpty     判断这个map集合是否为空
　　putAll        把另一个map集合里面的东西放到这个里面
　　clear      清空map集合里的内容，本身还存在

　　keySet---Set      
　　values---Conllection

put方法

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class Test2 {

	public static void main(String[] args) {	
		
		Map<String, Object> map = new HashMap<String, Object>();
		
		Object o1 = map.put("a", "小明");
		Object o2 = map.put("b", new Book());
		Object o3 = map.put("c", 123);
		Object o4 = map.put("a", 456);

                System.out.println(o1);
		System.out.println(o2);
		System.out.println(o3);
		System.out.println(o4);      
                //以上会打印 null   null   null  小明
                put 严格来讲不是往里添加，而是把原来的那个剑换成另一个值
                一开始实例化一个Map对象的时候，是没有a，小明这个值的，
                硬要获取值的话只能获取到null，这时候获取一下返回值o1,
                null就会给o1,当新添加一个a的时候，原来的值就会返回来
      }
}		

get 方法　　通过一个箭去取一个值

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class Test2 {

	public static void main(String[] args) {	
		
		Map<String, Object> map = new HashMap<String, Object>();
		
		Object o1 = map.put("a", "小明");
		Object o2 = map.put("b", new Book());
		Object o3 = map.put("c", 123);
		Object o4 = map.put("a", 456);
                
                System.out.println(map.get("c"))    //会打印出123
      }
}

remove 用法　有两种方法

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class Test2 {

	public static void main(String[] args) {	
		
		Map<String, Object> map = new HashMap<String, Object>();
		
		Object o1 = map.put("a", "小明");
		Object o2 = map.put("b", new Book());
		Object o3 = map.put("c", 123);
		Object o4 = map.put("a", 456);
                
                System.out.println(map.get("c"));
                map.remove("c");
                map.remove("a", 456);      //打印出b=Book name=null
                System.out.println(map);     //打印出a=456,b=Book name=null
                Object o =  map.remove("c");   //返回值
                System.out.println(o);    // 打印出123，就是把删掉的东西返回来了 
                Object o22 = map.remove("a", 456);  //返回值
	        System.out.println(o22);     //打印true,删除成功tru,失败false
      } 
}

containsKey 用法  判断是否包含某个键     containValue 判断是否包含某个值

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class Test2 {

	public static void main(String[] args) {	
		
		Map<String, Object> map = new HashMap<String, Object>();
		
		Object o1 = map.put("a", "小明");
		Object o2 = map.put("b", new Book());
		Object o3 = map.put("c", 123);
		Object o4 = map.put("a", 456);

            System.out.println(map.containsKey("b"));     //打印true，说明有的
    }

}

keySet---Set  map里所有的键封装成了一个set集合      values---Conllection  把值封装成一个集合

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class Test2 {

	public static void main(String[] args) {
		
		Map<String, Object> map = new HashMap<String, Object>();
		
		Object o1 = map.put("a", "小明");
		Object o2 = map.put("b", new Book());
		Object o3 = map.put("c", 123);
		Object o4 = map.put("a", 456);

                Set<String> set1 = map.keySet();   
                System.out.println(set1);                //打印出a,b,c
		Collection<Object> c = map.values();
                System.out.println(c);         //打印出456，Book name=null,123
 
      }

}

一道题　　

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

public class Test3 {

     public static void main(String[] args) {
	String[] arrs = {"aa","bb","cc","dd","aa","cc","ee","ee","cc","aa"};
	
	Map<String, Integer> map = new HashMap<>();
		
	for (int i = 0; i < arrs.length; i++) {
	 map.put(arrs[i], map.get(arrs[i]) == null ? 1 : map.get(arrs[i]) + 1);
        用三元运算符，等于空的时候是1，不等于的时候+1，
         下边是第二种方法
	  /*	Integer count = map.get(arrs[i]);
		if (count == null) {
			map.put(arrs[i], 1);
		} else {
			map.put(arrs[i], count + 1);
		}  */
	}
	System.out.println(map);
}

}

加强版for循环　

for (String s1 : set1) {
	System.out.println(s1);
		
	}
		
	/*
	 * 好处:
	 *简单方便, 效率高
	 * 
	 * 不能使用索引
	 * 不能通过变量来改变集合中的元素
	 * */

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

public class Test3 {

	public static void main(String[] args) {
		String[] arrs = {"aa","bb","cc","dd","aa","cc","ee","ee","cc","aa"};
		List<String> list = new ArrayList<>();
		list.add("qqqq");list.add("wwww");list.add("eeee");
		Set<String> set = new HashSet<>();
		set.add("1111");set.add("22222222222");set.add("3333333");
		
		for(String s1 : arrs) {
			System.out.println(s1);   //打印arrs
		}
		for (String s2 : list) {
			System.out.println(s2);   //打印list
		}
		for (String s3 : set) {
			System.out.println(s3);    // 打印set
		}
      }
}

Iterator接口
 　　所有实现了Collection接口的容器都有一个iterator方法, 用来返回一个实现了Iterator接口的对象
 　　Iterator对象称作迭代器, 用来方便的实现对容器内的元素的遍历
 　　Iterator里面的三个方法:
 　　　　hasNext()       有没有下一个，有的话返回下一个要遍历的元素
 　　　　next(), 重点注意: 这个方法每调用一次, 游标就往下走一个
 　　　　remove(), 不能与父类的方法混着用

用法举例

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

/**
 * 迭代器
 * 
 * @author Administrator
 */
public class Test4 {
	public static void main(String[] args) {

		List<String> list = new ArrayList<>();
		list.add("qqqq");
		list.add("wwww");
		list.add("eeee");
              	list.add("rrrr");
		
		Iterator<String> iter = list.iterator();
		
		while(iter.hasNext()) {
			String s = iter.next();
			System.out.println(s);
			if (s.equals("wwww")) {
			         iter.remove();
				//list.remove(iter.next());   两个不能混用
			}
		}
                 System.out.println(list);
    }

}

Comparable接口, Collections类
　　List的常用算法:
　　　　sort(List); 排序
　　　　　　如果需要对自定义的类进行排序, 那就必须要让其实现Comparable接口, 实现比较两个类大小的方法
　　　　shuffle(List); 随机排列
　　　　void reverse(List); 逆序排列(Linked效率较高)]
　　　　copy(); 复制集合, 前提是size()大于等于源集合的size(长度, 和容量的区别)
　　　　fill(List, Object);使用某个对象填充整个List
　　　　binarySearch();

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

/**
 * Collections
 * @author Administrator
 *
 */
public class Test5 {

	public static void main(String[] args) {
		// Arrays.sort
		// Collections.
		List<Integer> list = new ArrayList<Integer>();
		list.add(23);
		list.add(47);
		list.add(15);
		list.add(9);
		list.add(88);
		System.out.println(list);
		// Collections.sort(list); // 默认的从小到大
		// Collections.shuffle(list);   随机排列
		// Collections.reverse(list);    逆序排列，反转一下
		List<Integer> list2 = new ArrayList<Integer>();
		list2.add(1);
		list2.add(1);
		list2.add(1);
		list2.add(1);
		list2.add(1);
		Collections.copy(list2, list);
                //需要传两个集合，前面是要复制的，后面是原集合
                 要复制的集合要大于等于 要复制的集合
		System.out.println(list2);
		Collections.fill(list, 55);
		System.out.println(list);*/    //填充全部变成55了
		Collections.sort(list);       //必须先排序
		int i = Collections.binarySearch(list, 9);  二分查找法
		System.out.println(i);    //排序之后打印0
	}

}

如果list里装的是book，dog等对象，用comparable排序

public class Book implements Comparable<Book> {
	private String name;
	private double price;

	public Book() {
		super();
	}

	public Book(String name, double price) {
		super();
		this.name = name;
		this.price = price;
        }
 

        @Override
	public int compareTo(Book o) {
		if (this.price > o.getPrice()) {    大于返回正整数
			return 1;
		}
		if (this.price == o.getPrice()) {    等于返回0
			return 0; 
		}
		return -1;       小于返回负整数
	}
}

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

/**
 * Comparable
 * @author Administrator
 */
public class Test6 {

	public static void main(String[] args) {
		List<Book> list = new ArrayList<Book>();
		list.add(new Book("Java从入门到放弃", 78));
		list.add(new Book("Oracle数据库详解", 56));
		list.add(new Book("HTML入门", 3));
		list.add(new Book("三国演义", 108));
		Collections.sort(list);   
                //sort排序，因为是书所以没有标准排序所以要去自己写比较在上方代码红字		
		System.out.println(list);
	}

}

总结：

　　集合是数组的一种延伸, 与数组相比有很多好处和优点,
　　　　1, 可以存放不同的类型
　　　　2, 长度可变
　　　　3, 随时存放和获取

　　六个接口和一个类:
　　　　Collection
　　　　List
　　　　Set
　　　　Map
　　　　Iterator
　　　　Comparable

　　　　Collections工具类

　　选择一种集合类型是一件非常痛苦的事

　　在以后的编程中要考虑读取和修改的效率问题, 数据的存取在以后的使用过程中, Collection是主要的载体,
　　　　Array: 读快改慢
　　　　Linked: 读慢改快
　　　　Hash: 介于两者之间的