java 集合简单学习Demo

package com.amaker.file;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeSet;

public class Collection {

	/**
	 * 集合学习Demo
	 */
	public static void main(String[] args) {
		//
	}
	/**
	 * 类集：类集就是一系列的动态对象数组。
	 * 类集中最大的几个操作接口：Collection、Map、Iterator
	 * 所有的类集操作的接口或类都在java.util包中。
	 * List接口:ArrayList（95%）、Vector（4%）、LinkedList（1%）
	 * Vector类和ArrayList类的区别:
	 * No.	区别点	              ArrayList	              Vector
	 * 1	时间	    是新的类，是在JDK 1.2之后推出的	是旧的类是在JDK 1.0的时候就定义的
	 * 2	性能     性能较高，是采用了异步处理	           性能较低，是采用了同步处理
	 * 3           输出	    支持Iterator、ListIterator输出	除了支持Iterator、ListIterator输出，还支持Enumeration输出
	 * 
	 */
	public void demo1(){
		List<String> all = new ArrayList<String>(); // 实例化List对象，并指定泛型类型
		all.add("hello "); // 增加内容，此方法从Collection接口继承而来
		all.add(0, "VINCE ");// 增加内容，此方法是List接口单独定义的
		all.add("world"); // 增加内容，此方法从Collection接口继承而来
		System.out.println(all); // 打印all对象调用toString()方法

	}
	/**
	 * Set接口:
	 * Set接口也是Collection的子接口，与List接口最大的不同在于，Set接口里面的内容是不允许重复的
	 * 此接口中有两个常用的子类：HashSet、TreeSet
	 * HashSet属于散列的存放类集，里面的内容是无序存放的
	 * 使用HashSet实例化的Set接口实例，本身属于无序的存放。
	 */
	public void demo2(){
		Set<String> all = new HashSet<String>(); // 实例化Set接口对象
		all.add("A");
		all.add("B");
		all.add("C");
		all.add("D");
		all.add("E");
		System.out.println(all);

	}
	public void demo3(){
		Set<String> all = new HashSet<String>(); // 实例化Set接口对象
		all.add("A");
		all.add("B");
		all.add("C");
		all.add("D");
		all.add("E");
		String[] str = all.toArray(new String[] {});// 变为指定的泛型类型数组
		for (int x = 0; x < str.length; x++) {
			System.out.print(str[x] + "、");
		}

	}
	/**
	 * 排序的子类：TreeSet:
	 * 与HashSet不同的是，TreeSet本身属于排序的子类
	 */
	public void demo4(){
		Set<String> all = new TreeSet<String>(); // 实例化Set接口对象\
		all.add("D");
		all.add("X");
		all.add("A");
		System.out.println(all);

	}
	/**
	 * 判断两个对象是否相等:
	 * 第一种判断两个对象的编码是否一致，这个方法需要通过hashCode()完成，即：每个对象有唯一的编码
	 * 还需要进一步验证对象中的每个属性是否相等，需要通过equals()完成。
	 * 关于TreeSet的排序实现，如果是集合中对象是自定义的或者说其他系统定义的类没有实现
	 * Comparable接口，则不能实现TreeSet的排序，会报类型转换（转向Comparable接口）错误。
	 * 换句话说要添加到TreeSet集合中的对象的类型必须实现了Comparable接口.
	 */

	/**
	 * 集合输出:
	 * 只要是碰到了集合，则输出的时候想都不想就使用Iterator进行输出。
	 * Iterator
	 */
	public void demo5(){
		List<String> all = new ArrayList<String>();
		all.add("A");
		all.add("B");
		all.add("C");
		all.add("D");
		all.add("E");
		Iterator<String> iter = all.iterator();
		while (iter.hasNext()) {// 判断是否有下一个元素
			String str = iter.next(); // 取出当前元素
			System.out.print(str + "、");
		}

	}
	/**
	 * Map接口:
	 * Map本身是一个接口，所以一般会使用以下的几个子类：HashMap、TreeMap、Hashtable
	 * Map接口在开发中最基本的操作过程，根据指定的key找到内容，如果没有找到，则返回null，找到了则返回具体的内容。
	 * HashMap本身是属于无序存放的。
	 * Hashtable中是不能向集合中插入null值
	 * HashMap与Hashtable的区别:
	 * No.	区别点	      HashMap	                 Hastable
	 * 1	推出时间	JDK 1.2之后推出的，新的操作类	     JDK 1.0时推出的，旧的操作类
	 * 2	性能	异步处理，性能较高	                                              同步处理，性能较低
	 * 3	null	允许设置为null	                                              不允许设置，否则将出现空指向异常
	 */
	public void demo6(){
		Map<Integer, String> map = new HashMap<Integer, String>();
		map.put(1, "张三A");
		map.put(1, "张三B"); // 新的内容替换掉旧的内容
		map.put(2, "李四");
		map.put(3, "王五");
		String val = map.get(6);
		System.out.println(val);

	}
	public void demo7(){
		Map<Integer, String> map = new HashMap<Integer, String>();
		map.put(1, "张三A");
		map.put(2, "李四");
		map.put(3, "王五");
		Set<Integer> set = map.keySet(); // 得到全部的key
		List<String> value = (List<String>) map.values(); // 得到全部的value
		Iterator<Integer> iter1 = set.iterator();
		Iterator<String> iter2 = value.iterator();
		System.out.print("全部的key：");
		while (iter1.hasNext()) {
			System.out.print(iter1.next() + "、");
		}
		System.out.print("\n全部的value：");
		while (iter2.hasNext()) {
			System.out.print(iter2.next() + "、");
		}
	}

	//Map集合中每一个元素都是Map.Entry的实例，只有通过Map.Entry才能进行key和value的分离操作。
	public void demo8(){
		Map<String, String> map = new HashMap<String, String>();
		map.put("ZS", "张三");
		map.put("LS", "李四");
		map.put("WW", "王五");
		map.put("ZL", "赵六");
		map.put("SQ", "孙七");
		Set<Map.Entry<String, String>> set = map.entrySet();// 变为Set实例
		Iterator<Map.Entry<String, String>> iter = set.iterator();
		while (iter.hasNext()) {
			Map.Entry<String, String> me = iter.next();
			System.out.println(me.getKey() + " --> " + me.getValue());
		}

	}
	//在JDK 1.5之后也可以使用foreach完成同样的输出，只是这样的操作基本上不使用。
	public void demo9(){
		Map<String, String> map = new HashMap<String, String>();
		map.put("ZS", "张三");
		map.put("LS", "李四");
		map.put("WW", "王五");
		map.put("ZL", "赵六");
		map.put("SQ", "孙七");
		for (Map.Entry<String, String> me : map.entrySet()) {
			System.out.println(me.getKey() + " --> " + me.getValue());
		}

	}
	/**
	 * 当一个对象被存进HashSet集合后，就不能修改这个对象中的那些参与计算的哈希值的字段了，否则，对象被修改后的哈
	 * 希值与最初存储进HashSet集合中时的哈希值就不同了，在这种情况下，即使在contains方法使用该对象的当前引用作为
	 * 的参数去HashSet集合中检索对象，也将返回找不到对象的结果，这也会导致无法从HashSet集合中删除当前对象，从而
	 * 造成内存泄露。
	 * 
	 */

	/**
	 * foreach输出
	 */
	public static void demo10(){
		String [] strs = {"a","b","c","d","e"};
		for(String s:strs){
			System.out.print(s+"、");
		}
	}
}