【Java】【基础篇】day15：集合（TreeSet）和泛型

前言

本期任务：毕向东老师Java视频教程学习笔记（共计25天）

原视频链接：黑马程序员_毕向东_Java基础视频教程day01：编写HelloWorld程序day02：操作符与条件选择语句day03：循环语句与函数day04：数组day07：继承、抽象类与接口day08：多态day09：异常处理day11：多线程day12：线程安全与同步机制day13：String类day14：集合（ArrayList，LinkedList，HashSet）day15：集合（TreeSet）和泛型）day16：集合（HashMap、TreeMap）day17：集合框架的工具类（Arrays、Collections）day18：IO流（字符流读写）day19：IO流（字节流、转换流读写）day20：IO流（File对象）

---

代码

import java.util.*; /* Set:无序，不可以重复元素。 |--HashSet：数据结构是哈希表。线程是非同步的。 保证元素唯一性的原理：判断元素的hashCode值是否相同。 如果相同，还会继续判断元素的equals方法，是否为true。 |--TreeSet：可以对Set集合中的元素进行排序。 底层数据结构是二叉树。 保证元素唯一性的依据： compareTo方法return 0. TreeSet排序的第一种方式：让元素自身具备比较性。 元素需要实现Comparable接口，覆盖compareTo方法。 也种方式也成为元素的自然顺序，或者叫做默认顺序。 TreeSet的第二种排序方式。 当元素自身不具备比较性时，或者具备的比较性不是所需要的。 这时就需要让集合自身具备比较性。 在集合初始化时，就有了比较方式。 需求： 往TreeSet集合中存储自定义对象学生。 想按照学生的年龄进行排序。 记住，排序时，当主要条件相同时，一定判断一下次要条件。 */ // 实现Comparable接口，自行编写compareTo函数，使得学生类对象具备比较性 class Student implements Comparable { private String name; private int age; Student(String name, int age) { this.name = name; this.age = age; } public String getName() { return name; } public int getAge() { return age; } public int compareTo(Object obj) { if (!(obj instanceof Student)) throw new RuntimeException("不是学生对象"); Student s = (Student) obj; // System.out.println(s.getName()+"......"+s.getAge()); if (age > s.age) return 1; if (age == s.age) return s.name.compareTo(name); return -1; } } public class TreeSetDemo { public static void main(String[] args) { TreeSet ts = new TreeSet(); ts.add(new Student("张三", 10)); ts.add(new Student("张三", 10)); ts.add(new Student("张三", 11)); ts.add(new Student("李四", 20)); ts.add(new Student("王五", 15)); Iterator it = ts.iterator(); while (it.hasNext()) { Student s = (Student) it.next(); System.out.println(s.getName() + "......" + s.getAge()); } } } import java.util.*; /* 当元素自身不具备比较性，或者具备的比较性不是所需要的。 这时需要让容器自身具备比较性。 定义了比较器，将比较器对象作为参数传递给TreeSet集合的构造函数。 当两种排序都存在时，以比较器为主。 定义一个类，实现Comparator接口，覆盖compare方法。 */ class Student2 { private String name; private int age; Student2(String name, int age) { this.name = name; this.age = age; } public String getName() { return name; } public int getAge() { return age; } } // 定义一个类，实现Comparator接口，覆盖compare方法。 class MyCompare implements Comparator { public int compare(Object obj1, Object obj2) { Student2 s1 = (Student2) obj1; Student2 s2 = (Student2) obj2; // if (s1.getAge() > s2.getAge()) // return 1; // // if (s1.getAge() == s2.getAge()) // return s1.getName().compareTo(s2.getName()); // // return -1; // 优化 int num = new Integer(s1.getAge()).compareTo(new Integer(s2.getAge())); if (num == 0) { return s1.getName().compareTo(s2.getName()); } return num; } } public class TreeSetDemo2 { public static void main(String[] args) { TreeSet ts = new TreeSet(new MyCompare()); ts.add(new Student2("张三", 10)); ts.add(new Student2("张三", 10)); ts.add(new Student2("张三", 11)); ts.add(new Student2("李四", 20)); ts.add(new Student2("王五", 15)); Iterator it = ts.iterator(); while (it.hasNext()) { Student2 s = (Student2) it.next(); System.out.println(s.getName() + "......" + s.getAge()); } } } /* 练习：按照字符串长度排序。 字符串本身具备比较性。但是它的比较方式不是所需要的。 这时就只能使用比较器。 需求：按照长度进行排序 思路：新建一个类，实现Comparator接口，覆盖compare方法 */ import java.util.*; class LenComparator implements Comparator { public int compare(Object obj1, Object obj2) { String s1 = (String) obj1; String s2 = (String) obj2; int num = new Integer(s1.length()).compareTo(new Integer(s2.length())); if (num == 0) { return s1.compareTo(s2); } return num; } } public class TreeSetTest { public static void main(String[] args) { TreeSet ts = new TreeSet(new LenComparator()); ts.add("jdkaflskdijf"); ts.add("asdfa"); ts.add("gasdf"); ts.add("dafgds"); ts.add("sadjfl;dj"); Iterator it = ts.iterator(); while (it.hasNext()) { System.out.println(it.next()); } } } /* "90 -7 0 18 2 45 4" 将字符串中的数值进行排序。使用TreeSet完成。 思路 1，将字符串切割。 2，可以将这些对象存入TreeSet集合。因为TreeSet自身具备排序功能。 */ import java.util.TreeSet; public class TreeSetTest2 { public static void main(String[] args) { String str = "90 -7 0 18 2 45 4"; String[] arr = str.split(" "); TreeSet ts = new TreeSet(); for (int x = 0; x < arr.length; x++) { ts.add(new Integer(arr[x])); } System.out.println(ts); } } import java.util.*; /* 泛型：JDK1.5版本以后出现新特性。用于解决安全问题，是一个类型安全机制。 好处 1.将运行时期出现问题ClassCastException，转移到了编译时期。， 方便于程序员解决问题。让运行时问题减少，安全。， 2，避免了强制转换麻烦。 泛型格式：通过<>来定义要操作的引用数据类型。 在使用java提供的对象时，什么时候写泛型呢？ 通常在集合框架中很常见， 只要见到<>就要定义泛型。 其实<> 就是用来接收类型的。 当使用集合时，将集合中要存储的数据类型作为参数传递到<>中即可。 */ public class GenericDemo { public static void main(String[] args) { ArrayList<String> al = new ArrayList<String>(); al.add("flkads;l"); al.add("dfajdslk;l"); System.out.println(al); Iterator<String> it = al.iterator(); while(it.hasNext()){ System.out.println(it.next()); } } } import java.util.Comparator; import java.util.Iterator; import java.util.TreeSet; public class GenericDemo2 { public static void main(String[] args) { TreeSet<String> ts = new TreeSet<String>(new LenComparator2()); ts.add("dakfhjl"); ts.add("dafdfasdf"); ts.add("daffadsf a"); Iterator<String> it = ts.iterator(); while (it.hasNext()) { System.out.println(it.next()); } } } class LenComparator2 implements Comparator<String> { public int compare(String o1, String o2) { int num = new Integer(o1.length()).compareTo(new Integer(o2.length())); if (num == 0) { return o1.compareTo(o2); } return num; } } /* 什么时候定义泛型类？ 当类中要操作的引用数据类型不确定的时候， 早期定义Object来完成扩展。 现在定义泛型来完成扩展。 注：工具类本质上就是针对类对象进行特殊操作 */ // 泛型前的做法 class Tool { private Object obj; public void setObject(Object obj) { this.obj = obj; } public Object getObject() { return obj; } } // 泛型做法 class Utils<Q> { private Q q; public void setObject(Q q) { this.q = q; } public Q getObject() { return q; } } class Worker{ } class Student1{ } public class GenericDemo3 { public static void main(String[] args) { Utils<Student1> u1 = new Utils<Student1>(); u1.setObject(new Student1()); System.out.println(u1.getObject()); Utils<Worker> u2 = new Utils<Worker>(); u2.setObject(new Worker()); System.out.println(u2.getObject()); } } //泛型类定义的泛型，在整个类中有效。如果被方法使用， //那么泛型类的对象明确要操作的具体类型后，所有要操作的类型就已经固定了。 // //为了让不同方法可以操作不同类型，而且类型还不确定。 //那么可以将泛型定义在方法上。 /* 特殊之处： 静态方法不可以访问类上定义的泛型。 如果静态方法操作的应用数据类型不确定，可以将泛型定义在方法上。 */ class Demo<T> { public void show(T t) { System.out.println("show: " + t); } public <Q> void print(Q q) { System.out.println("print: " + q); } public static <W> void method(W w) { System.out.println("method: " + w); } } public class GenericDemo4 { public static void main(String[] args) { Demo<String> d = new Demo<String>(); d.show("hahaha"); d.print("xixi"); d.print(123); Demo.method("lalala"); Demo.method(456); } } //泛型定义在接口上。 interface Inter<T>{ void show(T t); } class InterImpl<T> implements Inter<T>{ public void show(T t){ System.out.println("show: "+t); } } public class GenericDemo5 { public static void main(String[] args) { InterImpl<String> iis = new InterImpl<String>(); iis.show("abcd"); InterImpl<Integer> iii = new InterImpl<Integer>(); iii.show(123); } } import java.util.*; /* ? 通配符。也可以理解为占位符。 泛型的限定； ？ extends E: 可以接收E类型或者E的子类型。上限。 ？ super E: 可以接收E类型或者E的父类型。下限 */ class Person { private String name; Person(String name) { this.name = name; } public String getName() { return name; } } class Student3 extends Person { Student3(String name) { super(name); } } public class GenericDemo6 { public static void main(String[] args) { ArrayList<Person> al = new ArrayList<Person>(); al.add(new Person("张三")); al.add(new Person("张三")); al.add(new Person("李四")); al.add(new Person("王五")); printColl(al); ArrayList<Student3> al1 = new ArrayList<Student3>(); al1.add(new Student3("张三1")); al1.add(new Student3("张三1")); al1.add(new Student3("李四1")); al1.add(new Student3("王五1")); printColl(al1); } // 泛型限制，集合的元素只能是Person及其子类 public static void printColl(Collection<? extends Person> al) { Iterator<? extends Person> it = al.iterator(); while (it.hasNext()) { System.out.println(it.next().getName()); } } } /* 需求： 1. 类关系： |--Person |-- Worker |-- Student 2. 功能：生成一个适用于Person、Worker和Student的比较器, 此时只用指定Person泛型，细品 3. 使用TreeSet存放Person、Worker、Student三个类类对象 */ import java.util.Comparator; import java.util.Iterator; import java.util.TreeSet; class Person01 { private int age; private String name; Person01(String name, int age) { this.name = name; this.age = age; } public String getName() { return name; } public int getAge() { return age; } } class Student01 extends Person01 { Student01(String name, int age) { super(name, age); } } class Worker01 extends Person01 { Worker01(String name, int age) { super(name, age); } } class MyComp implements Comparator<Person01> { public int compare(Person01 p1, Person01 p2) { int num = ((Integer) p1.getAge()).compareTo((Integer) p2.getAge()); if (num == 0) { return p1.getName().compareTo(p2.getName()); } return num; } } class GenericDemo7 { public static void main(String[] args) { TreeSet<Person01> ts1 = new TreeSet<Person01>(new MyComp()); ts1.add(new Person01("张三", 10)); ts1.add(new Person01("张三", 10)); ts1.add(new Person01("李四", 10)); ts1.add(new Person01("王五", 11)); // System.out.println(ts1); show(ts1); TreeSet<Student01> ts2 = new TreeSet<Student01>(new MyComp()); ts2.add(new Student01("张三", 10)); ts2.add(new Student01("张三", 10)); ts2.add(new Student01("李四", 10)); ts2.add(new Student01("王五", 11)); // System.out.println(ts2); show(ts2); TreeSet<Worker01> ts3 = new TreeSet<Worker01>(new MyComp()); ts3.add(new Worker01("张三", 10)); ts3.add(new Worker01("张三", 10)); ts3.add(new Worker01("李四", 10)); ts3.add(new Worker01("王五", 11)); // System.out.println(ts3); show(ts3); } public static void show(TreeSet<? extends Person01> ts) { Iterator<? extends Person01> it = ts.iterator(); while (it.hasNext()) { Person01 p = (Person01) it.next(); System.out.println(p.getAge() + "......" + p.getName()); } System.out.println(); } }