java基础整理——集合

           首先，集合是存储对象的容器，面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，存储对象，集合是存储对象最常用的一种方式。

集合的出现就是为了持有对象。集合中可以存储任意类型的对象, 而且长度可变。在程序中有可能无法预先知道需要多少个对象, 那么用数组来装对象的话, 长度不好定义, 而集合解决了这样的问题。

      数组也能存储数据，那集合与数组的区别：

数组和集合类都是容器

数组长度是固定的，集合长度是可变的。数组中可以存储基本数据类型，集合只能存储对象数组中存储数据类型是单一的，集合中可以存储任意类型的对象。

集合类的特点

用于存储对象，长度是可变的，可以存储不同类型的对象。

集合分为单列集合 和 双列集合

---|Collection: 单列集合

            ---|List: 有存储顺序, 可重复

                ---|ArrayList:    （底层维护了一个object数组，初始容量为10，不够时增加原来的一半）数组实现, 查找快, 增删慢

                                    由于是数组实现, 在增和删的时候会牵扯到数组增容, 以及拷贝元素. 所以慢。数组是可以直接按索引查找, 所以查找时较快

                ---|LinkedList:   链表实现, 增删快, 查找慢

                                    由于链表实现, 增加时只要让前一个元素记住自己就可以, 删除时让前一个元素记住后一个元素, 后一个元素记住前一个元素. 这样的增删效

                                    率较高但查询时需要一个一个的遍历, 所以效率较低

                ---|Vector:   和ArrayList原理相同, 但线程安全, 效率略低（好像被淘汰了）

                               和ArrayList实现方式相同, 但考虑了线程安全问

题, 所以效率略低

            ---|Set: 无存储顺序, 不可重复

                ---|HashSet（根据哈希表存储，原理是：往HashSet存储元素的时候，首先HasHSet会先调用元素的hashCode方法， 得到元素的哈希码值
                          然后通过哈希码就可以算出该元素在哈希表中的存储位置。如果该位置没有元素，则正常存储，如果已经有元素，则调用该元素的equals（）方法，

                          如果返回为 t rue，则视为重复元素，不再存储，如果返回为false，则也存储在该位置）

                ---|TreeSet（底层是使用了二叉树数据结构实现，可以对元素进行排序），但是它的存储有点复杂啊：

                              1. 如果往TreeSet添加元素的时候，如果元素本身具备自然顺序的特性，那么treeSet就会按照元素自然顺序的特性进行排序存储。
                              2. 如果往TreeSet添加元素的时候， 如果元素本身不具备自然顺序的特性, 那么元素所属的类就必须要实现Comparable接口，

                                  把元素的比较规则定义在compareTo(T o)方法上。
                             3. 在TreeSet中如果比较的方法返回的是0，该元素则被视为重复元素，不允许添加。
                             4. 往TreeSet添加元素的时候，如果元素本身不具备自然顺序的特性，而且元素所属的类没有实现Comparable接口，

                                 那么在创建TreeSet对象 的时候就必须要传入一个比较器对象（Comparator）。

class Emp implements Comparable {

	String name;
	
	int age;
	
	double salary;

	public Emp(String name, int age, double salary) {
		this.name = name;
		this.age = age;
		this.salary = salary;
	}
	
	@Override
	public String toString() {
		return "{ 姓名："+ this.name+" 年龄："+ this.age+ " 薪水："+this.salary+"}";
	}

	/*
	 * 元素与元素之间的比较规则定义在COmparaTo方法上。(non-Javadoc)
	 	返回值：负整数、零或正整数，根据此对象是小于、等于还是大于指定对象。 

	 */
	@Override  //  100.52 - 100.32 = 0.2
	public int compareTo(Object o) {
		Emp e = (Emp)o;
		return (int)((this.salary-e.salary)*100);
	}
}

//自定义一个比较器类
class AgeComparator implements Comparator{

	@Override
	public int compare(Object o1, Object o2) {
		Emp e1 = (Emp)o1;
		Emp e2 = (Emp)o2;
		
		return e1.age - e2.age;
	}
}





public class Demo3 {

	public static void main(String[] args) {
		//创建一个比较器对象
		AgeComparator ageComparator = new AgeComparator();
		
		TreeSet tree = new TreeSet(ageComparator);
		tree.add(new Emp("家宝",68,200));
		tree.add(new Emp("永康",78,100));    
		tree.add(new Emp("习总",58,300));
		tree.add(new Emp("克强",48,500));
		
		System.out.println(tree);
	}
	
}

                ---|LinkedHashSet（看名字就知道也是使用了链表结构了）

单列集合的集合容器都有自己的迭代器

public class Collections {
	public static void main(String[] args) {
		Collection list = new ArrayList();//ArrayList可以换成实现collection·接口的实现类
		Iterator it = list.iterator();
		while(it.hasNext()){
			System.out.println(it.next());
		}		
	}
}

另外，继承list抽象类的集合容器还有特有的迭代器

public class Collections {
	public static void main(String[] args) {
		ArrayList list = new ArrayList();//ArrayList可以换继承list类的集合容器
		ListIterator it = list.listIterator();
		while(it.hasNext()){
			System.out.println(it.next());
		}		
	}
}

---| Map: 键值对（双列集合，以键-值的形式存储（键和值存在映射关系），键是唯一的，值不唯一）

public class Collections {
	public static void main(String[] args) {
		HashMap hm = new HashMap();
		hm.put("张三", "aa");
		hm.put("张三", "bb");
		//键是唯一的，第二个元素会取代第一个元素
		System.out.println(hm);		
	}
}

        ---|HashMap（也是根据哈希表来存储的）

map集合并没有自己的迭代器，只能通过获取collection的迭代器来进行遍历

/*
迭代
	keySet()
	values() 
	entrySet()
 */

public class Demo2 {
	
	public static void main(String[] args) {
		Map<String,String> map = new  HashMap<String, String>();
		map.put("霆锋", "张柏芝");
		map.put("文章", "马伊琍");
		map.put("汪峰", "章子怡");
		map.put("奥巴马", "凤姐");
		
	/*	//遍历方式一： 可以使用keySet方法遍历。   keySet方法返回的集合只是包含了所有的键，没有包含值。
		Set<String> set = map.keySet();  //把map集合中所有key的数据存储到Set集合中返回。  
		Iterator<String> it = set.iterator();   
		while(it.hasNext()){
			String key = it.next();
			System.out.println("键："+ key+" 值："+ map.get(key));
		}
		
		
		//遍历的方式二：可以使用values方法进行遍历。  values方法返回的集合对象只是包含了map中的所有值，没有键的数据。
		Collection<String> list = 	map.values();  // values 把map集合中的所有值存储到一个Collection集合返回。 
		Iterator<String> it= list.iterator();
		while(it.hasNext()){
			String value = it.next();
			System.out.println("值："+ value);
		}
		
		遍历的方式三： 使用 entrySet方式遍历。 推荐使用。
		*/
		
		Set<Map.Entry<String,String>> entrys  = map.entrySet();
		Iterator<Map.Entry<String,String>> it = entrys.iterator();
		while(it.hasNext()){
			Map.Entry<String,String> entry = it.next();
			System.out.println("键： "+ entry.getKey()+ " 值：" + entry.getValue());
		}

	}

}

        ---|TreeMap

        ---|HashTable

        ---|LinkedHashMap

map集合的其它三个可以对应单列集合的，值得一提的是继承了HashTable类的properties类再IO和JDBC中有不小的用处，因为它可以生成加载配置文件