17、集合框架_HashSet\TreeSet\比较器\泛型
一、Set接口中的实现类
- Set接口存储一组唯一，无序的对象
- （存入和取出的顺序不一定一致）
- 操作数据的方法与List类似，Set接口不存在get()方法
▪HashSet:采用Hashtable哈希表存储结构
–优点：添加速度快，查询速度快，删除速度快
–缺点：无序
–LinkedHashSet
▪ 采用哈希表存储结构，同时使用链表维护次序
▪有序（添加顺序）
▪TreeSet
–采用二叉树（红黑树）的存储结构
–优点：有序（排序后的升序）查询速度比List快
–缺点：查询速度没有HashSet快
1、Hash表原理
public class SetDemo implements Comparator<Person> { public static void main(String[] args) { Set set = new HashSet(); set.add("123"); set.add(1); set.add(true); set.add("123"); System.out.println(set); }
源码:
HashSet的本质其实是HashMap
public class SetDemo { public static void main(String[] args) { Set set = new HashSet(); set.add("123"); set.add(1); set.add(true); set.add("123"); System.out.println(set); Iterator iterator = set.iterator(); while (iterator.hasNext()){ System.out.println(iterator.next()); } System.out.println("---------"); //将while循环改成for循环,推荐使用 for(Iterator iter = set.iterator(); iter.hasNext();){ System.out.println(iter.next()); } } }
打印结果为:
/* [1, 123, true] 1 123 true --------- 1 123 true Process finished with exit code 0 */
二、Treeset
public class SetDemo { public static void main(String[] args) { TreeSet treeSet = new TreeSet(); treeSet.add("123"); treeSet.add(1); treeSet.add("a"); System.out.println(treeSet); } }
报错：
为什么会报错，需要了解一下TreeSet的数据结构
源码
TreeSet本质上是TreeMap
TreeMap
用的是红黑数
/* 基础知识补充 BST树： 二叉搜索比(Binary Search Tree, 简写BST),又称为二叉排序树，属于树的一种.通过二叉树将数据组织起来，树的每个 节点包含了键值 Key、数据值 data、左子节点指针、右子节点指针.其中键值key是最核心的部分,它的值次定了树的 组织形状； 数据值data是该节点对应的数据， 有些场景可以忽略，举个例子， key 为身份证号而data人名，通过身份证号找人名；左子节点指针指向左子节点，右子节点指针指向右子节点。 特点： 左右子树也分别是二又搜索树. 左子树的所有节点key值都小于它的根节点的key值 右子树的所有节点key值都大于它的根节点的key值 二又搜索树可以为一颗空树. 一般来说.树中的每个节点的key值都不相等,唱根据需要也可以将相同的key值插入树中 AVL树: AVL树.也称平衡二叉搜索树.AVL树属于树的一种.而且它也是一颗二叉搜索树.不同的是 他通过一定机制能保证二叉搜索树的平衡，平衡的二叉搜索树的查询效率更高 特点： AVL树是一颗二叉搜索树. AVL树的左右子书点也是AVL树. AVI树拥有二叉树的所有基本特点. 每个节点的左右子节点的高度之差的绝对值最多为1，即平衡因子的范围为[-1,1] 红黑树 红黑（Red-black）树 是一种自平衡二叉查找树，它与AVL树类似.都在插入和删除操作时能通过旋转操作保持二叉查找树的平衡，以便能获取高效的查找性能。它可以在O（logn）时间内查找，插入和删除等操作。红黑树是2-3-4树的一种等同，但有些红黑树设定只能左边是红树，这种情况就是2-3树的一种等同了。对于AVL树来说，红黑树牺牲了部分平衡性。 特点： 节点是红色或黑色. 根节点是黑也. 每个叶节点（NIL节点）是黑色的. 每个红色节点的两个子节点都为黑色.(从每个叶子到根的所有路径上不能有两个连续的红色节点 从任一节点到其每个叶子的所有路径都包含相同数目的黑色节点 最长路径不超过最短路径的2倍 */
左子树小于根，右子树大于根，有一个自动排序的过程
public class SetDemo { public static void main(String[] args) { TreeSet treeSet = new TreeSet(); treeSet.add(31); treeSet.add(1); treeSet.add(6); System.out.println(treeSet); } }
打印结果为：
/* [1, 6, 31] Process finished with exit code 0 */
Set
public class Person implements Comparable{ private String name; private int age; public Person(){ } public Person(String name, int age) { this.name = name; this.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; } @Override public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; Person person = (Person) o; return age == person.age && Objects.equals(name, person.name); } @Override public int hashCode() { return Objects.hash(name, age); } @Override public String toString() { return "Person{" + "name='" + name + '\'' + ", age=" + age + '}'; } }
public class SetDemo { public static void main(String[] args) { TreeSet treeSet = new TreeSet(); treeSet.add(34); treeSet.add(1); treeSet.add(65); System.out.println(treeSet.ceiling(1)); System.out.println(treeSet); HashSet hashSet = new HashSet(); hashSet.add(new Person("zhangsan",12)); hashSet.add(new Person("zhangsan",12)); hashSet.add(new Person("lisi",13)); System.out.println(hashSet); } }
会打印两个，因为是Set
/* ▪ 总结:
▪ HashSet是如何保证元素的唯一性的呢?
▪ 答:是通过元素的两个方法,hashCode和equals方法来完成 ▪ 如果元素的HashCode值相同，才会判断equals是否为true ▪ 如果元素的hashCode值不同，不会调用equals方法 */
▪ TreeSet
– 采用二叉树（红黑树）的存储结构
– 优点：有序（排序后的升序）查询速度比List快
– 缺点：查询速度没有HashSet快
1、Comparable接口
/* * 比较器分类： * 内部比较器 * 定义在元素的类中，通过实现comparable接口来进行实现 * 外部比较器 * 定义在当前类中，通过实现comparator接口来实现，但是要将该比较器传递到集合中 * 注意：外部比较器可以定义成一个工具类，此时所有需要比较的规则如果一致的话，可以复用，而 * 内部比较器只有在存储当前对象的时候才可以使用 * 如果两者同时存在，使用外部比较器 * 当使用比较器的时候，不会调用equals方法 * */
树中的元素是要默认进行排序操作的，如果是基本数据类型，自动比较，如果是引用类型的话，需要自定义比较器
1.1、内部比较器
• 所有可以“排序”的类都实现了java.lang.Comparable 接口，
Comparable接口中只有一个方法
public int compareTo(Object obj)；
public class Person implements Comparable{ private String name; private int age; public Person(){ } public Person(String name, int age) { this.name = name; this.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; } @Override public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; Person person = (Person) o; return age == person.age && Objects.equals(name, person.name); } @Override public int hashCode() { return Objects.hash(name, age); } /** * 此比较器按照name的长度来进行比较 * @param o * @return */ @Override public int compareTo(Object o) { Person p = (Person) o; // 强制转换 if (p.name.length()>this.name.length()){ return -1; }else if(p.name.length()<this.name.length()){ return 1; }else{ return 0; } } @Override public String toString() { return "Person{" + "name='" + name + '\'' + ", age=" + age + '}'; } }
public class SetDemo { public static void main(String[] args) { TreeSet treeSet = new TreeSet(); treeSet.add(new Person("lisi",15)); treeSet.add(new Person("wangwu",13)); treeSet.add(new Person("maliu",12)); treeSet.add(new Person("zhangsan",19)); treeSet.add(new Person("zhangsan",12)); System.out.println(treeSet); } }
1.2、外部比较器
public class Person{ private String name; private int age; public Person(){ } public Person(String name, int age) { this.name = name; this.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; } @Override public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; Person person = (Person) o; return age == person.age && Objects.equals(name, person.name); } @Override public int hashCode() { return Objects.hash(name, age); } @Override public String toString() { return "Person{" + "name='" + name + '\'' + ", age=" + age + '}'; } }
public class SetDemo implements Comparator<Person> { public static void main(String[] args) { TreeSet treeSet = new TreeSet(new SetDemo()); treeSet.add(new Person("lisi",15)); treeSet.add(new Person("wangwu",13)); treeSet.add(new Person("maliu",12)); treeSet.add(new Person("zhangsan",19)); treeSet.add(new Person("zhangsan",12)); System.out.println(treeSet); } @Override public int compare(Person o1, Person o2) { if(o1.getAge()>o2.getAge()){ return -1; }else if(o1.getAge() < o2.getAge()){ return 1; }else{ return 0; } } }
三、泛型
这时就报错了
list里面有整形、字符串、布尔、自定义对象
可以放object
public class FanXingDemo { public static void main(String[] args) { List list = new ArrayList<String>(); list.add(1); // new Integer(1) list.add("abc");//new String("abc) list.add(true);//new Boolean(true) list.add(new Person("zhangsan",12).toString()); System.out.println(list); // for(int i = 0;i<list.size();i++){ // System.out.println(list.get(i)); // } for(Object iter:list){ System.out.println(iter); } } }
打印结果为：
/* [1, abc, true, Person{name='zhangsan', age=12}] 1 abc true Person{name='zhangsan', age=12} Process finished with exit code 0 */
我现在想要的是只拿Person里的
能强转吗
public class FanXingDemo { public static void main(String[] args) { List list = new ArrayList<String>(); list.add(1); // new Integer(1) list.add("abc");//new String("abc) list.add(true);//new Boolean(true) list.add(new Person("zhangsan",12).toString()); System.out.println(list); // for(int i = 0;i<list.size();i++){ // System.out.println(list.get(i)); // } for(Object iter:list){ Person p = (Person) iter; System.out.println(iter); } } }
报错
不能进行转换int 类型不能转成persion对象
这种情况
当做一些集合的统一操作的时候，需要保证集合的类型是统一的，此时需要泛型来进行限制
/** * 优点： * 1、数据安全 * 2、获取数据时效率比较高 * 给集合中的元素设置相同的类型就是泛型的基本需求 * 使用： * 在定义对象的时候，通过<>中设置合理的类型来进行实现 */
public class FanXingDemo { public static void main(String[] args) { List<String> list = new ArrayList<String>(); list.add("1"); // new Integer(1) list.add("abc");//new String("abc") list.add("true");//new Boolean(true) list.add(new Person("zhangsan",12).toString()); System.out.println(list); // for(int i = 0;i<list.size();i++){ // System.out.println(list.get(i)); // } // for(String iter:list){ System.out.println(iter); } } }
打印结果为:
/* [1, abc, true, Person{name='zhangsan', age=12}] 1 abc true Person{name='zhangsan', age=12} Process finished with exit code 0 */
四、泛型的高阶应用
1、泛型类
/* 在定义类的时候在类名的后面添加<E,K,V,A,B>,起到占位的作用，类中的方法的返回值类型和属性的类型都可以使用
E:element K:key V:value A:占位 什么字母无所谓, */
public class FanXingClass<A> { private int id; private A a; public int getId() { return id; } public void setId(int id) { this.id = id; } public A getA() { return a; } public void setA(A a) { this.a = a; } public void show(){ System.out.println("id : "+id+" ,A : "+a); } }
public class FanXingDemo { public static void main(String[] args) { FanXingClass<String> fxc = new FanXingClass<String>(); fxc.setA("mashibing"); fxc.setId(1); fxc.show(); FanXingClass<Integer> fxc2 = new FanXingClass<Integer>(); fxc2.setA(34); fxc2.setId(2); fxc2.show(); FanXingClass<Person> fxc3 = new FanXingClass<Person>(); fxc3.setA(new Person("aaa",123)); fxc3.setId(3); fxc3.show(); } }
打印结果为:
/* id : 1 ,A : mashibing id : 2 ,A : 34 id : 3 ,A : Person{name='aaa', age=123} Process finished with exit code 0 */
返回特定的类型
public class FanXingClass<A> { private int id; private A a; public int getId() { return id; } public void setId(int id) { this.id = id; } public A getA() { return a; } public void setA(A a) { this.a = a; } public void show(){ System.out.println("id : "+id+" ,A : "+a); } public A get(){ return a; } public void set(A a){ System.out.println("执行set方法：" + a); } }
public class FanXingDemo { public static void main(String[] args) { FanXingClass<String> fxc = new FanXingClass<String>(); fxc.setA("mashibing"); fxc.setId(1); fxc.show(); FanXingClass<Integer> fxc2 = new FanXingClass<Integer>(); fxc2.setA(34); fxc2.setId(2); fxc2.show(); FanXingClass<Person> fxc3 = new FanXingClass<Person>(); fxc3.setA(new Person("aaa",123)); fxc3.setId(3); fxc3.show(); System.out.println(fxc3.get()); fxc3.set(new Person("hhe",123)); } }
打印结果为:
/* id : 1 ,A : mashibing id : 2 ,A : 34 id : 3 ,A : Person{name='aaa', age=123} Person{name='aaa', age=123} 执行set方法：Person{name='hhe', age=123} Process finished with exit code 0 */
2、泛型接口
/* * 2、泛型接口 * 在定义接口的时候，在接口的名称后添加<E,K,V,A,B>, * 1、子类在进行实现的时候，可以不填写泛型的类型，此时在创建具体的子类对象的时候才决定使用什么类型 * 2、子类在实现泛型接口的时候，只在实现父类的接口的时候指定父类的泛型类型即可，此时，测试方法中的泛型类型必须要跟子类保持一致 */
public interface FanXingInterface<B> { public B test(); public void test2(B b); }
怎么对它进行实现
public class FanXingInterfaceSub implements FanXingInterface<String> { @Override public String test() { return null; } @Override public void test2(String string) { System.out.println(string); } }
public class FanXingDemo { public static void main(String[] args) { FanXingInterfaceSub fxi = new FanXingInterfaceSub() ; fxi.test2("123"); } }
打印结果为:
/* 123 Process finished with exit code 0 */
return null 这里的返回值应该如何写, FanXingInterfaceSub<String> 不是真正的String
FanXingInterfaceSub<Integer> fxm = new FanXingInterface<Ingeger>();
也可以
3、泛型方法
/* * 在定义方法的时候，指定方法的返回值和参数是自定义的占位符，可以是类名中的T,也可以是自定义的Q，只不过在使用Q的时候需要使用 * <Q>定义在返回值的前面 */
public class FanXingMethod<T> { private T t; public T getT() { return t; } public void setT(T t) { this.t = t; } public <Q> void show(Q q){ System.out.println(q); System.out.println(t); } }
public class FanXingDemo { public static void main(String[] args) { FanXingMethod<String> fxm = new FanXingMethod<>(); fxm.setT("ttt"); fxm.show(123); fxm.show(true); } }
打印结果为:
/* 123 ttt true ttt Process finished with exit code 0 */
4、泛型的上限(工作中不用)
extends 继承
如果父类确定了，所有的子类都可以直接使用
5、泛型的下限(工作中不用)
如果子类确定了，子类的所有父类都可以直接传递参数使用
