黑马程序员_集合框架

----------- [url=http://www.itheima.com][color=red]android培训[/color][/url]、[url=http://www.itheima.com][color=red]java培训[/color][/url]、java学习型技术博客、期待与您交流！ ------------

[b]数组与集合[/b]
对象存储数据，而容器（数组，集合）可以用来存储对象。
数组：
1。长度不可变
2.元素类型单一
容器：
1.长度可变
2.元素类型不一定是单一的

[b]集合框架体系中常用集合[/b]
Collection集合
Collection
|--List:元素是有序的，元素可以重复，因为元素有索引。
|--ArrayList
|--LinkedList
|--Vector
|--Set：元素是无序的，元素不可以重复。
|--HashSet
|--TreeSet
Map集合
Map
|--HashMap
|--Hashtable
|--TreeMap
[b]具体增删改查方法可查阅API[/b]

[b]比较ArrayList，Vector和LinkedList[/b]
ArrayList和Vector都是使用数组方式存储数据，此数组元素数大于实际存储的数据以便增加和插入元素，它们都允许直接按序号索引元素，但是插入元素要涉及数组元素移动等内存操作，所以索引数据快而插入数据慢，Vector由于使用了synchronized方法（线程安全），通常性能上较ArrayList差。
而LinkedList使用双向链表实现存储，按序号索引数据需要进行前向或后向遍历，但是插入数据时只需要记录本项的前后项即可，所以插入速度较快。

[b]HashMap和Hashtable的区别[/b]
HashMap是Hashtable的轻量级实现（非线程安全的实现），他们都完成了Map接口，主要区别在于HashMap允许空（null）键值（key）,由于非线程安全，效率上可能高于Hashtable。
HashMap允许将null作为一个entry的key或者value，而Hashtable不允许。
建议使用HashMap集合，因为它的效率高，在需要同步时可以使用工具类Collections的静态方法进行同步处理

[b]Collection和Map集合的元素取出方式[/b]
Collection集合使用迭代器取出元素，Map集合没有迭代器，所以要先转换为keySet或Map.Entry的Set集合在获取键值。

演示Collection集合取出元素

package cn.itcast.javabase;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
/**
演示Collection集合的元素取出
*/
public class CollectionDemo
{
	public static void main(String[] args)
	{
		//创建Collection集合
		Collection<String> coll = new ArrayList<String>();
		//向集合中添加元素
		for(int i=0;i<5;i++)
		{
			coll.add("object"+i);
		}
		//打印集合
		System.out.println(coll);
		//通过迭代器取出Collection集合中的元素
		System.out.println("集合中的元素有：");
		Iterator<String> it = coll.iterator();
		while(it.hasNext())
		{
			String obj = it.next();
			System.out.println(obj);
		}
	}
}

演示Map集合取出元素

package cn.itcast.javabase;
import java.util.Map;
import java.util.HashMap;
import java.util.Set;
import java.util.Iterator;
class MapDemo 
{
	public static void main(String[] args) 
	{
		//创建Map集合
		Map<String,Integer> map = new HashMap<String,Integer>();
		//向Map集合中添加元素
		for(int i=0;i<5;i++)
		{
			map.put("object"+i,i);
		}
		//打印map集合
		System.out.println(map);

		/*
		获取keySet，用迭代器获取key和value
		*/
		Set<String> keySet = map.keySet();	
		Iterator<String> keyInter = keySet.iterator();
		System.out.println("通过keySet获取key和value:");
		while(keyInter.hasNext())
		{
			String key = keyInter.next();
			System.out.println("key="+key+" value="+map.get(key));
		}
		/*
		获取entrySet，通过迭代器获取key和value
		*/
		Set<Map.Entry<String,Integer>> entrySet = map.entrySet();
		Iterator<Map.Entry<String,Integer>> entryIter = entrySet.iterator();
		System.out.println("通过Map.Entry获取key和value:");
		while(entryIter.hasNext())
		{
			Map.Entry<String,Integer> entry =entryIter.next();
			System.out.println("key="+entry.getKey()+" value="+entry.getValue());
		}

	}
}

[b]哈希表数据结构[/b]
对于判断集合中是否有相同元素，需要遍历整个集合，这样效率很慢，有人发明了一种方法，将集合分为若干个存储区域，每个对象可以算出一个哈希码，将哈希码进行分组，每组对于某个存储区域，根据一个对象的哈希码就可以确定该对象应该存储在那个区域，这样极大的提高了效率，这就是哈希表结构。
如果两个元素hashCode相同说明他们在同一个区域中，然后在判断是否为同一个对象。


[b]哈希表结构集合如何保证元素唯一性[/b]
是通过元素的两个方法hashCode和equals来完成的。
如果元素的hashCode相同，才会判断equals是否相同。
如果元素的hashCode不同，不会调用equals。
对于元素是否存在，以及删除等操作，依赖的方法是元素的hashCode和equals方法。

package cn.itcast.javabase;
import java.util.*;
/**
演示哈希表结构存储元素，判断元素唯一性的依据是元素的hashCode和equals方法。
*/
class Student 
{
	private String name;
	private int age;
	Student(String name,int age)
	{
		this.name = name;
		this.age = age;
	}
	//重写hashCode方法
	public int hashCode()
	{
		return name.hashCode()+age*39;
	}
	//重写equals方法
	public boolean equals(Object obj)
	{
		if(!(obj instanceof Student))
			throw new RuntimeException("不是学生对象");
		Student stu = (Student)obj;
		return this.name.equals(stu.name)&&this.age==stu.age;
	}

	public String getName()
	{
		return name;
	}

	public int getAge()
	{
		return age;
	}
}
public class HashSetDemo
{
	public static void main(String[] args)
	{
		/*
		创建一个HashSet集合，添加四个元素
		*/
		HashSet<Student> hashSet = new HashSet<Student>();
		hashSet.add(new Student("stu01",19));
		hashSet.add(new Student("stu02",20));
		hashSet.add(new Student("stu03",19));
		hashSet.add(new Student("stu01",19));//与第一个元素name和age相同不会存储

		/*
		用迭代器遍历集合，查看元素存储状态
		*/
		Iterator<Student> setIter = hashSet.iterator();
		while(setIter.hasNext())
		{
			Student stu = setIter.next();
			System.out.println(stu.getName()+"..."+stu.getAge());
		}

	}
}

[b]二叉树结构集合的排序[/b]
1.让元素自身具备比较性，元素所属的类实现Comparable接口。
2.让集合具备比较性，使用比较器作为参数传递给构造函数。

package cn.itcast.javabase;
import java.util.*;
/**
演示一：让元素自身具备比较性，实现Comparable接口
*/
class Student implements Comparable<Student>
{
	private String name;
	private int age;
	Student(String name,int age)
	{
		this.name = name;
		this.age = age;
	}
	//实现compareTo方法
	public int compareTo(Student stu)
	{
		int num = new Integer(this.age).compareTo(new Integer(stu.age));
		if(num==0)
			return this.name.compareTo(stu.name);
		return num;
	}
	/*
	name和age的set、get方法
	*/
	public String getName()
	{
		return name;
	}

	public int getAge()
	{
		return age;
	}

}
public class ComparableDemo
{
	public static void main(String[] args)
	{
		TreeSet<Student> treeSet = new TreeSet<Student>();
		treeSet.add(new Student("stu01",19));
		treeSet.add(new Student("stu02",20));
		treeSet.add(new Student("stu03",21));
		treeSet.add(new Student("stu04",19));
		treeSet.add(new Student("stu05",20));

		Iterator<Student> setIter = treeSet.iterator();
		while(setIter.hasNext())
		{
			Student stu = setIter.next();
			System.out.println(stu.getName()+"..."+stu.getAge());
		}

	}
}

package cn.itcast.javabase;
import java.util.*;
/**
演示一：让集合具备比较性。
当元素和集合都具备比较性时，以传递给集合的比较器为主
*/
class MyComparator implements Comparator<Student>
{
	//实现compare方法
	public int compare(Student s1,Student s2)
	{
		int num = s1.getName().compareTo(s2.getName());
		if(num==0)
			return new Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));

		return num;
	}
}
class Student implements Comparable<Student>
{
	private String name;
	private int age;
	Student(String name,int age)
	{
		this.name = name;
		this.age = age;
	}
	//实现compareTo方法
	public int compareTo(Student stu)
	{
		int num = new Integer(this.age).compareTo(new Integer(stu.age));
		if(num==0)
			return this.name.compareTo(stu.name);
		return num;
	}
	/*
	name和age的set、get方法
	*/
	public String getName()
	{
		return name;
	}

	public int getAge()
	{
		return age;
	}

}
public class ComparatorDemo
{
	public static void main(String[] args)
	{
		TreeSet<Student> treeSet = new TreeSet<Student>(new MyComparator());
		treeSet.add(new Student("stu01",19));
		treeSet.add(new Student("stu02",20));
		treeSet.add(new Student("stu03",21));
		treeSet.add(new Student("stu04",19));
		treeSet.add(new Student("stu05",20));
		treeSet.add(new Student("stu01",20));

		Iterator<Student> setIter = treeSet.iterator();
		while(setIter.hasNext())
		{
			Student stu = setIter.next();
			System.out.println(stu.getName()+"..."+stu.getAge());
		}

	}
}

[b]集合框架工具类Collections[/b]
常见操作：
1.排序
static <T> void sort(list<T> list,Comparator<? super T> c):
根据元素的自然顺序 对指定列表按升序进行排序。
static <T extends Comparable<? super T>> void sort(List<T> list)：
根据指定比较器产生的顺序对指定列表进行排序。
2.查找
static <T extends Object&&Comparable<? super T>> max(Collection<? extends T> coll):
根据元素的自然顺序，返回给定 collection 的最大元素。
static <T> T max(Collection<? extends T> coll, Comparator<? super T> comp) :
根据指定比较器产生的顺序，返回给定 collection 的最大元素。
static <T extends Object&&Comparable<? super T>> min(Collection<? extends T> coll):
根据元素的自然顺序 返回给定 collection 的最小元素。
static <T> T min(Collection<? extends T> coll, Comparator<? super T> comp) :
根据指定比较器产生的顺序，返回给定 collection 的最小元素。
static <T> int binarySearch(List<? extends Comparable<? super T>> list, T key) ：
使用二分搜索法搜索指定列表，以获得指定对象。
static <T> int binarySearch(List<? extends T> list, T key, Comparator<? super T> c) ：
使用二分搜索法搜索指定列表，以获得指定对象。
3.替换
static <T> void fill(List<? super T> list, T obj) ：
使用指定元素替换指定列表中的所有元素。
static <T> void fill(List<? super T> list, T obj) :
使用指定元素替换指定列表中的所有元素。
static <T> boolean replaceAll(List<T> list, T oldVal, T newVal)：
使用另一个值替换列表中出现的所有某一指定值。
static void swap(List<?> list, int i, int j) :
在指定列表的指定位置处交换元素。

4.反转
static void reverse(List<?> list) ：
反转指定列表中元素的顺序。
static <T> Comparator<T> reverseOrder() ：
返回一个比较器，它强行逆转实现了 Comparable 接口的对象 collection 的自然顺序。
static <T> Comparator<T> reverseOrder(Comparator<T> cmp) ：
返回一个比较器，它强行逆转指定比较器的顺序。

5.随即置换
static void shuffle(List<?> list) ：
使用默认随机源对指定列表进行置换。
static void shuffle(List<?> list, Random rnd) ：
使用指定的随机源对指定列表进行置换。
6.集合同步：
static <T> Collection<T> synchronizedCollection(Collection<T> c) ：
返回指定 collection 支持的同步（线程安全的）collection。
static <T> List<T> synchronizedList(List<T> list) ：
返回指定列表支持的同步（线程安全的）列表。
static <K,V> Map<K,V> synchronizedMap(Map<K,V> m) :
返回由指定映射支持的同步（线程安全的）映射。
static <T> Set<T> synchronizedSet(Set<T> s):
返回指定 set 支持的同步（线程安全的）set。
static <K,V> SortedMap<K,V> synchronizedSortedMap(SortedMap<K,V> m) :
返回指定有序映射支持的同步（线程安全的）有序映射。
static <T> SortedSet<T> synchronizedSortedSet(SortedSet<T> s) :
返回指定有序 set 支持的同步（线程安全的）有序 set。
----------- [url=http://www.itheima.com][color=red]android培训[/color][/url]、[url=http://www.itheima.com][color=red]java培训[/color][/url]、java学习型技术博客、期待与您交流！ ------------