黑马程序员-Java API-day15
来源：互联网 发布：cisco 端口聚合 编辑：程序博客网 时间：2024/05/18 00:40
---------------------- ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ ----------------------
1、集合框架—TreeSet
Set无序，不可以重复元素。
|--HashSet：数据结构式哈希表，县城市非同步的。
保证元素唯一性的原理：判断怨毒的hashcode值是否相同。
如果相同，还会继续判断元素的equals方法，是否为true
|--TreeSet：可以对Set集合中的元素进行排序。
底层数据机构是二叉树，保证元素唯一性的依据：
compareTo方法return 0；
TreeSet排序的第一种方式：让元素自身具备比较性；
元素需要实现Comparable接口，覆盖compareTo方法。
这种方式也称为元素的自然顺序，或者叫做默认顺序。
TreeSet的第二种排序方式。
当元素自身不具备比较性时，或者具备的比较性不是所需要的，
这时就需要让集合自身具备比较性
在集合初始化时，就有了比较方式。
需求：
往TreeSet集合中存储自定义对象学生，想按照学生的年龄进行排序。
记住，排序时，当主要条件相同时，一定要判断一下次要条件。
import java.util.*;class TreeSetDemo{ public static void main(String[] args) { TreeSet ts = new TreeSet(); ts.add(new Student("lisi001",20)); ts.add(new Student("lisi009",22)); ts.add(new Student("lisi004",23)); ts.add(new Student("lisi003",23)); ts.add(new Student("lisi007",25)); Iterator it = ts.iterator(); while(it.hasNext()) { //System.out.println(it.next()); Studentstu = (Student)it.next(); 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)) thrownew RuntimeException("不是学生对象"); Student s = (Student)obj; System.out.println(this.name+"..compareTo..."+s.name); if(this.age > s.age) return1; if(this.age==s.age) { returnthis.name.compareTo(s.name); } return -1; } public String getName() { return name; } public int getAge() { return age; }}2、集合框架—二叉树
当元素自身不具备比较性，或者具备的比较性不是所需要的，这时需要让容器自身具备比较性。定义了比较器，将比较器对象作为参数传递个TreeSet集合的构造函数。
当两种排序都存在时，以比较器为主。
集合框架—实现Comparator方式排序
定义一个类，实现Comparator接口，覆盖compare方法。
而在Comparable方式排序中，实现的是Comparable接口，覆盖的却是compareTo方法。
import java.util.*;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)) thrownew RuntimeException("非法学生对象"); Student s = (Student)obj; if(this.age>s.age) return1; if(this.age==s.age) { returnthis.name.compareTo(s.name); } return -1; } public String getName() { return name; } public int getAge() { return age; }}class TreeSetDemo1{ public static void main(String[] args) { TreeSet ts = new TreeSet(new MyCompare()); ts.add(new Student("lisi003",20)); ts.add(new Student("lisi005",22)); ts.add(new Student("lisi005",21)); ts.add(new Student("lisi04",21)); Iterator it = ts.iterator(); while(it.hasNext()) { Student stu = (Student)it.next(); 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 new Integer(s1.getAge()).compareTo(new Integer(s2.getAge())); /* if(s1.getAge()>s2.getAge()) return 1; if(s1.getAge()>s2.getAge()) return 0; return-1; */ } return num; }}练习：按照字符串长度排序。
字符串本身具备比较性。但是他的比较方式不是所需要的，这时就只能使用比较器
import java.util.*;class TreeSetTest{ public static void main(String[] args) { TreeSet ts = new TreeSet(new StrLenCompartor()); ts.add("abcd"); ts.add("cc"); ts.add("cba"); ts.add("aaa"); ts.add("z"); ts.add("hahaha"); Iterator it = ts.iterator(); while(it.hasNext()) { System.out.println(it.next()); } }}class StrLenCompartor implements Comparator{ public int compare(Object o1,Object o2) { String s1 = (String)o1; String s2 = (String)o2; /* if(s1.length()>s2.length()) return1; if(s1.length()==s2.length()) return0; return -1; */ int num = newInteger(s1.length()).compareTo(new Integer(s2.length())); if(num==0) returns1.compareTo(s2); return num; }}3、集合框架—泛型概述
泛型：JDK1.5版本以后出现的新特性，用于解决安全问题，是一个类型安全机制。
好处：
1.将运行时期出现的问题classcastException,转移到了编译时期。
方便于解决问题，让运行时期问题减少，安全。
2.避免了强制转换麻烦。
泛型格式：通过<>来定义要操作的引用数据类型。
在使用java提供的对象时，什么时候写泛型呢？
通常在集合框架中很常见，只要见到<>就要定义泛型。
其实<>就是用来接收类型的。
当使用集合时，将集合中药存储的数据类型作为参数传递到<>即可。
import java.util.*;class GenericDemo{ public static void main(String[] args) { ArrayList<String> al = newArrayList<String>();//定义一个容器，容器类型是String类型 al.add("abc01"); al.add("abc0991"); al.add("abc014"); //al.add(4);//al.add(new Intege(4)); Iterator<String> it =al.iterator();//由于迭代的过程中，数据会存储到迭代器中，因此迭代的时候需要将迭代器的类型也添加泛型<String> while(it.hasNext()) { Strings = it.next(); System.out.println(s+":"+s.length()); } }}import java.util.*;class GenericDemo2{ public static void main(String[] args) { TreeSet<String> ts = newTreeSet<String>(new StrLenComparator()); ts.add("abcd"); ts.add("cc"); ts.add("cba"); ts.add("aaa"); ts.add("z"); ts.add("haha"); Iterator<String> it =ts.iterator(); while(it.hasNext()) { Strings = it.next(); System.out.println(s); } }} class StrLenComparator implementsComparator<String>{ public int compare(String o1,String o2) { int num = new Integer(o1.length()).compareTo(o2.length()); if(num==0) returno1.compareTo(o2); return num; }}4、集合框架—泛型类
import java.util.*;class Student{}class Worker{} //泛型前class Tool{ private Object obj; public void setObject(Object obj) { this.obj = obj; } public Object getObject() { return obj; }}//泛型类
什么时候定义泛型类？
当类中药操作的引用数据类型不确定的时候，早期定义Object来完成扩展，现在定义泛型来完成扩展。
class Utils<QQ>{ private QQ q; public void setObject(QQ q) { this.q = q; } public QQ getObject() { return q; }}
class GenericDemo3{ public static void main(String[] args) { Utils<Worker> u = newUtils<Worker>(); u.setObject(new Worker()); Worker w = u.getObject(); /* Tool t = new Tool(); t.setObject(new Worker); Worker w = (Worker)t.getObject(); */ }}5、集合框架—泛型方法
泛型类定义的泛型，在整个类中有效，如果被方法使用，
那么泛型类的对象明确要操作的具体类型后，所有要操作的类型就已经固定了。
为了让不同方法可以操作不同类型，而且类型还不确定。
那么可以讲泛型定义在方法上。
特殊之处：
静态方法不可以访问类上定义的泛型。
如果静态方法操作的引用数据类型不确定，可以将泛型定义在方法上。
泛型只能放在返回值类型的前面，修饰符类型的后面
//泛型定义在类上class Demo<T>{ public void show(T t) { System.out.println("show: "+t); } public void print(T t) { System.out.println("print:"+t); }}//泛型定义在方法上class Demo{ public <T> void show(T t) { System.out.println("show :"+t); } public <T> void print(T t) { System.out.println("print:"+t); }}class GenericDemo4{ public static void main(String[] args) { Demo d = new Demo(); d.show("haha"); d.show(new Integer(4)); d.print("heihei"); /* Demo<String> d = newDemo<String>(); d.show("haha"); d.print("hehhe"); */ }}//泛型定义在接口上interface Inter<T>{ voidshow(T t);}/*class InterImpl implementsInter<String>{ public void show(String s) { System.out.println("show :"+s); }}*/class InterImpl<T> implementsInter<T>{ public void show(T t) { System.out.println("show :"+t); }}class GenericDemo5{ public static void main(String[] args) { InterImpl<Integer> i = newInterImpl<Integer>(); i.show(4); /* InterImpl i = new InterImpl(); i.show("haha"); */ }}注意：当泛型定义在方法上时，一定要将定义的泛型放在返回值前面，否则编译出错。
6、集合框架—泛型限定
? 通配符。也可以理解为占位符。
泛型的限定：
? extends E:可以接收E类型或者E的子类型，上限。
? super E:可以接收E类型或者E的父类型，下限。
代码演示1：
import java.util.*;class GenericDemo6{ public static void main(String[] args) { ArrayList<String> al = new ArrayList<String>(); al.add("abc1"); al.add("abc2"); al.add("abc3"); ArrayList<Integer> al1 = new ArrayList<Integer>(); al1.add(4); al1.add(6); al1.add(0); printColl(al); printColl(al1); } public static void printColl(ArrayList<?> al)//ArrayList al = newArrayList<Integer>;error { Iterator<?> it = al.iterator(); while(it.hasNext()) { System.out.println(it.next()); } }}代码演示2：
import java.util.*;class GenericDemo7{ public static void main(String[] args) { TreeSet<Student> ts = newTreeSet<Student>(new Comp()); ts.add(new Student("abc03")); ts.add(new Student("abc02")); ts.add(new Student("abc06")); ts.add(new Student("abc01")); Iterator it = ts.iterator(); while(it.hasNext()) { System.out.println(it.next()); } TreeSet<Worker> ts1 = newTreeSet<Worker>(new Comp()); ts1.add(newWorker("wabc--03")); ts1.add(newWorker("wabc--02")); ts1.add(newWorker("wabc--06")); ts1.add(newWorker("wabc--01")); Iterator it1 = ts1.iterator(); while(it1.hasNext()) { System.out.println(it1.next()); } }}class Comp implementsComparator<Person>//这里我们可以直接将比较器的泛型定义成Student和Worker的父类即Person，这样就扩展了泛型的限定{ public int compare(Person p1,Person p2) { returnp2.getName().compareTo(p1.getName()); }} class Person{ private String name; Person(Stringname) { this.name = name; } public String getName() { return name; } public String toString() { return "person :"+name; }}class Student extends Person{ Student(Stringname) { super(name); }}class Worker extends Person{ Worker(Stringname) { super(name); }}小结：泛型限定是用于泛型扩展用的。
---------------------- ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ ----------------------
详细请查看：http://edu.csdn.net
- 黑马程序员-Java API-day15
- 黑马程序员-day15-泛型
- 黑马程序员_java基础day15
- 黑马程序员-day15集合框架
- 黑马程序员--java api
- 黑马程序员---Java API
- 黑马程序员-java API
- 黑马程序员——day15泛型
- 黑马程序员-day15-集合框架(泛型)
- 黑马程序员-----java中你必须掌握的线程技术一DAY15总结
- 黑马程序员 Java常用API
- 黑马程序员：JAVA反射API
- 黑马程序员_ java API
- 黑马程序员--JAVA<API>--String
- 黑马程序员-Java API-day13
- 黑马程序员-Java API-day14
- 黑马程序员-Java API-day16
- 黑马程序员-Java API-day17
- android对文件的MD5验证
- 黑马程序员------C#类型
- 自己对编程原则的看法（初识数据结构）
- 有关C语言
- C#代码审查清单
- 黑马程序员-Java API-day15
- ubuntu文件系统和启动流程
- Nginx 源码学习（一） nginx的跟踪与调试
- 内存的动态分配
- 黑马程序员------堆栈
- C# WPF 关闭程序 释放资源
- DG删除备库上的archive log
- HD 1392 Surround the Trees 解题报告
- Winsock编程
