JavaSE_集合框架_3

VectorDemo

package temp;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.Vector;
public class VectorDemo {
	public static void main(String[] args) {
      Vector<String> v=new Vector();
      v.add("女儿悲，青春已大守空闺。");
      v.add("女儿愁，悔教夫婿觅封侯。");
      v.add("女儿喜，对镜晨妆颜色美。");
      v.add("女儿乐，秋千架上春衫薄。");
      Enumeration enumeration=v.elements();//和迭代器功能完全一样,已被取代
      while (enumeration.hasMoreElements()) {
         System.out.println(enumeration.nextElement());
      }
      /*女儿悲，青春已大守空闺。
      女儿愁，悔教夫婿觅封侯。
      女儿喜，对镜晨妆颜色美。
      女儿乐，秋千架上春衫薄。*/
      //下面用迭代器,和上面等效
      Iterator it=v.iterator();
      while (it.hasNext()) {
         System.out.println(it.next());
      }
      /*女儿悲，青春已大守空闺。
      女儿愁，悔教夫婿觅封侯。
      女儿喜，对镜晨妆颜色美。
      女儿乐，秋千架上春衫薄。*/

   }
}

CollectionDemo

package temp;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

import org.junit.Test;
public class CollectionDemo {
   public static void main(String[] args) {
      Collection coll=new ArrayList();
      Collection c1=new ArrayList();
      Collection c2=new ArrayList();
   }
   @Test
   public void Collection4() {
      /* * Iterator迭代器的使用*/
      Collection coll=new ArrayList();
      coll.add("黛玉");
      coll.add("宝钗");
      coll.add("湘云");
      Iterator it=coll.iterator();
      System.out.println(coll);//[黛玉, 宝钗, 湘云]
      //千万注意:while迭代有缺点!
      //变量(即迭代器)循环完毕,未释放,滞留内存! 没有for循环好(for用的是局部变量)
      while (it.hasNext()) {
         System.out.println(it.next());
      }
      /*
      黛玉
      宝钗
      湘云*/
   }
   @Test
   public void Collection3() {
      /* * Iterator迭代器的使用*/
      Collection coll=new ArrayList();
      coll.add("黛玉");
      coll.add("宝钗");
      coll.add("妙玉");
      System.out.println(coll);//[黛玉, 宝钗, 妙玉]
      //千万注意:while迭代时,存在变量(迭代器)滞留内存的问题
      //现在改用for循环(用局部变量~)
      for (Iterator it = coll.iterator(); it.hasNext();) {         
         System.out.println(it.next());
      }
      /*
      黛玉
      宝钗
      妙玉*/
   }
   @Test
   public void test2() {
      /* * Iterator迭代器的使用
       * NoSuchElementException*/
      Collection coll=new ArrayList();
      coll.add("黛玉");
      coll.add("宝钗");
      coll.add("妙玉");
      Iterator it=coll.iterator();
      System.out.println(coll);//[黛玉, 宝钗, 妙玉]
      System.out.println(it.next());//黛玉
      System.out.println(it.next());//宝钗
      System.out.println(it.next());//妙玉
      System.out.println(it.next());//NoSuchElementException
   }
   @Test
   public void Collection2() {
      /*addAll
       * containsAll
       * retainAll */
      Collection c1 =new ArrayList();
      Collection c2 =new ArrayList();
      c1.add("路人1");
      c1.add("路人2");
      c1.add("路人3");
      c1.add("路人4");
      
      c2.add("路人5");
      c2.add("路人6");
      c2.add("路人7");
      c2.add("路人3");
      System.out.println("c1:  "+c1);//[路人1, 路人2, 路人3, 路人4]
      System.out.println("c2:  "+c2);//[路人5, 路人6, 路人7, 路人3]
      //将C2中的元素全部append到C1尾部(重复的也会添加进来~)
      c1.addAll(c2);
      System.out.println("c1:  "+c1);// [路人1, 路人2, 路人3, 路人4, 路人5, 路人6, 路人7, 路人3]
      //再将C1中和C2相同的元素全部拿掉;
      c1.removeAll(c2);
      System.out.println("c1:  "+c1);// [路人1, 路人2, 路人4]
      //布尔: C1是否全部包含了C2的元素
      boolean b1=c1.containsAll(c2);
      System.out.println(b1);//false
      
      c1.add("路人7");
      //c1  里面现在是:[路人1, 路人2, 路人4, 路人7]
      //c2  里面现在是:[路人5, 路人6, 路人7, 路人3]
      //C1只留下和C2里相同的元素!
      boolean b2=c1.retainAll(c2);
      System.out.println("c1:  "+c1);// [路人7]
   }
   /**
    * 集合Collection
    */
   @Test
   public void Collection1() {
      Collection coll=new ArrayList();
      coll.add("路人1");
      coll.add("路人2");
      coll.add("路人3");
      coll.add("路人4");
      System.out.println(coll);//[路人1, 路人2, 路人3, 路人4]
      coll.remove("路人3");
      System.out.println(coll);//[路人1, 路人2, 路人4]
      //清空集合,自己将自己清空~
      coll.removeAll(coll);
      System.out.println(coll);//[]
      coll.add("路人1");
      coll.add("路人2");
      System.out.println(coll.isEmpty());//false
      //另外一种方式:清空集合
      coll.clear();
      System.out.println(coll);//[]
      System.out.println(coll.isEmpty());//是否为空true
      coll.add("路人1");
      coll.add("路人2");
      coll.add("路人3");
      coll.add("路人4");
      System.out.println(coll.contains("路人3"));//是否包含true
      System.out.println(coll.size());//成员个数4
   }
}

ComparatorByName

package temp;
import java.util.Comparator;

import bean.Person;
//比较器,Person是按姓名排序
//即:String的compareTo方法,基于每一个字符的Unicode值
public class ComparatorByName implements Comparator<Person> {
   public int compare(Person p1, Person p2) {
      //String的compareTo方法,基于每一个字符的Unicode值
      //based on the Unicode value of each character in the strings. 
      int temp=p1.getName().compareTo(p2.getName());
      //如果姓名一样,就按年龄排序
      return temp==0?p1.getAge()-p2.getAge():temp;
   }
}

ComparatorByStringLength

package temp;
import java.util.Comparator;
//比较器,按字符串长度进行比较
public class ComparatorByStringLength implements Comparator<String> {
   public int compare(String s1, String s2) {
      int temp=s1.length()-s2.length();
      //如果字符串的长度相同,就按Unicode值排序
      return temp==0?s1.compareTo(s2):temp;
   }
}

HashSetDemo

package temp;
import java.util.HashSet;
import java.util.Iterator;
public class HashSetDemo {
   public static void main(String[] args) {
      method1();
      String s1="ab";
      String s2="ba";
      System.out.println(s1.hashCode());//3105
      System.out.println(s2.hashCode());//3135
   }
   private static void method1() {
      //哈希表保证元素的唯一性!再多的重复元素也进不去!(同时不保证取出有序)
      //哈希表判断元素是否相同,首先用的是对象的hashCode方法;如果相同,再用对象的equals方法
      //判断内容是否相同!注意,如果前面hashCode不相同,就不需要再判断equals
      HashSet hs=new HashSet();
      hs.add("陋室空堂");
      hs.add("当年笏满床");
      hs.add("衰草枯杨");
      hs.add("曾为歌舞场");
      hs.add("好了歌");
      //即使一样,也存不进去~先判hashCode,再判equals
      hs.add("好了歌");
      hs.add("好了歌");
      Iterator it=hs.iterator();
      while (it.hasNext()) {
         System.out.println(it.next());
      }
   }
}

HashSetTest

package temp;
import java.util.HashSet;
import java.util.Iterator;

import org.junit.Test;

import bean.Person;
public class HashSetTest {
   @Test
   public void method1() {
      /*哈希表判断元素是否相同,首先用的是对象的hashCode方法;
      如果相同,再用对象的equals方法,判断内容是否相同!
      注意,如果前面hashCode不相同,就不需要再判断equals
      往HashSet里面存自定义类型Person,
      自己定义~如果name和age相同,则视为同一个人(保证元素唯一)*/
      HashSet hs=new HashSet();
      hs.add(new Person("黛玉",16));
      hs.add(new Person("宝钗",18));
      hs.add(new Person("宝玉",17));
      hs.add(new Person("宝琴",15));
      //下面试试添加一个重复的~
      hs.add(new Person("宝玉",17));
      Iterator it=hs.iterator();
      System.out.println("while循环之前");
      while (it.hasNext()) {
         Person p = (Person) it.next();
         System.out.println(p.getName()+"::"+p.getAge());
      }
      /*...Person覆写的equals方法...宝玉...17
      while循环之前
      宝钗::18
      宝玉::17
      宝琴::15
      黛玉::16*/
//出现了重复,原因是Person用的是Object的hashCode,算的是地址!所以要重写!hashCode!equals!
//      lisi4::24
//      lisi9::29
//      lisi7::27
//      lisi7::27
   }
}

HashMapDemo

package temp;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Set;

import uncommitted.Student;
public class HashMapDemo {
   public static void main(String[] args) {
      HashMap<Student,String> hm=new HashMap<Student,String>();
      method1(hm);
   }
   private static void method1(HashMap<Student,String> map) {
      // 要求:将学生对象<key>和学生归属地<value>存储到Map集合中
      map.put(new Student("宝琴",15), "北京");
      map.put(new Student("宝玉",17), "武汉");
      map.put(new Student("宝钗",18), "香港");
      map.put(new Student("黛玉",16), "台湾");
//      Set<Student> keySet=map.keySet();
//      Iterator<Student> it=keySet.iterator();
      //上面两句可以简化成这一句即可!
      Iterator<Student> it=map.keySet().iterator();
      while (it.hasNext()) {
         //泛型规定了存Student,可以不转型~
         Student key =it.next();
         String address=map.get(key);
         System.out.println(key.getName()+"..."+key.getAge()+"..."+address);
      }
   }
}

LinkedListDemo

package temp;
import java.util.Iterator;
import java.util.LinkedList;

import org.junit.Test;
public class LinkedListDemo {
   @Test
   public void show5() {
      // addFirst加在头部~后来居上,removeFirst返回被移除的首元素,
      //如果移完了还要移:报异常NoSuchElementException!
            LinkedList list=new LinkedList();
            list.addFirst("abc1");
            list.addFirst("abc2");
            list.addFirst("abc3");
            list.addFirst("abc4");
            System.out.println(list);
            //[abc4, abc3, abc2, abc1]
            while (!list.isEmpty()) {
               //直到没有元素才退出循环
               System.out.println(list.removeFirst());//堆栈,先进后出
               //System.out.println(link.removeLast());//队列,先进先出
            }
            System.out.println(list);
            //返回[],因为已经移除干净
   }
   @Test
   public void show4() {
      // addFirst后来居上,removeFirst返回被移除的首元素,
      //如果移光了还移:NoSuchElementException!
      LinkedList list=new LinkedList();
      list.addFirst("abc1");
      list.addFirst("abc2");
      list.addFirst("abc3");
      System.out.println(list);
      //[abc3, abc2, abc1]
      System.out.println(list.removeFirst());
      //abc3,会改变长度;返回被移除的首元素
      System.out.println(list.removeFirst());
      //abc2,会改变长度;返回被移除的首元素
      System.out.println(list);
      //只剩下[abc1]~
   }
   @Test
   public void show3() {
            // addFirst加在最前面,后来居上,
            //getFirst只返回,不会移除元素!
            LinkedList list=new LinkedList();
            list.addFirst("abc1");
            list.addFirst("abc2");
            list.addFirst("abc3");
            System.out.println(list);
            //[abc3, abc2, abc1]
            System.out.println(list.getFirst());//abc3
            System.out.println(list.getFirst());//还是abc3,因为getFirst不会移除元素!
            System.out.println(list.getFirst());//还是abc3,因为getFirst不会移除元素!
            System.out.println(list);
            //不变,仍是[abc3, abc2, abc1]
   }
   @Test
   public void show2() {
      // addFirst添加到集合的头部~后来居上
      LinkedList list=new LinkedList();
      list.addFirst("abc1");
      list.addFirst("abc2");
      list.addFirst("abc3");
      Iterator it=list.iterator();
      while (it.hasNext()) {
         System.out.println(it.next());
      }
      //输出 3  2  1
   }
   @Test
   public void show1() {
      //add会添加到集合的尾部~
      LinkedList list=new LinkedList();
      list.add("abc1");
      list.add("abc2");
      list.add("abc3");
      Iterator it=list.iterator();
      while (it.hasNext()) {
         System.out.println(it.next());
      }
      //输出 1  2  3
   }

}

LinkedListTest

package temp;
import java.util.LinkedList;
//简单模拟实现队列和堆栈数据结构~
class DuiLie{
   //内部维护一个链表~
   private LinkedList list;
   //构造时,即生成链表
   DuiLie() {
      this.list = new LinkedList();
   }
   //队列是先进先出的,其实只用add也可以~
   public void myAdd(Object obj){//注意参数是上帝类型
      list.addLast(obj);
   }
   public Object myGet(){
      return list.removeFirst();//前面是增加到最后,现在是从最前面取出!先进先出,队列!
   }
   public boolean isNull(){
      return list.isEmpty();
   }
}
class DuiZhan{
   //内部维护一个链表~
   private LinkedList list;
   //构造时,即生成链表
   DuiZhan() {
      this.list = new LinkedList();
   }
   public void myAdd(Object obj){//注意参数是Object上帝类型
      list.addLast(obj);
   }
   public Object myGet(){//注意返回参数是Object
      return list.removeLast();//前面是增加到最后,现在是从最前面取出!先进先出,队列!
   }
   public boolean isNull(){
      return list.isEmpty();
   }
}
public class LinkedListTest {
   public static void main(String[] args) {
      //面试题,用LinkedList模拟堆栈()和队列(圆水管)数据结构
      //我们应该设计1个类(容器),类的内部用私有LinkedList,对外仅提供增删2种方法
      //duiLie();
      duiZhan();
   }
   private static void duiZhan() {
      DuiZhan d1=new DuiZhan();
      d1.myAdd("abc1");
      d1.myAdd("abc2");
      d1.myAdd("abc3");
      d1.myAdd("abc4");
      while (!d1.isNull()) {
         System.out.println(d1.myGet());
      }
   }
   public static void duiLie() {
      DuiLie d1=new DuiLie();
      d1.myAdd("abc1");
      d1.myAdd("abc2");
      d1.myAdd("abc3");
      d1.myAdd("abc4");
      while (!d1.isNull()) {
         System.out.println(d1.myGet());
      }
   }
}

LinkedHashSetDemo

package temp;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashSet;
public class LinkedHashSetDemo {
   public static void main(String[] args) {
      //Set唯一,但不保证有序~
      //自从用了LinkedHashSet,怎么存的就怎么取出来!存取有序!
      HashSet hs=new LinkedHashSet();
      hs.add("都道是金玉良姻;俺只念木石前盟;");
      hs.add("空对着;山中高士晶莹雪;");
      hs.add("终不忘;世外仙姝寂寞林;");
      hs.add("叹人间;美中不足今方信;");
      hs.add("纵然是齐眉举案;到底意难平;");
      Iterator it=hs.iterator();
      while (it.hasNext()) {
         System.out.println(it.next());
         //自从用了LinkedHashSet,怎么存的就怎么取出来!存取有序!
      }
      /*都道是金玉良姻;俺只念木石前盟;
      空对着;山中高士晶莹雪;
      终不忘;世外仙姝寂寞林;
      叹人间;美中不足今方信;
      纵然是齐眉举案;到底意难平;*/
   }
}

ListDemo

package temp;
import java.util.ArrayList;
import java.util.List;
public class ListDemo {
   public static void main(String[] args) {
      /* Collection接口的两个弟子之一:接口List集合演示,另1个是Set*/
      List list=new ArrayList();
      listMethod1(list);
   }
   /* 接口List集合方法演示*/
   private static void listMethod1(List list) {
      //因为List是Collection的子接口,所以前面的方法都可以用!
      list.add("abc1");
      list.add("abc2");
      list.add("abc3");
      System.out.println("list:  "+list);// [abc1, abc2, abc3]
      //将元素添加到指定位置~
      list.add(1,"abc9");//在指定下标添加元素
      System.out.println("list:  "+list);// [abc1, abc9, abc2, abc3]
      //下面这句是将指定下标元素删除,
      //注意返回值是被删除的元素
      System.out.println("remove(2):  "+list.remove(2));
      // abc2,返回指定下标处被删除的元素
      System.out.println("删除后的集合:"+list);
      //[abc1, abc9, abc3]
      System.out.println("set(1,'abc-2'): "+list.set(1,"abc-2"));
      //abc9,返回替换之前的该位置上的元素
      System.out.println("替换后的集合:"+list);
      //[abc1, abc-2, abc3]
      //System.out.println(list.get(3));//下标越界IndexOutOfBoundsException
      //List.subList(int fromIndex, int toIndex)
      System.out.println("subList(1,2): "+list.subList(1,2));
      //获取(返回)子列表,从1开始到2-1个元素作为子列表,[abc-2]
   }
}

ListDemo2

package temp;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
public class ListDemo2 {
   public static void main(String[] args) {
      List list=new ArrayList();
      show4(list);      
   }
   private static void show4(List list) {
      //ListIterator迭代器可以从后往前走,老猛!!!
            list.add("abc1");//add方法默认参数是Object,类型提升了
            list.add("abc2");
            list.add("abc3");      
            ListIterator it=list.listIterator();
            while (it.hasNext()) {
               System.out.println(it.next());                              
            }
            //此时指针已经到最后了,接着判断它是前面是否有元素
            while(it.hasPrevious()){
               System.out.println(it.previous());
            }      
   }
   private static void show3(List list) {
      // 用List的listIterator()方法,解决并发修改异常
      // 解决异常ConcurrentModificationException
            list.add("abc1");//add方法默认参数是Object,类型提升了
            list.add("abc2");
            list.add("abc3");         
            //List的listIterator()方法,解决并发修改异常
            ListIterator it=list.listIterator();//解决方法:换个迭代器ListIterator
            while (it.hasNext()) {
               Object obj = (Object) it.next();
               if(obj.equals("abc2")){
                  //在abc2后面紧接着就插入了abc9!!!
                  it.add("abc9");//ListIterator一边迭代一边增删改就OK
//                  it.set("abc9");//ListIterator的set方法:void set(E);用E元素替换next返回的最后一个元素
               }
            }      
            System.out.println(""+list);//[abc1, abc2, abc9, abc3]
            System.out.println(""+it.hasNext());//false
            System.out.println(""+it.hasPrevious());//true
   }
   private static void show2(List list) {
      // 异常ConcurrentModificationException
      list.add("abc1");//add方法默认参数是Object,类型提升了
      list.add("abc2");
      list.add("abc3");
      list.add("abc4");
      //开始使用迭代器操作List元素了,注意(异常)ConcurrentModificationException
      Iterator it=list.iterator();//解决方法:换个迭代器ListIterator
      while (it.hasNext()) {
         Object obj = (Object) it.next();
         if(obj.equals("abc2")){
            list.add("abc9");//这里List也在操作里面的元素,会出现并发操作异常
         }
         else
            System.out.println("迭代器取List元素: "+obj);
      }
      
   }
   public static void show1(List list) {
      list.add("abc1");
      list.add("abc2");
      list.add("abc3");
      list.add("abc4");
      //传统方法:迭代器取List元素
      Iterator it=list.iterator();
      while (it.hasNext()) {
         System.out.println("迭代器取List元素: "+it.next()); 
         
      }
      //List有自己特有的取元素方式:E get(int index)
      //IndexOutOfBoundsException - 如果索引超出范围 (index < 0 || index >= size())
      for (int i = 0; i < list.size(); i++) {
         System.out.println("List特有取元素:E get(int index)"+list.get(i));
      }
   }
}

MapDemo

package temp;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

import org.junit.Test;
public class MapDemo {
   @Test
   public void method4() {
      /* 只获取值的方法:通过Map的values方法: 
       * Collection<V> values() 
       * 返回此映射中包含的值的Collection 视图。
       * 按常规对Coll进行迭代即可~*/
      Map<Integer,String> map=new HashMap<Integer,String>();
      map.put(1, "林黛玉");
      map.put(2, "薛宝钗");
      map.put(4, "贾探春");
      map.put(5, "史湘云");
      map.put(6, "妙玉");
         // map.values()返回值的集合,对集合迭代~
      Collection<String> coll=map.values();
      Iterator it=coll.iterator();
      while (it.hasNext()) {
         String value=(String)it.next();
         System.out.println(value);
      }
   }
   @Test
   public void method3() {
      /*另1种方法:通过Map的entrySet方法:
      Set<Map.Entry<K,V>> entrySet()方法 
    返回此映射中包含的映射关系(即键值对)的Set 视图.
    再通过Set视图可以拿到迭代器
      映射关系的类型是:Map.Entry<K,V>*/
      Map<Integer,String> map=new HashMap<Integer,String>();
      map.put(1, "林黛玉");
      map.put(2, "薛宝钗");
      map.put(4, "贾探春");
      map.put(5, "史湘云");
      map.put(6, "妙玉");
      //集合里面保存的是键值对Map.Entry<K,V>
      Set<Map.Entry<Integer, String>> set=map.entrySet();
      //注意迭代器里面泛型,必须和集合的一模一样
      Iterator<Map.Entry<Integer, String>> it=set.iterator();
      while (it.hasNext()) {
         Map.Entry<Integer, String> entry = (Map.Entry<Integer, String>) it.next();
         /*
          * 现在有了映射关系,如何取出里面的键和值呢?
          * Map.Entry提供了我们方法 
          * K getKey() 返回与此项对应的键。 
          * V getValue() 返回与此项对应的值。 
          * oldValue setValue(V newValue) 用指定的新值替换与此项对应的旧值*/
         Integer key=entry.getKey();
         String value=entry.getValue();
         System.out.println(key+"..."+value);
      }
   }
   @Test
   public void method2() {
      /*由于Map本身没有迭代器
       通过Map的keySet方法得到键的集合(Set 视图)
       再通过Set视图可以拿到迭代器,迭代出每一个键,
       最后通过键,就可以取对应的值了~
       Set<K> keySet() 
    返回此映射中包含的键的 Set 视图。*/ 
      Map<Integer,String> map=new HashMap<Integer,String>();
      map.put(1, "林黛玉");
      map.put(2, "薛宝钗");
      map.put(4, "贾探春");
      map.put(5, "史湘云");
      map.put(6, "妙玉");
      Set<Integer> keySet=map.keySet();
      Iterator<Integer> it=keySet.iterator();
      while (it.hasNext()) {
         //规定了泛型,就可以不用强转了
         Integer key =it.next();
         System.out.println(map.get(key));
      }
   }
   @Test
   public void method1() {//模拟学生:学号+姓名
      /*put添加元素: V put(K key, V value) 
        将指定的值与此映射中的指定键关联（可选操作）。 
      返回以前与 key 关联的值，如果没有针对 key 的映射关系，则返回 null
      返回值:the previous value associated with key, 
      or null if there was no mapping for key. 
      (A null return can also indicate that the map previously associated null with key, 
      if the implementation supports null values.)
      */
      Map<Integer,String> map=new HashMap<Integer,String>();
      System.out.println(map.put(4, "张三"));
      //null,因为以前没有哪个值,关联过键4
      System.out.println(map.put(4, "李四"));
      //返回张三,即旧值(张三)曾与4关联;
      System.out.println(map.put(5, "王五"));
      //null,同理 因为以前没有哪个值,关联过键5
      System.out.println(map);
      //map的自定义打印形式: {4=李四, 5=王五}
      
      /*map的remove方法:
      V remove(Object key)
      返回以前与 key 关联的值;
      如果没有key的映射关系,则返回 null。*/ 
      System.out.println(map.remove(5));
      //返回王五,
      System.out.println(map);
      //剩下{4=李四}
      System.out.println(map.containsKey(4));
      //true
      System.out.println(map.containsKey(9));
      //false
      System.out.println(map.containsValue("李四"));
      //true
      System.out.println(map.containsValue("寒塘渡鹤影,冷月葬花魂"));
      //false
      System.out.println(map.size());
      //1 个键值对~ 即{4=李四}
      
      /*map的get方法:
      获取 V get(Object key) 
    返回指定键所映射的值；
    如果此映射不包含该键的映射关系，则返回 null。*/
      System.out.println(map.get(4));//李四
      System.out.println(map.get(8));//null
   }
}

TreeMapDemo

package temp;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;

import uncommitted.Student;

public class TreeMapDemo {
   public static void main(String[] args) {
      /*TreeMap()空参默认是按成员(即Student对象)的compareTo方法排序
      TreeMap<Student,String> map=new TreeMap<Student,String>();
      下面我要按姓名排序,传一个参数,
      该参数是一个实现了比较器Comparator接口的类*/
      TreeMap<Student,String> map=new TreeMap<Student,String>(new ComparatorByName());
      method1(map);
   }
   public static void method1(TreeMap<Student,String> tm) {
      // 要求:将学生对象<key>和学生归属地<value>存储到Map集合中
      tm.put(new Student("sg",21), "北京");
      tm.put(new Student("keke",18), "武汉");
      tm.put(new Student("gaoshou",29), "香港");
      tm.put(new Student("abs",16), "台湾");
      Set<Map.Entry<Student, String>> entrySet=tm.entrySet();
      Iterator<Map.Entry<Student, String>> it=entrySet.iterator();
      //上面两句可以简化成这一句即可!
      //Iterator<Map.Entry<Student, String>> it=tm.entrySet().iterator();
      while (it.hasNext()) {
         Map.Entry<Student, String> entry = (Map.Entry<Student, String>) it.next();
         Student key=entry.getKey();
         String value=entry.getValue();
         System.out.println(key.getName()+"..."+key.getAge()+"..."+value);
      }
   }
}

TreeSetDemo

package temp;
import java.util.Iterator;
import java.util.TreeSet;

import org.junit.Test;

import bean.Person;
public class TreeSetDemo {
   @Test
   public void method4() {
      // TreeSet实现排序的第2种办法:让集合自身具备排序功能!
      // 比较器,按字符串长度进行比较,长度相同按Unicode码排序
      TreeSet ts=new TreeSet(new ComparatorByStringLength());
      ts.add("abc");
      ts.add("a");
      ts.add("z");
      ts.add("bc");
      ts.add("ddabc");
      Iterator it=ts.iterator();
      while (it.hasNext()) {
         System.out.println(it.next());
      }
   }
   @Test   
   public void method3() {
      /*TreeSet实现排序的第2种办法:让集合自身具备排序功能!
         TreeSet(Comparator comparator) 
      构造一个新的空 TreeSet，它根据指定比较器进行排序。*/
      TreeSet ts=new TreeSet(new ComparatorByName());
      ts.add(new Person("a李纹",23));
      ts.add(new Person("c李绮",26));
      ts.add(new Person("d宝琴",24));
      ts.add(new Person("b岫烟",25));
      Iterator it=ts.iterator();
      while (it.hasNext()) {
         System.out.println(it.next());//出现类型转换异常
      }
   }
   @Test
   public void method2() {
      /*public interface Comparable<T>
      此接口强行对实现它的每个类的对象进行整体排序。
      这种排序又被称为类的自然排序，
      类的 compareTo 方法被称为它的自然比较方法。
      TreeSet它不看其他方法,只看对象的compareTo方法,
      如果为0,就视为同一元素;不再添加*/
      TreeSet ts=new TreeSet();
      ts.add(new Person("a李纹",23));
      ts.add(new Person("c李绮",26));
      ts.add(new Person("d宝琴",24));
      ts.add(new Person("b岫烟",25));
      ts.add(new Person("b岫烟",25));
      Iterator it=ts.iterator();
      while (it.hasNext()) {
         System.out.println(it.next());//出现类型转换异常
      }
   }
   @Test
   public void method1() {
      /*1:基于 TreeMap 的 NavigableSet 实现。
       * 使用元素的自然顺序对元素进行排序，
      只要元素对象实现了Comparable接口,
      具备了可比性,且覆写了compareTo方法!   
      如果对象没有实现Comparable接口,
      则不具备可比性,在存入TreeSet时,
      会出现类型转换异常   
      2:或者根据创建 set 时提供的参数 Comparator 进行排序，
      具体取决于使用的构造方法。*/
      TreeSet<String> ts=new TreeSet<String>();
      ts.add("sgycw");
      ts.add("bac");
      ts.add("nba");
      ts.add("zz");
      ts.add("sb");
      Iterator it=ts.iterator();
      while (it.hasNext()) {
         System.out.println(it.next());
         //英语单词进去无序,出来按字母顺序排列好啦!!!哈哈
      }
   }
}