java基础复习-map与collection set+list集合总结

-------------MAP   Map<K,V>成对出现，K唯一，V可重复。    举例：  学号  姓名
----HashMap特点：无序                   
           建立集合：    Map<String,String> map = new HashMap<String,String>
                          添加元素：   map.put（"邓超","孙俪"）   返回上一个值（后面那个）
                          移除元素：   map.clear（）；   移除所有元素
                                       map.remove("K");   移除键值K，附带移除对应的值V 
                          判断:          是否包含 map.containskey("K");
                                         是否为空 map.isEmpty（）;
                          长度：         map.size（）;  判断集合MAP有多少对元素   
                          获取：      map.get（K）  返回K对应的V 

                  遍历集合所有的键：
                                 Set<类型> *** = map.keySet();
                                 for(String **:***){
                                            syso(**);
                                    }
                   遍历集合所有的值:
                                 Collection <类型> *** =map.values();
                                  增强for
                  遍历所有的对： 第一种：
                               先遍历键K，在增强for中获取V：string * =map.get（key）；
                                    syso(key +"-----" + value)   ;
                                 第二种：（理解）
                               // 获取所有键值对对象的集合
		            Set<Map.Entry<String, String>> set = map.entrySet();
		          // 遍历键值对对象的集合，得到每一个键值对对象
		             for (Map.Entry<String, String> me : set) {
			  // 根据键值对对象获取键和值
			   String key = me.getKey();
			   String value = me.getValue();
			   System.out.println(key + "---" + value);

----------LinkHashMap：有序（存储序列）唯一
----------TreeMap ：  自然排序  唯一                        例题：treemapdemo
                   对于key是类对象，需要重写方法。 
           案例：  public class TreeMapDemo2 {
	public static void main(String[] args) {
		// 创建集合对象
TreeMap<Student, String> tm = new TreeMap<Student, String>(new Comparator<Student>() {
				
			public int compare(Student s1, Student s2) {
						// 主要条件
			int num = s1.getAge() - s2.getAge();
						// 次要条件
	int num2 = num == 0 ? s1.getName().compareTo(s2.getName()) : num;
				return num2;
					}
				});

		// 创建学生对象
		Student s1 = new Student("潘安", 30);...............

-------------------------------------嵌套  hashmap-hashmap  例题：hashmapdemo2.java
                                           hashmap-arraylist  自己写，简单
                                           综合嵌套   看例题 hashmapdemo.java


----------------------------------- * 1:Hashtable和HashMap的区别?
              * Hashtable:线程安全，效率低。不允许null键和null值
              * HashMap:线程不安全，效率高。允许null键和null值

---------------------------------2:List,Set,Map等接口是否都继承子Map接口?
                    * List，Set不是继承自Map接口，它们继承自Collection接口
                    * Map接口本身就是一个顶层接口





-------------------------------------collections 集合
                           Collections.sort(list);排序 默认情况下是自然顺序。
                           Collections.binarySearch(list, 30)；二分查找
                           Collections.max(list)；最大值
                           Collections.reverse(list);反转
                           Collections.shuffle(list);随机置换

                -------- 同时出现自然排序和比较器排序，以比较器为主--------




------------------- * 模拟斗地主洗牌和发牌
 * 
 * 分析：
 * 		A:创建一个牌盒
 * 		B:装牌
 * 		C:洗牌
 * 		D:发牌
 * 		E:看牌                 例题：PokerDemo.java 地址http://download.csdn.net/detail/qq_34446485/9921208 其他同

 Collection:是集合的顶层接口，它的子体系有重复的，有唯一的，有有序的，有无序的。(后面会慢慢的讲解)
 * 
 * Collection的功能概述：
 * 1：添加功能
 * 		boolean add(Object obj):添加一个元素
 * 		boolean addAll(Collection c):添加一个集合的元素
 * 2:删除功能
 * 		void clear():移除所有元素
 * 		boolean remove(Object o):移除一个元素
 * 		boolean removeAll(Collection c):移除一个集合的元素(是一个还是所有)
 * 3:判断功能
 * 		boolean contains(Object o)：判断集合中是否包含指定的元素
 * 		boolean containsAll(Collection c)：判断集合中是否包含指定的集合元素(是一个还是所有)
 * 		boolean isEmpty()：判断集合是否为空
 * 4:获取功能
 * 		Iterator<E> iterator()(重点)
 * 5:长度功能
 * 		int size():元素的个数
 * 		面试题：数组有没有length()方法呢?字符串有没有length()方法呢?集合有没有length()方法呢?
 * 6:交集功能
 * 		boolean retainAll(Collection c):两个集合都有的元素?思考元素去哪了，返回的boolean又是什么意思呢?

 * 7：把集合转换为数组
 * 		Object[] toArray()

--------------------------
          // Collection c = new Collection(); //错误，因为接口不能实例化
		Collection c = new ArrayList();

char[] chs =s.toCharArray();      toCharArray -把字符串转换成字符数组

16课时.
                      建立一个集合   （list集合）
-------------------------（arraylist）   泛型：在引用和重写后+类型<>，可避免强转，优化程序
              ArrayList ** =new ArrayList();   
              add 添加

遍历 ：（用了泛型） 1.   Iterator<String> *** =**.iterator<String>（）;
                        while（it.hasNext（））{
                  String * =***.next();   //存储的对象是什么，用什么接收。-双String-
                  System.out.println(*);                    
}
 
         2.for(int x=0;x<array.size();x++){
              String * =(String)array.get(x); //存储的对象是什么，用什么接收。-双String-
              System.out.println(*);
}


ArrayList去除集合中字符串的重复值:       
             注：方法1中如果集合对象是一个类，则需在引用的类中重写equals方法，否则报错
         1.     // 创建新集合
		ArrayList newArray = new ArrayList();

		// 遍历旧集合,获取得到每一个元素
		Iterator it = array.iterator();
		while (it.hasNext()) {
			String s = (String) it.next();

			// 拿这个元素到新集合去找，看有没有
			if (!newArray.contains(s)) {
				newArray.add(s);
			}
		}

          2.// 由选择排序思想引入，我们就可以通过这种思想做这个题目
		// 拿0索引的依次和后面的比较，有就把后的干掉
		// 同理，拿1索引...
		for (int x = 0; x < array.size() - 1; x++) {
			for (int y = x + 1; y < array.size(); y++) {
				if (array.get(x).equals(array.get(y))) {
					array.remove(y);
					y--;
				}
			}
		}
-----------------------------（vector）      add  get  Iterator 等对应，可替换

		// 创建集合对象
		Vector v = new Vector();

		// 添加功能
		v.addElement("hello");
		v.addElement("world");
		v.addElement("java");

 遍历：1.for (int x = 0; x < v.size(); x++) {
			String s = (String) v.elementAt(x);
			System.out.println(s);
		}


       2.Enumeration en = v.elements(); // 返回的是实现类的对象
		while (en.hasMoreElements()) {
			String s = (String) en.nextElement();
			System.out.println(s);
		}
	}

--------------------------（LinkedList）   remove移除的元素会被返回

                 LinkedList link = new LinkedList(); // 创建集合对象
		 link.addFirst("javaee");
		 link.addLast("android");
		 System.out.println("getFirst:" + link.getFirst());
		 System.out.println("getLast:" + link.getLast());
		 System.out.println("removeFirst:" + link.removeFirst());
		 System.out.println("removeLast:" + link.removeLast());
                  遍历通用

-----------------------------------------------------------------------------------------
泛型：     
        1.用在类 （在实现的时候需要每次注明类型）
                    public class ObjectTool<T> {
	              private T obj;

       用法：   ObjectTool<String> ot = new ObjectTool<String>();
		ot.setObj(new String("林青霞"));
		String s = ot.getObj();
		System.out.println("姓名是：" + s);

		ObjectTool<Integer> ot2 = new ObjectTool<Integer>();
		ot2.setObj(new Integer(27));
		Integer i = ot2.getObj();
		System.out.println("年龄是：" + i);

        2.用在方法上   （无论什么类型直接引用，无需注明） 
             public <T> void show(T t) {
		System.out.println(t);
	}
          用法：ObjectTool ot = new ObjectTool();
		ot.show("hello");
		ot.show(100);
		ot.show(true);


          3.用在接口上
    写接口  public interface Inter<T> {
	                public abstract void show(T t);
                         }

    写类
                      --第一种情况：已经知道该是什么类型的了

                      //public class InterImpl implements Inter<String> {        
                      //	public void show(String t) {
                      //		System.out.println(t);
                      //	}
                      // }

                      --第二种情况：还不知道是什么类型的
                       public class InterImpl<T> implements Inter<T> {
                     	public void show(T t) {
	          	System.out.println(t);
	                 }
                          }

     测试
                 public static void main(String[] args) {
		// 第一种情况的测试  <>与引用类一致
		// Inter<String> i = new InterImpl();
		// i.show("hello");

		// // 第二种情况的测试
		Inter<String> i = new InterImpl<String>();
		i.show("hello");

		Inter<Integer> ii = new InterImpl<Integer>();
		ii.show(100);
	}



----------- 泛型高级(通配符)
               // 泛型如果明确的写的时候，前后必须一致（//后的是报错的）
		Collection<Object> c1 = new ArrayList<Object>();
		// Collection<Object> c2 = new ArrayList<Animal>();
		// Collection<Object> c3 = new ArrayList<Dog>();
		// Collection<Object> c4 = new ArrayList<Cat>();

		// ?表示任意的类型都是可以的
		Collection<?> c5 = new ArrayList<Object>();
		Collection<?> c6 = new ArrayList<Animal>();
		Collection<?> c7 = new ArrayList<Dog>();
		Collection<?> c8 = new ArrayList<Cat>();

		// ? extends E:向下限定，E及其子类
		// Collection<? extends Animal> c9 = new ArrayList<Object>();
		Collection<? extends Animal> c10 = new ArrayList<Animal>();
		Collection<? extends Animal> c11 = new ArrayList<Dog>();
		Collection<? extends Animal> c12 = new ArrayList<Cat>();

		// ? super E:向上限定，E极其父类
		Collection<? super Animal> c13 = new ArrayList<Object>();
		Collection<? super Animal> c14 = new ArrayList<Animal>();
		// Collection<? super Animal> c15 = new ArrayList<Dog>();
		// Collection<? super Animal> c16 = new ArrayList<Cat>();
	}
}

class Animal {
}

class Dog extends Animal {
}

class Cat extends Animal {
}


                      jdk5新特性
----------------------------------------------------------------------------------------
              -------------------------------------增强for：
for（元素类型 *：数组或集合）{
           system.out.println（*）；
}
//用来给数组或者集合遍历，及其简单，但是对于数组或者集合不能为空，（null ），
  解决办法，加一个if判断。   if（数组 ！=null）{}     。一般用来替代集合迭代器


------------------------------------------------------------------------------------
        ---------------------------静态导入（一般不用，非静态方法不能用，错误多）
 格式：import static 包名.类名.方法名. 
          用的时候可直接引用方法
                              
------------------------------------------------------------------------------------
       -------------------可变参数
格式： 修饰符 +返回值类型+方法名+（数据类型...+变量名）{}
       比如 public static int sum （int...a）{
            int s=0;
            for(int x:a){
              s +=x;                  //a相当于一个数组，遍历后自家，用于不知道多少个数
             }                        //的变量相加（左边的方法）
              return s;
            }
-----------------------------------------------------------------------------------------
           --------------------数组转集合-------这种转化的集合不能增删，但是能改
                                                保留了数组的特性：长度不变
           import java.util.Arrays；
           
           List<String> list = Arrays.asList(数组名字或者直接多个元素)
-----------------------------------------------------------------------------------------
             ------------------嵌套集合
                      // 创建大集合
ArrayList<ArrayList<Student>> bigArrayList =new ArrayList<ArrayList<Student>>();

		        // 分别创建小集合
		ArrayList<Student> firstArrayList = new ArrayList<Student>();
                        // 遍历嵌套集合
		for (ArrayList<Student> array : bigArrayList) {
			for (Student s : array) {
				System.out.println(s.getName() + "---" + s.getAge());
			}
		}
----------------------------------------------------------------------------------------
                             -----------------例题

import java.util.ArrayList;        
import java.util.Random;
 * 获取10个1-20之间的随机数，要求不能重复
 * 
 * 用数组实现，但是数组的长度是固定的，长度不好确定。
 * 所以我们使用集合实现。
 *                                                
           //     random：该值大于等于0.0且小于1.0，即取值范围是[0.0,1.0)的左闭右开区间
           //     contains：包含就返回true    equals：相等返回true
 * 分析：
 * 		A:创建产生随机数的对象
 * 		B:创建一个存储随机数的集合。
 * 		C:定义一个统计变量。从0开始。
 * 		D:判断统计遍历是否小于10
 * 			是:先产生一个随机数，判断该随机数在集合中是否存在。
 * 					如果不存在:就添加，统计变量++。
 * 					如果存在:就不搭理它。
 * 			否：不搭理它
 * 		E:遍历集合
 */
public class RandomDemo {
	public static void main(String[] args) {
		// 创建产生随机数的对象
		Random r = new Random();

		// 创建一个存储随机数的集合。
		ArrayList<Integer> array = new ArrayList<Integer>();

		// 定义一个统计变量。从0开始。
		int count = 0;

		// 判断统计遍历是否小于10
		while (count < 10) {
			//先产生一个随机数
			int number = r.nextInt(20) + 1;
			
			//判断该随机数在集合中是否存在。
			if(!array.contains(number)){
				//如果不存在:就添加，统计变量++。
				array.add(number);
				count++;
			}
		}
		
		//遍历集合
		for(Integer i : array){
			System.out.println(i);
		}
	}
}
----------------------------------------------------------------------------------------
                             -----------------例题
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;

/*
 * 键盘录入多个数据，以0结束，要求在控制台输出这多个数据中的最大值
 * 
 * 分析：
 * 		A:创建键盘录入数据对象
 * 		B:键盘录入多个数据,我们不知道多少个，所以用集合存储
 * 		C:以0结束,这个简单，只要键盘录入的数据是0，我就不继续录入数据了
 * 		D:把集合转成数组
 * 		E:对数组排序
 * 		F:获取该数组中的最大索引的值
 */
public class ArrayListDemo {
	public static void main(String[] args) {
		// 创建键盘录入数据对象
		Scanner sc = new Scanner(System.in);

		// 键盘录入多个数据,我们不知道多少个，所以用集合存储
		ArrayList<Integer> array = new ArrayList<Integer>();

		// 以0结束,这个简单，只要键盘录入的数据是0，我就不继续录入数据了
		while (true) {
			System.out.println("请输入数据：");
			int number = sc.nextInt();
			if (number != 0) {
				array.add(number);
			} else {
				break;
			}
		}

		// 把集合转成数组
		// public <T> T[] toArray(T[] a)
		Integer[] i = new Integer[array.size()];
		array.toArray(i);
		// 对数组排序
		// public static void sort(Object[] a)
		Arrays.sort(i);

		// 获取该数组中的最大索引的值
		System.out.println("数组是：" + arrayToString(i) + "最大值是:"
				+ i[i.length - 1]);
	}

	public static String arrayToString(Integer[] i) {
		StringBuilder sb = new StringBuilder();

		sb.append("[");
		for (int x = 0; x < i.length; x++) {
			if (x == i.length - 1) {
				sb.append(i[x]);
			} else {
				sb.append(i[x]).append(", ");
			}
		}
		sb.append("]");

		return sb.toString();
	}
}
--------------------------------------------------------------------------------------
                                      set集合
list集合 ：有序，可重复
set集合：无序，唯一   
----------------------HashSet （每次迭代的顺序都有可能变化）
             创建集合：            HashSet<类型> set = new HashSet<类型>（）；
             其余和list集合一样 

---------注意：    当set对象是一个类，而不是普通int等类型，需要在类中重写哈希值和equals方法，ALT+ SHIFT+S （自动生成） 。否则会出现重复元素



----------------------LinkedHashSet集合：  元素顺序迭代不变，怎么存储怎么遍历
                               LinkedHashSet<> ** = new LinkedHashSet<>(); 

----------------------TreeSet集合： 根据自然排序或者 比较器排序
                        TreeSet<>  * = new TreeSet<>();
                如果存储元素是int类型，默认采用自然排序，但是当元素类型为引用类
                 则需要在类里导入接口----implements Comparable<类名（类型）>
                然后在末尾重写方法   （返回值<0从大到小，=0只导入第一个元素,>0从小到大）

              ---public int compareTo(student s) {
		// 主要条件 姓名的长度
		int num = this.name.length() - s.name.length();
		// 姓名的长度相同，不代表姓名的内容相同
		int num2 = num == 0 ? this.name.compareTo(s.name) : num;
		// 姓名的长度和内容相同，不代表年龄相同，所以还得继续判断年龄
		int num3 = num2 == 0 ? this.age - s.age : num2;
		return num3;
	}