2020-12-19迭代器/compara自定义排序/Set集合接口/HashSet/TreeSet/LinkedHashSet/Map集合接口/HashMap/Hashtable/TreeMap

Vector中的迭代器

Iterator iterator()

		Vector depVector = dao.loadDepartments();
		if(depVector!=null//没有实例化
				&& !depVector.isEmpty()//数据为空
				) {//如果集合有数据
			
		
		Iterator iterator = depVector.iterator();
		//使用迭代器变量集合元素
		while(iterator.hasNext()) {
			Department dep = (Department)iterator.next();
			System.out.println(dep.getId()+"\t"+dep.getName());

重写comparator接口的compare方法来实现集合数据的排序

		Vector depVector = dao.loadDepartments();
		class ComparatorImp implements Comparator{

			@Override
			public int compare(Object o1, Object o2) {
				Department dep0 = (Department)o1;
				Department dep2 = (Department)o2;
				
				if (dep0.getCreateDate().getTime()>dep2.getCreateDate().getTime()) {
					return -1;
					
				}else if(dep0.getCreateDate().getTime()<dep2.getCreateDate().getTime())
					return 1;
				
				return 0;
			}
			
		}
		depVector.sort(new ComparatorImp());
		System.out.println("部门ID\t\t部门名称\t\t成立日期");
		
		for (int j = 0; j < depVector.size(); j++) {
			Department depRes = (Department)depVector.get(j);
			System.out.println(depRes.getId()+"\t\t"+
			depRes.getName()+"\t\t"+new SimpleDateFormat("yyyy-MM-dd").format(depRes.getCreateDate()));
		}

Set集合接口规范概述

Set接口继承自——Collection——Iterable
Iterable接口循环迭代方式访问集合中的数据元素，定义了唯一一个返回指向集合的Iterator迭代器。它主要通过foreach方式处理集合中的元素，任何其实现类都可以通过获取指向集合的迭代实现对集合的遍历。
Set接口只能存储不相等的对象，Set接口时数学Set的抽象描述，与ArrayList不同，它其中元素不带任何索引，不能使用索引方式访问集合中的元素。
Set接口通常追加，遍历元素比较慢，随机删除修改数据速度稍快。

Set集合方法规范

boolean add(Object e)
//随机添加数据
void clear()
boolean contains(Object o)
Iteratoriterator()
boolean remove(Object o)
int size()
boolean isEmpty()
Object[] toArray()

HashSet集合实现类

此类实现Set接口，有哈希表（实际上是一个HashMap实例）支持实现算法.HashSet不能保证Set集合元素的迭代顺序，也不能保证该顺序恒久不变。HashMap允许使用null元素。
HashSet实现不是线程同步的。如果在多个线程同时访问一个HashSet，应该做必要额外同步处理，HashSet由于不排序，通常执行效率比较高。

	/**
	 * 获取所有员工信息
	 */
	@Override
	public Set loadEmployee() {
		// TODO Auto-generated method stub
		return DateBase.getEmployeeTable();//返回员工集合Set对象
	}

使用Set接口的迭代器实现迭代

		DateBase.initEmployeeTable();
		Set empSet = empDao.loadEmployee();
		//获取Set接口的迭代器实现对集合元素的遍历
		Iterator iterator = empSet.iterator();
		System.out.println("Id\t\t"+"name"+"\t\t"+"mobilePhone"+"\t\t"+"depid");
		
		while (iterator.hasNext()) {//如果有下一个数
			Employee emp = (Employee)iterator.next();//迭代器要强制转换类型
			System.out.println(emp.getId()+"\t\t"+emp.getName()+"\t\t"+emp.getMobilePhone()+"\t\t"+new SimpleDateFormat("yyyy-MM-dd").format(emp.getBirth())+"\t\t"+emp.getDepId());

HashSet重载构造器

Set set = new HashSet(int a，int b )//a为初始容量a>=0,b为加载因子(扩展集合时按b扩展)b>0
Set集合接口不能存储相同的数据

	int capicaty = 5;
		Set set = new HashSet(capicaty);
		String name = "king";
		String name2 = "king";
		set.add(name);set.add(name2);set.add(null);
		System.out.println(set.size());
		System.out.println(name.equals(name2));
		for (Object e : set) {
			System.out.println(e);

TreeSet集合实现类

TreeSet是基于TreeMap的NavigableSet实现并实现SortenSet排序接口。默认按照元素的自然顺序（升序）对元素进行排序，或者根据创建set时提供的Commparetor进行排序。
TreeSet不是线程同步的。如果在多个线程同时访问一个TreeSet，必须做同步处理。
TreeSet由于需要进行排序，因此TreeSet比HashSet效率要低。

TreeSet集合常用方法

public TreeSet(Comparatorcomparator)
public IteratordescendingIterator()
//降序排序迭代器
public E last()
public E first()
TreeSet默认排序，descendingIterator反向迭代器

	TreeSet tree = new TreeSet();//用TreeSet的默认升序对元素进行排序
		tree.add(Integer.valueOf(34));
		tree.add(Integer.valueOf(20));
		tree.add(Integer.valueOf(30));
		tree.add(Integer.valueOf(40));
		tree.add(Integer.valueOf(50));
		
		for (Object e : tree) {
			System.out.println(e);
		}
		System.out.println("-------------");
		
		Iterator it = tree.descendingIterator();//获取迭代器（反向迭代集合中元素）
		while(it.hasNext()) {
			System.out.println(it.next());
		}
		//去除第一个和最后有一个元素方法
		System.out.println("--------------");
		System.out.println(tree.first());
		System.out.println(tree.last());

TreeSet自定义排序应用

		TreeSet resSet =  new TreeSet(new Comparator() {

			@Override
			public int compare(Object o1, Object o2) {
				Employee emp0 = (Employee)o1;
				Employee emp1 = (Employee)o2;
				if (emp0.getBirth().getTime()>emp1.getBirth().getTime()) {
					return -1;
				}else if(emp0.getBirth().getTime()<emp1.getBirth().getTime()) {
					return 1;
				}
				
				return 0;
			}
			
		});
		Set tempSet = DateBase.getEmployeeTable();
		for (Object o : tempSet) {
			resSet.add(o);//添加到新的TreeSet集合中
		}
		return resSet;

	DateBase.initEmployeeTable();
		TreeSet resSet = empDao.loadEmployeeSort();
		
		for (Object o : resSet) {
			Employee emp = (Employee)o;
			System.out.println(emp.getId()+"\t"+emp.getName()+"\t"+new SimpleDateFormat("yyyy-MM-dd").format(emp.getBirth()));

LinkedHashSet集合实现类

基于哈希表和链接列表的Set接口的实现类，与HashSet无序集合相比，LinkedHashSet的迭代是一个可以被预知的访问操作，它以添加到集合中的顺序为迭代最终顺序。
由于LinkedHashSet需要维护元素顺序，因此效率比HashSet要稍低些。
在需要保证使用Set接口并按照存储顺序迭代时使用它。
LinkedHashSet按输入顺序迭代

		LinkedHashSet set = new LinkedHashSet();
		set.add(new Integer(250));
		set.add(new Integer(260));
		set.add(new Integer(911));
		set.add(new Integer(120));
		for (Object e : set) {
			System.out.println(e);

Map集合接口规范概述

Map接口是存储键值对像的顶级集合接口。存储在Map集合中的键值对象必须确保每个键是不重复的；对于相同的键对象在添加到Map中时会产生覆盖源键值对象操作。
在通常情况下Map通过一个唯一的键查找其对应的值对象，键和值必须同时成对出现，一个键对应一个值对象。
在很多情况下可以使用Map对象替代（如果需要）实体对象，这样可以在应用程序实体类比较多的情况下减少类的定义。

Map集合接口常用方法

Object put(Object key,Object value)
Object get(Object key)
boolean containsKey(Object key)
boolean containsValue(Object value)
int size()
SetkeySet()
Collectionvalues()
boolean isEmpty()
V remove(Object key)
void clear()

HashMap集合实现类

HashMap是继承自AbstractMap间接实现Map接口的基本哈希表算法的Map接口的实现类。此实现提供所有可选的映射操作，允许使用null值和null键。HashMap不保证映射的顺序，特别是它不保证该顺序恒久不变。
HashMap不是线程安全的，如果在多线程中使用必须在程序中处理同步问题。

HashMap构造器

public HashMap()
构造一个具有默认初始容量（16）和默认加载因子（0.75）的空HashMap

public HashMap(int initSize)
构造一个指定初始容量和默认加载因子的空HashMap

public HadaMap(int initSize,float loadFactor)
构造一个带指定初始容量和加载因子的空HashMap

使用键值对集合映射角色对象以减少系统应用中的类定义

Map接口中的put方法

public static void initRoles() {//initRoles方法用来创建2个Map类型的实例存储到roleMaps变量中
		
		Map roleMap0 = new HashMap();//创建系统角色
		roleMap0.put("id", new Integer(1001));
		roleMap0.put("roleName", "普通");
		roleMap0.put("status",new Integer(0));
		roleMap0.put("Describe", "普通系统用户");
		roleMaps.add(roleMap0);
		
		Map roleMap1 = new HashMap();//创建系统角色
		roleMap1.put("id", new Integer(1002));
		roleMap1.put("roleName", "普管");
		roleMap1.put("status",new Integer(0));
		roleMap1.put("Describe", "普通系统管理员用户");
		roleMaps.add(roleMap1);
	}

	public List loadList() {
		
		return DateBase.getRoleMaps();//从数据库中获取所有权限信息
	}

获取并显示所有系统中角色信息

Map接口中的get方法

		DateBase.initRoles();
		List roles = roleDao.loadList();
		System.out.println("权限ID\t权限名称\t权限描述");
		for (int i = 0; i < roles.size(); i++) {
			Map roleMap = (Map)roles.get(i);//获取每个Map对象
			
			Integer statusInt = (Integer)roleMap.get("status");
			System.out.println(roleMap.get("id")+"\t"+
			roleMap.get("roleName")+"\t"+
			(statusInt==0?"启用":"禁用")+"\t\t"+
			roleMap .get("Describe"));
		}

添加新角色到角色表中

	public boolean addRole(Map roleMap) {
		List roleList = DateBase.getRoleMaps();
		return roleList.add(roleMap);
	}

		Scanner scan = new Scanner(System.in);
		DateBase.initRoles();
		System.out.println("添加新角色请输入信息");
		System.out.println("请输入权限id");
		Integer id = new Integer(scan.nextInt());
		System.out.println("请输入权限名称");
		String name = scan.next();
		System.out.println("请输入权限说明");
		String descs = scan.next();
		
		Map newRole = new HashMap();
		newRole.put("id", id);
		newRole.put("roleName", name);
		newRole.put("status", new Integer(0));
		newRole.put("Describe", descs);
		
		roleDao.addRole(newRole);//添加新权限
		System.out.println("权限ID\t权限名称\t权限描述\t\t用户类型");
		List roles = roleDao.loadList();
		for (int i = 0; i < roles.size(); i++) {
			Map roleMap = (Map)roles.get(i);//获取每个Map对象	
		Integer statusInt = (Integer)roleMap.get("status");
		System.out.println(roleMap.get("id")+"\t"+
		roleMap.get("roleName")+"\t"+
		(statusInt==0?"启用":"禁用")+"\t\t"+
		roleMap .get("Describe"));
		}

对给定唯一标识的角色进行禁用修改

	public void disableRoleById(Integer roleId) {
		List roleList = DateBase.getRoleMaps();
		for (int i = 0; i < roleList.size(); i++) {
			Map temMap = (Map)roleList.get(i);//获取当前Map
			if (((Integer)temMap.get("id")).intValue() == roleId.intValue()) {
				temMap.put("status", 1);//设置当前权限被禁用
				break;
			}
		}
		
	}

		System.out.println("请输入被禁用的权限id");
		Integer id0 = new Integer(scan.nextInt());
		
		roleDao.disableRoleById(id0);

获取键、值、键值对集合

		Map map = new HashMap();
		map.put("a",new Long(1000));
		map.put(Integer.valueOf(18), "king");
		map.put(new Date(),new Object());
		
		//获取所有键
		Set keys= map.keySet();
		System.out.println(keys);
		//获取所有值
		Collection coll =  map.values();
		System.out.println(coll);
		//获取键值对集合
		Set keyAndValue = map.entrySet();
		System.out.println(keyAndValue);

Hashtable集合实现类

Hashtable类实现一个哈希表，该哈希表将键映射到相应的值。任何给null对象都可以用作键或值。
Hashtable与HashMap功能几乎是相同的，最大区别在于HashMap是非线程同步的，而Hashtable是线程同步的，在多线程中通常使用同步的Hashtable。
由于Hashtable要考虑线程同步问题，因此Hashtable执行效率要比HashMap低。在非多线程中提倡使用HashMap存储键值对象，从而提供性能。
Hashtable的键和值不能存储null；

		Map table = new Hashtable();
		Map hashMap = new HashMap();
		
		//table.put(null, "king");
		//table.put("king", null);
		hashMap.put(null, null);

TreeMap集合实现类

基于红黑树的NavigableMap实现。NavigableMap接口时SortedMap排序Map的子接口。
TreeMap基于树形结构的排序方式实现排序，TreeMap默认以键为依据采用自然顺序进行排序，或者根据创建映射时提供的Comparator进行排序，具体取决于使用的构造方法 由于排序，通常此类比HashMap效率要低。
TreeMap不是线程安全的，在多线程中必须手动处理同步问题。

		TreeMap tree = new TreeMap();//默认采用升序排序
		tree.put("b", "king");
		tree.put("a", "king2");
		tree.put("e", "king3");
		tree.put("x", "king4");
		
		System.out.println(tree);