黑马程序员-学习日记9（集合框架 3 ） .
-------android培训、java培训、期待与您交流！ ----------
/*
Collection ：集合是可变长度的！！！
|--List:元素是有序的，元素可以重复，因为该集合体系有索引。
|--ArrayList:底层的数据结构使用的是数组结构。特点：查询速度很快，但增删稍慢，是线程不同步的效率高，默认数据长度为10，当超过长度为10的元素后，再往里增加的话，它会买new一个新的数组长度为原来的50%延长把原来数组的元素copy到新数组中来再把新元素增加到后面去。判断元素是否存在及删除元素，只依赖equals。原因在于数据结构不同，方法不同。而HashSet先依赖HashCode后依赖equals.
|--LinkedList:底层使用的链表数据结构，特点：增删速度很快，查询稍慢。
|--Vector:底层是数组数据结构。和ArrayList功能一模一样,是线程同步的，判锁，无论增删查都慢，被ArrayList替代了。
|--Set:元素是无序的（存入和取出不一至），元素不可以重复
Set集合的功能和Collection是一致的。
|--HashSet:底层数据结构是哈希表。哈希表是按照哈希值来存的，所以存入和取出时不一致。（因为每个字符串都有一个地址值，是按地址值存入的，，是线程非同步的。
//HashSet是如何保证元素唯一性呢？是通过元素的两个方法，hashCode和equals来完成的，如果元素的HashCode值相同，才会判断equals是否为true
//如果元素的hashCode值不同，不会调用equals方法。 所以当我们在自定义对象时，通常要覆写HashCode和equals方法。这两个方法是系统底层自己调用的。
//对于判断元素是否存在，及删除等操作，依赖的方法是元素的hashcode和equals方法。
|--TreeSet:可以对Set集合中的元素进行排序。实现compareble接口 按ASCII码排序。
底层数据结构是二叉树。保证元素唯一性的依据：cpmpareTo方法：retrurn 0; （判断元素是否相同都是以return 0，的方式）
//二叉树默认的取出方式为：从小到大的取。
TreeSet中删除元素或判断元素是否包含走的都是compareTo()方法。
TreeSet排序的第一种方式，让元素自身具备比较性。元素需要实现Comparable接口，覆盖compareTo方法。
它是通过compareTo方法return 0，来保证元素唯一的。
这种方式也称为元素的自然顺序，或者叫做默认顺序。
《排序有两个要素：①让元素自身具备比较性，②让集合具备比较性。
TreeSet的第二种排序方式：当元素自身不具备比较性，或者具备比较性不是所需要的
这时，就需要让集合自身具备比较性。
当元素自身不具备比较性，或者具备的比较性不是所需要的，这时需要让容器自身具备
比较性，定义了比较器，将比较器对象作为参数传递给TreeSet集合的构造函数。
当两种排序都存在时，以比较器为主！！！！！！
定义一个类实现Comparator接口，覆盖compare方法。
都是以return方法来判断是否是同一个元素。
注意Comparable里面是compareTo方法。而Comparator接口中是compare方法。
List:
特有方法，凡是可以操作角标的方法都是该体系特有方法。
为什么Add(),方法返回的是布尔型？当存入一个数据后，
因地址和内容一样是同一个元素，所以返回false.所以
添加失败为假。
往TreeSet集合中存储自定义对象学生。
想按学生的年龄进行排序。
TreeSet的要求是：往里面存的元素必须具备比较性。（实现Comparable接口)
记住：排序时，当主要条件相同时，一定要判断一下次要条件。
import java.util.*;
class VectorDemo{
public static void main(String args[]){
TreeSet ts = new TreeSet();
ts.add(new Student("lisi02",22));
ts.add(new Student("lisi07",20));
ts.add(new Student("lisi09",19));
ts.add(new Student("lisi08",19));
//ts.add(new Student("lisi01",40));
Iterator i = ts.iterator();
while(i.hasNext()){
//System.out.println(i.next());
Student stu = (Student)i.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))
throw new RuntimeException("不是学生对象");
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;
}
}
import java.util.*;
class VectorDemo{
public static void main(String args[]){
TreeSet ts = new TreeSet();
ts.add(new Student("lisi02",22));
ts.add(new Student("lisi07",20));
ts.add(new Student("lisi09",19));
ts.add(new Student("lisi08",19));
//ts.add(new Student("lisi01",40));
Iterator i = ts.iterator();
while(i.hasNext()){
//System.out.println(i.next());
Student stu = (Student)i.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){//不能声明异常。
return 1;
}
public String getName(){
return name;
}
public int getAge(){
return age;
}
}
//////////////////////////
//当两种排序都存在时，以比较器为主。定义一个类，实现Comparator接口，覆盖compare方法。
import java.util.*;
class VectorDemo{
public static void main(String args[]){
TreeSet ts = new TreeSet(new MyCompare());
ts.add(new Student("lisi02",22));
ts.add(new Student("lisi07",20));
ts.add(new Student("lisi09",19));
ts.add(new Student("lisi07",29));
ts.add(new Student("lisi08",18));
//ts.add(new Student("lisi01",40));
Iterator i = ts.iterator();
while(i.hasNext()){
//System.out.println(i.next());
Student stu = (Student)i.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))
throw new RuntimeException("不是学生对象。");
Student stu = (Student)obj;
if(this.age>stu.age)
return 1;
if(this.age==stu.age){
return this.name.compareTo(stu.name);
}
return -1;
}
public String getName(){
return name;
}
public int getAge(){
return age;
}
}
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){
//if(s1.getAge()>s2.getAge())
// return 1;
//if(s1.getAge()==s2.getAge())
// return 0;
//return -1;
return new Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));
}
return num;
}
}
////////////////////////
import java.util.*;
class VectorDemo{
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("lisi007",20));
ts.add(new Student("lisi09",19));
ts.add(new Student("lisi08",19));
//ts.add(new Student("lisi01",40));
Iterator i = ts.iterator();
while(i.hasNext()){
//System.out.println(i.next());
Student stu = (Student)i.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 (s1.getAge()-s2.getAge())>0?1:-1;
//return 0;
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 String getName(){
return name;
}
public int getAge(){
return age;
}
}
练习：按照字符串长度排序。
字符串本身具备比较性，但是它的比较方式不是所需要的。这时就只能使用比较器。
//高效，安全，减化书写。
//泛型：JDK1.5版本以后，出现新特性，用于解决类型安全问题，是一个类型安全机制。
//好处①将运行时出现的问题：ClassCastException，转移到了编译时期。方便于程序员解决问题，让运行问题减少，安全。
// ②避免了强制转换麻烦。
// 泛型格式：通过<>来定义要操作的引用数据类型。
//在使用java提供的对象时，什么时候写泛型呢？通常在集合框架中很觉，只要见到<>就要定义泛型。
//其实<>就是用来接收类型的，当使用集合时，将集合中要存储的数据类型作为参数传递到<>中即可。
//什么时候定义泛型类？当类中要操作的《引用数据类型》（基本类型不行）不确定的时候，早期定义Object来完成扩展，现在定义泛型来完成扩展。
//当泛型定义在方法上时，传什么类型，就操作什么类型。
//泛型类定义的方法，在整个类中有效，如果被方法使用。
//那么泛型类的对象明确要操作的具体类型后，所要操作的类型就已经固定了。
//为了让方法可以操作不同类型，而且类型还不确定，那么可以将泛型定义在方法上。
/特殊之处：
//静态方法不可以访问类上定义的泛型。因为类先加载，对象后创建。
//如果静态方法操作的应用数据类型不确定，可以将泛型定义在方法上。
//泛型在方法上的声明位置为：修饰符的后面，返回值的前面。
//方法上用泛型通配符的好处：①是扩展性强，②不好点是不能使用类型的特有方法，但共有方法可以：toString()。
//集合在初始化时没有指定类型，则存在安全隐患，而数组在定义时就指定好了类型，所以在编译时有提示信息。。
import java.util.*;
class VectorDemo{
public static void main(String args[]){
//int[] arr = new int[3];
//arr[0] = 4;
//arr[1] = 3.5;
//定义了一个容器，它里的类型是String类型。
ArrayList<String> a1 = new ArrayList<String>();
a1.add("abc01");
a1.add("abc0991");
a1.add("abc014");
//a1.add(4);//a1.add(new Integer(4))两种方法都行，因为集合中只能添加对象，不能
//添加基本数据类型，但Integer具备自动拆装箱功能。！！！
Iterator i = a1.iterator();
while(i.hasNext()){
String s = (String)i.next();//因为用到了子类的特有方法，所以得向下转型。
System.out.println(s+" : "+s.length());
}
}
}
import java.util.*;
class VectorDemo{
public static void main(String args[]){
ArrayList<String> a1 = new ArrayList<String>();
a1.add("abc01");
a1.add("abc0991");
a1.add("abc014");
//a1.add(4);//a1.add(new Integer(4))两种方法都行，因为集合中只能添加对象，不能
//添加基本数据类型，但Integer具备自动拆装箱功能。！！！
//因往里存入不同类型的数据，易产生了运行时类转换异常，所以加入泛型来解决这一安全问题。！！同时也把运行时出现的问题转移到了编译时期，让运行时期安全。
//int型数组，在定义容器时，已明确了类型，，所以只能存入int型值，而集合在初始化时并没有明确类型，所以产生了类型安全问题，所以加入了泛型。
Iterator i = a1.iterator();
while(i.hasNext()){
String s = i.next();//因为用到了子类的特有方法，所以得向下转型。
System.out.println(s+" : "+s.length());
}
}
}
import java.util.*;
class VectorDemo{
public static void main(String args[]){
TreeSet<String> ts = new TreeSet<String>(new LenComparator());
ts.add("abcd");
ts.add("cc");
ts.add("cba");
ts.add("z");
ts.add("hahaha");
Iterator<String> it = ts.iterator();//此处也需要加泛型。
while(it.hasNext()){
String s = it.next();//不用强转了，
System.out.println(s);
}
}
}
class LenComparator implements Comparator<String>{
public int compare(String o1,String o2){
int num = new Integer(o2.length()).compareTo(new Integer(o1.length()));
if(num==0)
return o2.compareTo(o1);//将对象调个位置就可以。
return -num;
}
}
class Tool{
private Worker w;
public void setWorker(Worker w){
this.w = w;
}
public Worker getWorker(){
return w;
}
}
class VectorDemo {
public static void main(String args[]){
Tool t = new Tool();
t.setObject(new Worker());
Worker w = (Worker)t.getObject();
}
}
class Tool{
private Object obj;
public void setObject(Object obj){
this.obj = obj;
}
public Object getObject(){
return obj;
}
}
class Student{
}
class Worker{
}
class Tool{
private Object obj;
public void setObject(Object obj){
this.obj = obj;
}
public Object getObject(){
return obj;
}
}
class VectorDemo {
public static void main(String args[]){
Utils<Worker> u = new Utils<Worker>();
u.setObject(new Worker());//传Student将编译失败。
Worker w = u.getObject();
}
}
class Utils<E>{
private E q;
public void setObject(E q){
this.q = q;
}
public E getObject(){
return q;
}
}
class Student{
}
class Worker{
}
class Utils <QQ>{
private QQ q;
public void setObject(QQ q){
this.q = q;
}
public QQ getObject(){
return q;
}
}
class Demo<T>{
public void show(T t){
System.out.println("show: "+t);
}
public void print(T t){
System.out.println("print:"+t);
}
}
class VectorDemo{
public static void main(String args[]){
Demo<Integer> d = new Demo<Integer>();
d.show(new Integer(4));
d.print(9);
}
}
//什么时候定义泛型类？当类中要操作的引用数据类型(基本数据类型定义不了。)不确定的时候，
//早期定义Object来完成扩展，现在定义泛型来完成扩展。
//泛型类定义的泛型，在整个类中有效，如果被方法使用。
//那么泛型类的对象在明确要操作的具体类型后，所有要操作的类型就已经固定了。
//为了让方法可以操作不同类型，而且类型还不确定，那么可以将泛型定义在方法上。
class Demo{
public <T> void show(T t){
System.out.println("show:"+t);
}
public <Q> void print(Q q){
System.out.println("print:"+q);
}
}
class VectorDemo{
public static void main(String args[]){
Demo d = new Demo();
d.show(new Integer(4));
d.show("new Integer(4)");
d.print("String:");
}
}
//泛型类定义的泛型，在整个类中有效，如果被方法使用，那么泛型
//类的对象明确要操作的具体类型后，所有要操作的类型就已经固定了。
//为了让方法可以操作不同类型的数据，而且类型还不确定，那么可以
//将泛型定义在方法上。
//泛型除了定义在类上，也可以定义在方法上。
//特殊之处：
//静态方法不可以访问类上定义的泛型。
//如果静态方法操作的引用数据类型不确定，可以将泛型定义在（泛型方法）上。
//静态方法上不能定义泛型！！！！！！
class Demo<T>{
public void show(T t){
System.out.println("show : "+t);
}
public void print(T t){
System.out.println("print : "+t);
}
}
class VectorDemo{
public static void main(String args[]){
Demo<Integer> d = Demo<Integer>();
d.show(new Integer(4));
d.print(9);
//当我们new一个对象时，以明确了对象的类型，那么这个
//对象在操作它的方法时，全都是与它相同的类型。
//当泛型一确定里面的方法也是固定的。，对象一建立，要操作的类型也确定了。
//d.print("hahaha");
}
}
//如果就一个对象，即想打印数字又想打印字符串，应怎样做？
//泛型类定义的泛型在整个类中有效，如果被方法使用，那么泛型类的对象明确要操作的具体类型
//后，所有要操作的类型就已经固定了，为了让方法可操作不同类型，而且类型还不确定，那么可以
//将泛型定义在方法上。
class Demo{
public <T> void show(T t){
System.out.println("show : "+t);
}
public <Q> void print(Q q){
System.out.println("print : "+q);
}
}
class VectorDemo{
public static void main(String args[]){
Demo d = new Demo();
d.show("haha");
d.show(new Integer(4));
}
}
//public static <W> void method(W t){//当该方法存在时，T类型的对象还不存在，所以无法访问。
//如果静态方法上操作的应用数据类型不确定，可以将泛型定义在方法上。
// System.out.println("method:"+t);
// }
//此处即有泛型类，又有泛型方法！！！
class Demo<T>{
public void show(T t){//该方法上声明的T 是随着类型走的。
System.out.println(t);
}
public <Q> void print(Q q){
System.out.println("print:"+q);
}
//泛型定义在静态方法上！！！
//public static void method(T t){//当该方法存在时，T类型的对象还不存在，所以无法访问。
//如果静态方法上操作的应用数据类型不确定，可以将泛型定义在方法上。
// System.out.println("method:"+t);
//}
public static <W> void method(W t){//这个是可以 的。
System.out.println("method : "+t);
}
}
class VectorDemo{
public static void main(String args[]){
Demo<String> d = new Demo<String>();
d.show("new Integer(4)");
d.show(new Integer(4));//怎样是不行的，该方法上声明的T 是随着类型走的。
d.print(5);这两个都行！
d.print("hahaa");这两个都行！这个方法传什么类型都行。
Demo.method("hahahaha");
}
}
//泛型定义在接口上！！！！！！！！！！！
//第一种方式：：：：：：：//第一种方式：：：：：：：
interface Inter<T>{
void show(T t);
}
class InterImpl implements Inter<String>{
public void show(String t){
System.out.println("show:"+t);
}
}
class VectorDemo{
public static void main(String args[]){
//InterImpl<Integer> i = new InterImpl<Integer>();
//i.show(4);
InterImpl i = new InterImpl();
i.show("haha");
}
}
//第二种方式：：：：：：：//第二种方式：：：：：：：
interface Inter<T>{
void show(T t);
}
class InterImpl<T> implements Inter<T>{
public void show(T t){
System.out.println("show:"+t);
}
}
class VectorDemo{
public static void main(String args[]){
InterImpl<Integer> i = new InterImpl<Integer>();
i.show(4);
}
}
//泛型的高级应用！！！！//泛型的高级应用！！！！
import java.util.*;
class VectorDemo{
public static void main(String args[]){
ArrayList<String> a1 = new ArrayList<String>();
a1.add("abc1");
a1.add("abc2");
a1.add("abc3");
ArrayList<Integer> a11 = new ArrayList<Integer>();
a11.add(4);
a11.add(7);
a11.add(1);
printColl(a1);
}
public static void printColl(ArrayList<String> a1){//ArrayList<String> a1 = new ArrayList<Integer>();泛型不允许。
Iterator<String>it = a1.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
}
}
import java.util.*;
class VectorDemo{
public static void main(String args[]){
ArrayList<String> a1 = new ArrayList<String>();
a1.add("abc1");
a1.add("abc2");
a1.add("abc3");
ArrayList<Integer> a11 = new ArrayList<Integer>();
a11.add(4);
a11.add(7);
a11.add(1);
printColl(a1);
printColl(a11);
}
public static void printColl(ArrayList<?> a1){//不指定泛型是可以的，但程序不严谨。应加一个<?>占位符。
Iterator<?> it = a1.iterator();//这样就通用了，
while(it.hasNext()){
System.out.println(it.next());
}
}
//public static <T> void printColl(ArrayList<T> a1){//这样也行，区别不是太大
// Iterator<T> it = a1.iterator();//
// while(it.hasNext()){//此处可接收T ，并操作T，//T t = it.next();System.out.println(t);如果成了？就不能接收，因为它类型不明确。
// System.out.println(it.next());//，泛型提高扩展性，但不能使用类型的特有方法。length(),
// }
//}
}
import java.util.*;
class VectorDemo{
public static void main(String args[]){
ArrayList<String> a1 = new ArrayList<String>();
a1.add("abc1");
a1.add("abc2");
a1.add("abc3");
ArrayList<Integer> a11 = new ArrayList<Integer>();
a11.add(4);
a11.add(7);
a11.add(1);
printColl(a1);
printColl(a11);
}
public static void printColl(ArrayList<?> a1){//ArrayList<String> a1 = new ArrayList<Integer>();
Iterator<?> it = a1.iterator();
while(it.hasNext()){
System.out.println(it.next().length());//泛型提高了扩展性，但不允许使用类型特有方法。
}
}
}
import java.util.*;
class VectorDemo{
public static void main(String args[]){
ArrayList<String> a1 = new ArrayList<String>();
a1.add("abc1");
a1.add("abc2");
a1.add("abc3");
ArrayList<Integer> a11 = new ArrayList<Integer>();
a11.add(4);
a11.add(7);
a11.add(1);
printColl(a1);
printColl(a11);
}
public static <T> void printColl(ArrayList<T> a1){//ArrayList<String> a1 = new ArrayList<Integer>();
Iterator<T> it = a1.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
}
}
//只能在静态方法上放泛型，，类中的静态方法不能放泛型。
//？和T 的区别，T代表一种具体的类型，可以接收一个类型，并操作，而用？表不明确类型，可以不能接收。
import java.util.*;
class VectorDemo{
public static void main(String args[]){
ArrayList<String> a1 = new ArrayList<String>();
a1.add("abc1");
a1.add("abc2");
a1.add("abc3");
ArrayList<Integer> a11 = new ArrayList<Integer>();
a11.add(4);
a11.add(7);
a11.add(1);
printColl(a1);
printColl(a11);
}
public static <T> void printColl(ArrayList<T> a1){//ArrayList<String> a1 = new ArrayList<Integer>();
Iterator<T> it = a1.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
}
}
//方法上用泛型通配符的好处：①是扩展性强，②不好点是不能使用类型的特有方法，但共有方法可以：toString()。
import java.util.*;
class VectorDemo{
public static void main(String args[]){
ArrayList<String> a1 = new ArrayList<String>();
a1.add("abc1");
a1.add("abc2");
a1.add("abc3");
ArrayList<Integer> a11 = new ArrayList<Integer>();
a11.add(4);
a11.add(7);
a11.add(1);
printColl(a1);
printColl(a11);
}
public static void printColl(ArrayList<?> a1){//ArrayList<String> a1 = new ArrayList<Integer>();
Iterator<?> it = a1.iterator();
while(it.hasNext()){
System.out.println(it.next().length());
}
}
}
import java.util.*;
class VectorDemo{
public static void main(String args[]){
ArrayList<String> a1 = new ArrayList<String>();
a1.add("abc1");
a1.add("abc2");
a1.add("abc3");
ArrayList<Integer> a11 = new ArrayList<Integer>();
a11.add(4);
a11.add(7);
a11.add(1);
printColl(a1);
printColl(a11);
}
public static void printColl(ArrayList<?> a1){//ArrayList<String> a1 = new ArrayList<Integer>();
Iterator<?> it = a1.iterator();
while(it.hasNext()){
System.out.println(it.next().length());
}
}
}
import java.util.*;
class VectorDemo{
public static void main(String args[]){
ArrayList<Person> a1 = new ArrayList<Person>();
a1.add(new Person("abc1"));
a1.add(new Person("abc2"));
a1.add(new Person("abc3"));
//printColl(a1);
ArrayList<Student> a11 = new ArrayList<Student>();
a11.add(new Student("abc1"));
a11.add(new Student("abc2"));
a11.add(new Student("abc3"));
printColl(a11);//ArrayList<Person> a1 = new ArrayList<Studnet>();怎样不允许，在定义时，声明集合时，
}
public static void printColl(ArrayList<Person> a1){//ArrayList<String> a1 = new ArrayList<Student>();
Iterator<Person> it = a1.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{
public Student(String name){
super(name);
}
}
//泛型限定！！！！！上下限。
//?叫通配符，也可以叫占位符，泛型的限定，？ extends E:
//可以接收E类型或E的子类型，因为继承E，所以上限是限定的！
//? super E:可以接收E类型或E的父类型，这称为下限定。
import java.util.*;
class VectorDemo{
public static void main(String args[]){
ArrayList<Person> a1 = new ArrayList<Person>();
a1.add(new Person("abc1"));
a1.add(new Person("abc2"));
a1.add(new Person("abc3"));
//printColl(a1);
ArrayList<Student> a11 = new ArrayList<Student>();
a11.add(new Student("abc--1"));
a11.add(new Student("abc--2"));
a11.add(new Student("abc--3"));
printColl(a11);
}
public static void printColl(ArrayList<? extends Person> a1){//ArrayList<String> a1 = new ArrayList<Student>();
Iterator<? extends Person> it = a1.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{
public Student(String name){
super(name);
}
}
///////////
class Student implements Comparable<Person>{//<? super E>
public int compareTo(Person s){
this.getName();
}
}
class Comp implements Comparator<Person>{
public int compare(Person s1,Person s2){
return s1.getName().compareTo(s2.getName());
}
}
TreeSet<Student> ts = new TreeSet<Student>(new Comp()));
ts.add(new Student("abc1"));
ts.add(new Student("abc2"));
ts.add(new Student("abc3"));
////////////
import java.util.*;
class VectorDemo{
public static void main(String args[]){
ArrayList<Person> a1 = new ArrayList<Person>();
a1.add(new Person("abc1"));
a1.add(new Person("abc2"));
a1.add(new Person("abc3"));
printColl(a1);
ArrayList<Student> a11 = new ArrayList<Student>();
a11.add(new Student("abc--1"));
a11.add(new Student("abc--2"));
a11.add(new Student("abc--3"));
printColl(a11);
}
public static void printColl(ArrayList<? super Student> a1){//ArrayList<String> a1 = new ArrayList<Student>();
Iterator<? super Student> it = a1.iterator();
while(it.hasNext()){
System.out.println(((Person)it.next()).getName());
}
}
}
class Person{
private String name;
Person(String name){
this.name = name;
}
public String getName(){
return name;
}
}
class Student extends Person{
public Student(String name){
super(name);
}
}
a problem has been detected and windows has been shut down to prevent damage to your computer.
the problem seems to be caused by the following file:subaudio.syspage_fault_in_nonpaged_area
if this is the first time you've seen this stop error screen,restart your computer .if this screen appears again,follow
these steps:
stop:0x00000050(0xe19700000,0x00000001,
import java.util.*;
class VectorDemo{
public static void main(String args[]){
// 此处也可使用匿名内部类。。。。。。。
TreeSet ts = new TreeSet(new StrLenComparator());
ts.add("abcde");
ts.add("cc");
ts.add("cba");
ts.add("hahaha");
ts.add("aaa");
Iterator it = ts.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
}
}
class StrLenComparator implements Comparator{
public int compare(Object o1,Object o2){
String s1 = (String)o1;
String s2 = (String)o2;
//if(s1.length()>s2.length()){
// return 1;
//}
//if(s1.length()==s2.length())
// return 0;
//return -1;
int num = new Integer(s1.length()).compareTo(new Integer(s2.length()));
if(num == 0)
return s1.compareTo(s2);
return num;
}
}
*/
import java.util.*;
class VectorDemo{
public static void main(String args[]){
TreeSet<Student> ts = new TreeSet<Student>(new Com());
ts.add(new Student("abc03"));
ts.add(new Student("abc02"));
ts.add(new Student("abc06"));
ts.add(new Student("abc01"));
for(Iterator<Student> i = ts.iterator();i.hasNext();){
System.out.println(i.next().getName());
}
TreeSet<Worker> ts1 = new TreeSet<Worker>(new Com());
ts1.add(new Worker("wabc03"));
ts1.add(new Worker("wabc02"));
ts1.add(new Worker("wabc06"));
ts1.add(new Worker("wabc01"));
for(Iterator<Worker> i = ts1.iterator();i.hasNext();){
System.out.println(i.next().getName());
}
}
}
class StuCom implements Comparator<Student>{
public int compare(Student s1,Student s2){
return s1.getName().compareTo(s2.getName());
}
}
class WorkCom implements Comparator<Worker>{
public int compare(Worker s1,Worker s2){
return s1.getName().compareTo(s2.getName());
}
}
class Com implements Comparator<Person>{//这里面只能用父类的方法，
public int compare(Person p1,Person p2){
return p2.getName().compareTo(p1.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);
}
}