1.treeSet

目前学习了三个及各类，分别为：

ArrayList：底层是数组，可以根据下标操作数据，数据可以重复，存取数据类型保持一致

LinkedList：底层是双向链表，有头有尾，可以根据头尾来操作数据，数据也可以重复，存取数据类型保持一致

HashCode：底层是一个hash表，不能保存重复的数据（一个萝卜一个坑）。存取相对无序。

TreeSet：它也是Set接口下面的一个实现类，可以保证数据唯一性，存取相对无序，同时可以对存入的数据进行排序。底层是二叉树（数据结构）。不能存重复数据

  1. 只要将数据存到TreeSet集合中，就已经开始进行排序了，默认的自然排序是升序。。。

1.1TerrSet存放自定义的对象

案例，使用TreeSet储存Student对象，按照年龄进行排序。

如果存入的是一个对象的话，需要让类实现一个比较器接口Comparable这个接口

1. compareTo

重写下面的compareTo（Student student）返回值是int类型的数据

实现这个方法的时候，这个只可以是正数、负数、0

如果是正数，表示对象调用此方法大于指定对象

如果是负数，表示对象调用此方法小于指定对象

如果是0，表示对象调用此方法等于指定对象

  1. package com.qfedu.test1TreeSet;
  3. import java.util.TreeSet;
  5. //TreeSet集合存入Person对象，属性name、age
  6. //按照name属性字典顺序进行比较，如果一样在按照年龄进行比较
  8. class Person implements Comparable<Person>{
  9.     String name;
  10.     int age;
  11.     public Person(String name, int age) {
  12.         super();
  13.         this.name = name;
  14.         this.age = age;
  15.     }
  16.     @Override
  17.     public String toString() {
  18.         return "Person [name=" + name + ", age=" + age + "]";
  19.     }
  20.     @Override
  21.     public int compareTo(Person o) {
  22.         //字符串按照字典顺序用String类下重写的 conpareTo方法
  23.         int number = this.name.compareTo(o.name);
  24.         if (number == 0) {//名字意义按照年龄排
  25.             int number2 = this.age - o.age;
  26.             return number2;
  27.         }
  28.         return number;
  29.     }
  30. }
  32. public class Demo2 {
  33.     public static void main(String[] args) {
  34.         TreeSet<Person> set = new TreeSet<Person>();
  35.         set.add(new Person("z朱志伟", 24));
  36.         set.add(new Person("g谷小天", 30));
  37.         set.add(new Person("l刘子贤", 20));
  38.         set.add(new Person("z朱航", 23));
  39.         set.add(new Person("z朱志伟", 18));
  40.         System.out.println(set);
  41.         for (Person person : set) {
  42.             System.out.println(person);
  43.         }
  44.     }
  45. }

2. 比较器

除了实现Comparable接口之外，还有一种写法，比较器

需要使用接口Comparator

案例

  1. package com.qfedu.test1TreeSet;
  3. import java.util.Comparator;
  4. import java.util.TreeSet;
  6. //比较器  
  7. class Animals{
  8.     String name;
  9.     int age;
  10.     public Animals(String name, int age) {
  11.         super();
  12.         this.name = name;
  13.         this.age = age;
  14.     }
  15.     @Override
  16.     public String toString() {
  17.         return "Animals [name=" + name + ", age=" + age + "]";
  18.     }
  19. }
  21. class MyComparator implements Comparator<Animals>{
  22.     @Override
  23.     public int compare(Animals o1, Animals o2) {
  24.         int num1 = o1.age - o2.age;
  25.         return num1;
  26.     }
  27. }
  29. public class Demo3bijiaoqi {
  30.     public static void main(String[] args) {
  31.         TreeSet<Animals> set = new TreeSet<Animals>(new MyComparator());
  32.         set.add(new Animals("a", 12));
  33.         set.add(new Animals("b", 120));
  34.         set.add(new Animals("c", 123));
  35.         set.add(new Animals("d", 12));//没了
  36.         set.add(new Animals("e", 99));
  37.         System.out.println(set);
  38.         for (Animals animals : set) {
  39.             System.out.println(animals);
  40.         }
  42.     }
  43. }

2.匿名内部类

目的就是减少代码量的

2.1基于抽象类的匿名内部类【重点】

  1. package com.qfedu.test2niming;
  3. //基于抽象类的匿名内部类
  4. abstract class Teacher{
  5.     public abstract void work();
  6. }
  7. public class Demo3 {
  8.     public static void main(String[] args) {
  9.         test(new Teacher() {
  11.             @Override
  12.             public void work() {
  13.                 // TODO Auto-generated method stub
  14.                 System.out.println("我要当老板");
  15.             }
  17.         });
  18.     }
  19.     //一个方法传的是抽象类，抽象来正常需要一个正常类去继承
  20.     //但是可以直接new抽象类，然后调用下面的方法
  21.     public static void test(Teacher teacher) {
  22.         teacher.work();
  23.     }
  24. }

2.2基于接口的匿名内部类【重点】

案例1

  1. package com.qfedu.test2niming;
  2. //方法1
  3. interface A{
  4.     void eat();
  5. }
  6. public class Demo4 {
  7.     public static void main(String[] args) {
  8.         //案例1
  9.         A a = new A() {
  11.             @Override
  12.             public void eat() {
  13.                 System.out.println("吃饭");
  14.             }
  16.         };
  17.         a.eat();
  19.         //案例2
  20.         new A() {
  22.             @Override
  23.             public void eat() {
  24.                 System.out.println("a ?");
  25.             }
  27.         }.eat();;
  28.     }
  29. }

案例2

  1. package com.qfedu.test2niming;
  2. //方法2
  3. interface B{
  4.     void eat();
  5. }
  6. public class Demo5 {
  7.     public static void main(String[] args) {
  8.         test(new B() {
  9.             @Override
  10.             public void eat() {
  11.                 // TODO Auto-generated method stub
  12.                 System.out.println("谷小天吃粑粑");
  13.             }
  14.         });
  15.     }
  16.     public static void test(B b) {
  17.         b.eat();
  18.     }
  19. }

改进Comparator

3.Map集合

集合用来存储数据的，双边队列。Map

K:键 V：值

  1. HashMap  基于hash值进行存储的，是key。
  2. TreeMap  基于二叉树进行存储
  3. public

方法：Map常用方法

  1. K是键        V是值
  2. 增：
  3.     v put(k,v);//键一样，替换值。键不一样，内容可以重复
  4.     v putAll();
  5. 删：
  6.     v remove(object key);
  7. 改
  8.     v put(k,v);//当K存在就修改内容，k不存在就是添加值
  9. 查
  10.     int size();//返回键值对的数量
  11.     boolean isEmpty();//是否为空
  12.     boolean containsKey(object k);//有没有这个键k
  13.     boolean containsValue(object v);//是否有v这个值
  14.     v get(object K);//根据键找值
  16.     Set<k> keySet();//取出键，存到Set集合中
  17.     Collection<v> values();//取出值，存到Collection集合中
  18. 为什么K键存Set，V值存Collection？？？？
  19.     Set不可重复，所以K键存Set中
  20.     因为K是唯一的，key是通过hash值进行存储的。value可以重复
  22.     Set<map.Entry<k,v>> entrySet();//把Map转换成Set 方便遍历
  23.     //Set<Map.Entry<String, String>> entry = map.entrySet();

经典问题：

为什么K键存Set，V值存Collection？？？？
Set不可重复，所以K键存Set中
因为K是唯一的，key是通过hash值进行存储的。value可以重复

  1. package com.qfedu.test3Map;
  3. import java.util.Collection;
  4. import java.util.HashMap;
  5. import java.util.Map;
  6. import java.util.Set;
  8. public class Demo1 {
  9.     public static void main(String[] args) {
  10.         Map<String, String> map = new HashMap<String, String>();
  11.         //增 改都是put
  12.         map.put("003", "王梦哲");
  13.         map.put("001", "朱志伟");
  14.         map.put("001", "朱爷");//键一样，替换值
  15.         map.put("002", "朱航");
  16.         //键不能一样，且根据键排序
  17.         System.out.println(map);
  18.         //putAll 增加集合
  19.         Map<String, String> map1 = new HashMap<String, String>();
  20.         map1.put("004", "刘子贤");
  21.         map1.put("005", "张桂园");
  22.         map.putAll(map1);;
  23.         System.out.println(map);
  24. //        for (String string : map) {//不能遍历
  25. //            System.out.println(string);
  26. //        }
  27.         //删
  28.         map.remove("004");//删除004
  29.         System.out.println(map);
  30.         //查
  31.         System.out.println(map.size());//键值对个数    4
  32.         System.out.println(map.isEmpty());//是否为空    F
  33.         System.out.println(map.containsKey("009"));//有没有009这个键    F
  34.         System.out.println(map.containsValue("谷小天"));//有没有谷小天这个值    F
  35.         System.out.println(map.get("001"));//根据键找值
  37.         Set<String> set = map.keySet();//取出键，存到Set集合中
  38.         System.out.println(set);
  40.         Collection<String> list = map.values();//取出值，存到Collection集合中
  41.         System.out.println(list);
  43.         //将map实体封装给了Set集合，方便遍历
  44.         Set<Map.Entry<String, String>> entry = map.entrySet();
  45.         System.out.println(entry);
  46.         //遍历
  47.         for (Map.Entry<String, String> entry2 : entry) {
  48.             System.out.println(entry2);
  49. //            System.out.println(entry2.getKey());//获取键
  50. //            System.out.println(entry2.getValue());//获取值
  51.         }
  52.     }
  54. }