一、集合框架 —— TreeSet
Set: 无序，不可重复 -HashSet: 数据结构是哈希表，线程非同步；保证元素唯一性的原理：判断元素的hasCode值是否相同，如果相同，再判断元素的equals方法是否为true。 -TreeSet: 可以对 Set 集合中的元素进行排序(按自然顺序，ASCII编码表)； 代码：class TreeSetDemo { public static void main(String[] args) { TreeSet ts = new TreeSet(); ts.add("cba"); ts.add("abc"); ts.add("bca"); ts.add("Daa"); Iterator it = ts.iterator(); while(it.hasNext()) System.out.println(it.next()); //结果为： Daa abc bca cba } }
该集合中具备比较性，是因为 String 类已经实现了 Comparable ,复写了 comparaTo() 方法。二、集合框架—— TreeSet 存储自定义对象
需求：
往TreeSet集合中存储自定义对象学生，并按照学生年龄进行排序。
注意：
排序时，当主要条件相同时，一定要判断次要条件。
代码：import java.util.*; class TreeSetDemo11 { public static void main(String[] args) { TreeSet ts = new TreeSet(); ts.add(new Student("lisi02",22)); ts.add(new Student("lisi007",20)); ts.add(new Student("lisi09",19)); ts.add(new Student("lisi01",19)); Iterator it = ts.iterator(); while(it.hasNext()) { Object obj = it.next(); Student stu = (Student)obj; System.out.println(stu.getName()+"...."+stu.getAge()); } } } class Student implements Comparable//该接口强制让学生具备比较性 { private String name; private int age; Student(String name, int age) { this.name = name; this.age = age; } public int compareTo(Object obj) { if(!(obj instanceof Student)) throw new ClassCastException("不是学生对象"); Student s = (Student)obj; System.out.println(this.name+"...compareto..."+s.name); //return this.age-s.age; if(this.age>s.age) return 1; if(this.age==s.age)//当主要条件满足时，判断次要条件 return this.name.compareTo(s.name); return -1; } public String getName() { return name; } public int getAge() { return age; } }三、集合框架——二叉树
-TreeSet: 底层数据结构是二叉树；保证数据元素唯一性的依据: compareTo方法return 0。
TreeSet 排序的第一种方式：
让元素自身具备比较性，元素需要实现 Comparable 接口，覆盖comparaTo()方法。这种方式也称为元素的自然顺序，或者叫默认顺序。
public int compareTo(Object obj)
{
return 1;//按存入顺序排序
//return -1;//按存入的反向顺序排序
}
TreeSet 集合取出元素时，是从小到大取。四、集合框架——实现 Comparator 方式排序
TreeSet 的第二种排序方式。
当元素自身不具备比较性时，或者具备的比较性并非所需。这时就需要让集合自身具备比较性(让集合在初始化时，就具备比较性)。参阅构造函数。
方式二：
定义一个类，实现 Comparator 接口，覆盖compare()方法。
当两种排序都存在时，以比较器为主。
代码：import java.util.*; class TreeSetDemo2 { public static void main(String[] args) { TreeSet ts = new TreeSet(new MyCompare()); ts.add(new Student("lisi02",22)); ts.add(new Student("lisi007",20)); ts.add(new Student("lisi09",19)); ts.add(new Student("lisi09",25)); Iterator it = ts.iterator(); while(it.hasNext()) { Object obj = it.next(); Student stu = (Student)obj; System.out.println(stu.getName()+"...."+stu.getAge()); } } } class MyCompare implements Comparator { public int compare(Object o1, Object o2) { Student s1 = (Student)o1; Student s2 = (Student)o2; int num = s1.getName().compareTo(s2.getName()); if(num==0) //return s1.getAge()-s2.getAge(); return new Integer(s1.getAge()).compareTo(new Integer(s2.getAge())); return num; } } class Student implements Comparable { private String name; private int age; Student(String name, int age) { this.name = name; this.age = age; } public int compareTo(Object obj) { if(!(obj instanceof Student)) throw new ClassCastException("不是学生对象"); Student s = (Student)obj; //System.out.println(this.name+"...compareto..."+s.name); if(this.age>s.age) return 1; if(this.age==s.age)//当主要条件满足时，判断次要条件 return this.name.compareTo(s.name); return -1; } public String getName() { return name; } public int getAge() { return age; } }五、集合框架 —— TreeSet 练习
练习：按照字符串长度排序
思路：
1、字符串本身实现了Comparable，复写了compareTo()方法；但是该方法是按自然顺序排序的，不符合本题要求。
2、自定义一个比较器，按字符串长度排序；当两种排序都存在时，以比较器为主。
3、自定义比较器实现Comparator，复写compare()方法。
4、复写compare方法时，如果主要条件相同，则需要判断次要条件。
代码：import java.util.*; class TreeSetTest1 { public static void main(String[] args) { TreeSet ts = new TreeSet(new StringLengthComparator()); ts.add("abcd"); ts.add("eb"); ts.add("abc"); ts.add("c"); ts.add("aaa"); Iterator it = ts.iterator(); while (it.hasNext()) { System.out.println(it.next()); } } } //自定义比较器 class StringLengthComparator implements Comparator { public int compare(Object o1, Object o2) { String s1 = (String)o1; String s2 = (String)o2; int num = new Integer(s1.length()).compareTo(new Integer(s2.length())); //int num = s1.length() - s2.length(); if(num==0)//当主要条件满足时，判断次要条件 return s1.compareTo(s2); return num; } }六、集合框架——泛型概述
泛型：JDK1.5版本后出现的新特性，用于解决安全问题，是一个安全机制。
好处：
1、将运行时期出现问题 ClassCastException, 转移到了编译时期；方便程序员解决问题，让运行时期问题减少。
2、避免了强制转换的麻烦。
代码：import java.util.*; class GenericDemo1 { public static void main(String[] args) { ArrayList<String> al = new ArrayList<String>();//明确集合中元素的类型。 al.add("abc01"); al.add("abc0021"); al.add("abaddfc01"); //al.add(4); Iterator<String> it = al.iterator();//明确迭代器接收的元素类型。 while (it.hasNext()) { String s = it.next(); System.out.println(s+": "+s.length()); } } }七、集合框架——泛型使用
泛型格式：通过<>来定义要操作的引用数据类型。
在使用java提供的对象时，什么时候使用泛型呢？
通常在集合框架中很常见，只要见到<>就要定义泛型。
其实<>就是用来接收类型的。
当使用集合时，将集合中要存储的数据类型作为参数传递到<>中即可。
自定义一个对象需要做如下几步；
1、复写hashCode()方法；
2、复写equals()方法；
3、实现 Comparable 接口，复写该接口的compareTo()方法。
这样就既可以放到 HashSet 集合中，又可以放到 TreeSet 集合中。
代码：import java.util.*; class GenericDemo2 { public static void main(String[] args) { TreeSet<String> ts = new TreeSet<String>(new LenComparator()); ts.add("abcd"); ts.add("cba"); ts.add("aaa"); ts.add("ab"); Iterator<String> it = ts.iterator(); while (it.hasNext()) { String s = it.next(); System.out.println(s+": "+s.length()); } } } class LenComparator implements Comparator<String> { public int compare(String s1, String s2) { int num = new Integer(s1.length()).compareTo(new Integer(s2.length())); //int num = s1.length()-s2.length(); if(num==0) return s1.compareTo(s2); return num; } }八、集合框架——泛型类
什么时候定义泛型类？
当类中要操作的引用数据类型不确定时，早期定义 Object 来完成扩展，现在定义泛型来完成扩展。
早期代码：class Worker { } class Student { } class Tool { //不定义泛型时，定义Object类，可以接收任意类型的对象。 private Object obj; public void setObject(Object obj) { this.obj = obj; } public Worker getObject() { return obj; } } class Demo { public static void main(String[] args) { Tool t = new Tool(); //t.setObject(new Worker()); t.setObject(new Student());//如果传入的是学生，编译时OK，运行时才会出现问题。 Worker w = (Worker)t.getObject(); } }
使用泛型后可以将运行时产生的问题转移到了编译时期；
示例代码：class Worker { } class Student { } class Utils<QQ>//类上定义泛型QQ { private QQ q; public void setObject(QQ q) { this.q = q; } public Person getObject() { return q; } } class GenericDemo3 { public static void main(String[] args) { //指定泛型类型为Worker Utils<Worker> u = new Utils<Worker>(); u.setObject(new Worker()); //u.setObject(new Student());//如果传入的是Student,编译失败 Worker w = u.getObject(); } }九、集合框架——泛型方法
泛型类定义的泛型，在整个类中有效；泛型类的对象在明确要操作的具体类型后，所有要操作的类型就已经固定了。
为了让不同方法可以操作不同类型，而且类型还不确定，那么可以将泛型定义在方法上。
代码：class GenericDemo4 { public static void main(String[] args) { //Demo<String> d = new Demo<String>(); Demo d = new Demo(); d.show("haha"); d.print(44); } } class Demo//<T> 类上不定义泛型 { public <T> void show(T t) { System.out.println("show: "+t); } public <T> void print(T t) { System.out.println("print: "+t); } }十、集合框架——静态方法泛型
静态方法，不可以访问在类上定义的泛型。
如果静态方法要操作的引用数据类型不确定，可以将泛型定义在方法上。
注意：
泛型定义在方法上，要放在返回值类型的前面（修饰符的后面）。
示例代码：class Demo<Q> { public <T> void show(T t) { System.out.println("show: "+t); } public static <T> void print(T t) { System.out.println("print--: "+t); } //静态方法不可以访问在类上定义的泛型。 public /*static不可以使用*/ void method(Q q) { System.out.println("method: "+q); } } class GenericDemo5 { public static void main(String[] args) { Demo<String> d = new Demo<String>(); d.show("haha"); d.print(44); d.method("java"); } }十一、集合框架——泛型接口
泛型可以定义在类上，可以定义在方法上；泛型还可以定义在接口上。
例如：interface Inter<T>//该接口定义了泛型<T> { void show(T t); } /*泛型定义方式一：该类在实现接口的同时，明确了该接口定义的泛型类型 class InterImpl implements Inter<String> { public void show(String t) { System.out.println("show: "+t); } } */ class InterImpl<T> implements Inter<T> {//该类实现接口时也不明确泛型类型，让具体对象去明确。 public void show(T t) { System.out.println("show: "+t); } } class GenericDemo6 { public static void main(String[] args) { /*泛型定义方式一： InterImpl i = new InterImpl(); i.show("haha"); */ //具体对象明确泛型 InterImpl<Integer> i = new InterImpl<Integer>(); i.show(123); } }十二、集合框架——泛型限定
1、注意：
class Student extends Person
ArrayList<Person> al = new ArrayList<Student>(); //error
集合左右两边定义的泛型必须相等。
2、在JDK1.5版本以后加入了泛型的概念，Collection后面都带了<>；
所以，当<>中的类型不确定时，可以用 ? 来替代泛型。
例如：boolean containsAll(Collection<?> c) 。
? 通配符，也可以理解为占位符。
当然，? 通配符也可以通过定义泛型来替代；不同在于定义泛型可以后可以使用该泛型定义。
参阅 ? 通配符示例代码。
3、泛型限定：
? extends E: 可以接收 E类型或者 E的子类型，上限限定；
? super E: 可以接收 E类型或者 E的父类型，下限限定。
4、上限限定示例：
如果 ArrayList<E> al = new ArrayList<E>(); //ArrayList限定类型E
那么 al.addAll(Collection<? extends E> c); //addAll方法可以接收E类型或者E的子类型。
5、下限限定示例：
如果 TreeSet<E> //TreeSet限定类型E
那么 TreeSet(Comparator<? super E> comparator)//Comparator可以定义E类型或者E的父类型，TreeSet都可以接收。
6、下限限定示例代码(完整代码请看下一节)：class Student extends Person {} class Comp implements Comparator<Person>//这里泛型定义的是Person { public int compare(Person s1, Person s2) { return s1.getName().compareTo(s2.getName()); } } class GenericDemo7 { public static void main(String[] args) { TreeSet<Student> ts = new TreeSet<Student>(new Comp()); //这里集合定义的泛型是Student，比较器可以接收Student或者其父类Person ts.add(new Student("zhangsan")); ts.add(new Student("lisi")); ts.add(new Student("wangwu")); System.out.println(ts); } }
7、上限限定示例代码：import java.util.*; class GenericDemo8 { public static void main(String[] args) { ArrayList<Person> al = new ArrayList<Person>(); al.add(new Person("person01")); al.add(new Person("person02")); al.add(new Person("person03")); ArrayList<Student> al1 = new ArrayList<Student>(); al1.add(new Student("student01")); al1.add(new Student("student02")); al1.add(new Student("student03")); printColl(al); printColl(al1); } public static void printColl(ArrayList<? extends Person> al) { Iterator<? extends Person> it = al.iterator(); while(it.hasNext()) { System.out.println(it.next().getName()); } } } class Person { private String name; Person(String name) { this.name = name; } public String getName() { return name; } } class Student extends Person { Student(String name) { super(name); } }
8、 ?占位符示例代码：import java.util.*; class GenericDemo9 { public static void main(String[] args) { ArrayList<String> al = new ArrayList<String>(); al.add("abc1"); al.add("abc2"); al.add("abc3"); ArrayList<Integer> al2 = new ArrayList<Integer>(); al2.add(4); al2.add(5); al2.add(8); printColl(al); printColl(al2); } public static void printColl(ArrayList<?> al)//当对象不确定时，用通配符?来表示，有占位作用 //也可以在函数上定义类型，如在函数上的void前定义<T> //public static <T> void printColl(ArrayList<T> al) { Iterator<?> it = al.iterator(); while (it.hasNext()) { //如果是定义了泛型<T>，那么这里可以使用该泛型 //T t = it.next(); System.out.println(it.next()); } } }
9、注意：当Student继承Person，Student实现Comparable时，<>内的泛型可以定义为Student,也可以定义为Person。
因为Person既可以接收Person，又可以接收Student。class Student extends Person implements Comparable<Person>//这里可以定义<? extends Student> { public int compareTo(Person s)// Person = new Student();是ok的。 { return num = this.getName().compareTo(s.getName()); } }十二、集合框架——泛型限定2
泛型限定理顺代码(请仔细阅读代码中注释)：import java.util.*; class GenericDemo10 { public static void main(String[] args) { TreeSet<Student> ts = new TreeSet<Student>(new Comp()); //这里集合定义的泛型是Student，但是可以接收定义了泛型Student或者其父类Person的比较器 ts.add(new Student("stu011")); ts.add(new Student("stu002")); ts.add(new Student("stu003")); TreeSet<Worker> ts1 = new TreeSet<Worker>(new Comp()); //这里集合定义的泛型是Worker，但是可以接收定义了泛型Worker或者其父类Person的比较器 ts1.add(new Worker("worker25")); ts1.add(new Worker("worker11")); ts1.add(new Worker("worker37")); printColl(ts); printColl(ts1); } //泛型是用于指定具体类型的；如果只指定一个泛型Person后，该方法就只能接收Person。 //加入了泛型限定<? extends Person>后，就可以接收Person或者其子类类型。 public static void printColl(TreeSet<? extends Person> ts) { Iterator<? extends Person> it = ts.iterator(); while(it.hasNext()) System.out.println(it.next().getName()); } } class Comp implements Comparator<Person>//这里泛型定义的是Person { public int compare(Person p1, Person p2) { return p1.getName().compareTo(p2.getName()); } } class Person { private String name; Person(String name) { this.name = name; } public String getName() { return name; } public String toString() { return "person: "+name; } } class Student extends Person { Student(String name) { super(name); } } class Worker extends Person { Worker(String name) { super(name); } }
562
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
