Map两种遍历方式与TreeSet两种排序依据

集合：可以存储不同类型的多个对象，随着存储对象的个数的增加而自动扩大容量

 

体系结构:

Collection<E>

  |----List:存入的对象是有序的，且可以重复

          ArrayList:底层使用的数据结构是数组，线程不安全的，查找速度快，增删速度慢

          Vector:底层使用的数据结构是数组，线程安全的，查找速度快，增删速度慢

          LinkedList:底层使用的数据结构是链表，线程不安全的，查找速度慢，增删速度快

 

  |----Set:存入的对象是无序的，且不可以重复

          HashSet:底层使用的数据结构是哈希表，线程不安全的

                  保证对象唯一的原理：

                  先判断hashCode()值，如果都不同就直接加入集合，如果哈希值相同了

                  在调用equals()方法，如果equals()方法返回值为true,则认为集合中存在该对象，不加入集合

 

           TreeSet:底层使用的数据结构是二叉树，线程不安全的

                  会对存入集合的对象进行排序

                  保证集合中对象唯一的方式：依据compareTo()或compare()的返回值是否为0

                   排序方式一：让存入集合中的对象具备可比较性

                                让存入集合中的对象所属的类实现Comparable<T>接口中的intcompareTo(T t) 方法

                   排序方式二:让集合具备排序功能

                                定义一个比较器，实现Comparator<T>接口中的int compare(T t1,T t2)方法

                                把比较器对象作为参数传递给TreeSet<E>集合的构造方法

 

                   当集合中的对象具备可比较性，且存在比较器时，比较器优先被使用

 

泛型：<引用数据类型>

       把运行时期的问题转移到了编译时期

       不用再强制类型转换

 

     classDemo<T>

     {

          publicvoid show(T t)

          { }

 

          //自己使用泛型的方法

          public<E> void fun(E e)

          {

          }

 

          //静态方法只能自己使用泛型

          publicstatic <W> void func(W w)

          {}

      }

 

    //泛型定义在接口上

    interfaceinter<T>

    { }

 

    通配符：?

    泛型限定：?extends E  和? super E

 

 

Map<K,V>:一个单独的接口，存储的是键值对，键不可以重复,无序的

 

        HashMap:保证键唯一的原理和HashSet一样，hashCode(),equals()

 

        TreeMap:TreeMap是根据键来排序的,保证键唯一的原理和TreeSet相同,依据

               compareTo()或compare()的返回值是否为0，为0就认为是重复键

 

         Map的迭代方式有两种：

         第一种:

                Set<K> keys  =map.keySet();

                Iterator<K> ite = keys.iterator();

                while(ite.hasNext())

                {

                    K key = ite.next();

                   V value = map.get(key);

                   System.out.println(key+","+value);

                }

         第二种:

               Set<Map.Entry<K,V>> entry = map.entrySet();

               Iterator<Map.Entry<K,V>> ite = entry.iterator();

               while(ite.hasNext())

               {

                  Map.Entry<K,V> en = ite.next();

                  K key = en.getKey();

                  V value = en.getValue();

                  System.out.println(key+","+value);

               }

 

 

工具类：Arrays

       Collections

举例说明：

/*
Collection
    List:存储的对象是有序的(取出的顺序和存储的顺序是一致的)，对象是可以重复的
 --ArrayList:底层使用的数据结构是数组,查找速度快，增删速度慢 线程不同步的
 --LinkedList：底层使用的数据结构是链表，查找速度慢，增删速度快  线程不同步的
 --Vector:底层使用的数据结构是数组，线程同步的


Set:存储的对象是无序的(取出的顺序和存储的顺序是不一致的)，对象不可以重复 
*/

import java.util.*;
class  Demo1
{
	public static void main(String[] args) 
	{
		ArrayList  list = new ArrayList();


		list.add("java01");
		list.add("java02");
		list.add("java03");
		list.add("java03");
		list.add("java02");
		Iterator ite = list.iterator();
		while(ite.hasNext())
		{
			sop(ite.next());
		}


		ArrayList list2 = quChu(list);
		sop(list2);
	}
	//去除集合中的重复元素
	public static ArrayList quChu(ArrayList list)
	{
		ArrayList list2 = new ArrayList();
		for(int i=0;i<list.size();i++)
		{
			Object obj = list.get(i);
			if(!list2.contains(obj))//依据什么来判断是否包含这个对象？boolean equals(Object obj)
			{
			   list2.add(obj);
			}
		}
		return list2;
	}






	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

    /*TreeSet:保证集合中对象唯一的方式：依据compareTo()或compare()的返回值是否为0

                   排序方式一：让存入集合中的对象具备可比较性

                                让存入集合中的对象所属的类实现Comparable<T>接口中的intcompareTo(T t) 方法

                   排序方式二:让集合具备排序功能

                                定义一个比较器，实现Comparator<T>接口中的int compare(T t1,T t2)方法

                                把比较器对象作为参数传递给TreeSet<E>集合的构造方法

 

                   当集合中的对象具备可比较性，且存在比较器时，比较器优先被使用*/

举例说明：

package com.demo.day07;

import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;
public class Demo8 {
	public static void main(String[] arg)
	{
		ComparaByName comparaByName=new ComparaByName();
		TreeSet ts=new TreeSet(comparaByName);
//		ts.add("sa");
//		ts.add("assa");
//		ts.add("esa");
//		ts.add("fsa");
		ts.add(new People("zs",22));
		ts.add(new People("ls",28));
		ts.add(new People("wm",22));
		ts.add(new People("tt",23));
		Iterator ite=ts.iterator();
		while(ite.hasNext())
		{
			sop(ite.next());
		}
	}
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}
@SuppressWarnings("rawtypes")
class ComparaByName implements Comparator//<span style="font-weight: bold;">排序方式二</span>
{

	@Override
	public int compare(Object arg0, Object arg1) {
		if(!(arg0 instanceof People))
			throw new ClassCastException("类型不对");
		if(!(arg1 instanceof People))
			throw new ClassCastException("类型不对");
		People per1=(People)arg0;
		People per2=(People)arg1;
		int num=per1.getName().compareTo(per2.getName());
		return num==0?per1.getAge()-per2.getAge():num;
	}
	
}
class People implements Comparable//<span style="font-weight: bold;">排序方式一</span>
{
	private String name;
	private int age;
	
	@Override
	public int compareTo(Object obj) {
		if(!(obj instanceof People))
			throw new ClassCastException("类型不对");
		People per=(People)obj;
		int num=this.age-per.age;
		return num==0?this.name.compareTo(per.name):num;
	}
	public People() {
		super();
		// TODO Auto-generated constructor stub
	}


	public People(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}


	@Override
	public String toString() {
		return "People [name=" + name + ", age=" + age + "]";
	}


	public String getName() {
		return name;
	}


	public void setName(String name) {
		this.name = name;
	}


	public int getAge() {
		return age;
	}


	public void setAge(int age) {
		this.age = age;
	}
	
}