Java基础——集合框架(二)
2015-07-17 12:38
459 查看
Set:
无序,不可重复元素HashSet:数据结构是哈希表,线程是非同步的。
保证元素唯一性的原理:判断元素的hashCode值是否相同
如果相同,还会继续判断元素的equals方法,是否为true
TreeSet:
可以对Set集合中的元素进行排序
底层数据结构式二叉树,
保证元素唯一的依据是:
compareTo方法return 0 。
TreeSet排序的第一种方式:
让元素自身具备比较性
元素需要实现Comparable接口,覆盖compareTo方法
这种方式也称为元素的自然顺序,或者叫做默认顺序
TreeSet的第二种排序方式。
当元素自身不具备比较性时,或者具备的比较性不是所需要的。
这时就需要让集合自身具备比较性。
在集合初始化时,就有了比较方式。
//TreeSet集合简单的存储以及取出演示 import java.util.*; public class TreeSetDemo { public static void sop(Object obj) { System.out.println(obj); } public static void main(String[] args) { TreeSet ts = new TreeSet(); ts.add("aaa"); ts.add("cbc"); ts.add("aac"); ts.add("bde"); for (Iterator it = ts.iterator();it.hasNext() ; ) { sop(it.next()); } } }
运行结果为:
发现TreeSet集合中打印出来的数据不仅无序,而且他会按照自己的规则(ASCII码表顺序)给集合中的元素进行排序。
那么接下来,老规矩,给集合中添加自定义对象呢?
//在TreeSet集合中添加自定义对象 import java.util.*; class Person//定义人这个类 { private String name; private int age; Person(String name,int age) { this.name = name; this.age = age; } public String getName() { return name; } public int getAge() { return age; } } public class TreeSetDemo1 { public static void sop(Object obj) { System.out.println(obj); } public static void main(String[] args) { TreeSet ts = new TreeSet();//创建TreeSet集合对象 ts.add(new Person("zhangsan",12)); ts.add(new Person("lisi",28)); ts.add(new Person("wangwu",17)); ts.add(new Person("zhaoliu",40)); for (Iterator it = ts.iterator(); it.hasNext(); )//用迭代器取出集合中的元素 { Object obj = it.next(); Person p = (Person)obj; sop("姓名= "+p.getName()+"...年龄为..."+p.getAge()); } } }
编译通过,,运行,,
在运行的时候,出现了异常,ClassCastException 原因是,Person can not be cast to Comparable
找到Comparable的详细信息
发现接口中只有一个方法
上边说了那么一大堆,其实简单来说就是:
TreeSet集合会给传进来的对象进行排序,但是传进来的Person类的对象并不具备比较性。TreeSet集合不知道用什么方式来给对象进行排序。
那怎么就有了比较性了呢?
实现Comparable接口。
那怎么定义比较方法呢?
在实现Comparable接口的类中,重写compareTo方法。
将比较规则写在该方法中,调用方的对象比较大于参数方,则返回正整数,否则返回负整数,相同返回0.
代码实现是这样的。
//在TreeSet集合中添加自定义对象 import java.util.*; class Person implements Comparable//此接口强制让Person对象具备比较性 { private String name; private int age; Person(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 Person)) throw new RuntimeException("参数格式不正确"); Person p = (Person)obj; //想按照年龄排序,从小到大的顺序 //如果调用方的属性值大于参数对象的属性值,返回一个正整数。 if (this.age>p.age) return 1; if(this.age==p.age) return 0; return -1; } } public class TreeSetDemo1 { public static void sop(Object obj) { System.out.println(obj); } public static void main(String[] args) { TreeSet ts = new TreeSet();//创建TreeSet集合对象 ts.add(new Person("zhangsan",12)); ts.add(new Person("lisi",28)); ts.add(new Person("wangwu",17)); ts.add(new Person("zhaoliu",40)); for (Iterator it = ts.iterator(); it.hasNext(); )//用迭代器取出集合中的元素 { Object obj = it.next(); Person p = (Person)obj; sop("姓名= "+p.getName()+"...年龄为..."+p.getAge()); } } }
运行结果为:
那么想到当两个人的年龄一样的话,会不会将对象存进来呢?
//在TreeSet集合中添加自定义对象 import java.util.*; class Person implements Comparable//此接口强制让Person对象具备比较性 { private String name; private int age; Person(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 Person)) throw new RuntimeException("参数格式不正确"); Person p = (Person)obj; if (this.age>p.age) return 1; if(this.age==p.age) return 0; return -1; } } public class TreeSetDemo1 { public static void sop(Object obj) { System.out.println(obj); } public static void main(String[] args) { TreeSet ts = new TreeSet(); ts.add(new Person("zhangsan",12)); ts.add(new Person("lisi",28)); ts.add(new Person("wangwu",17)); ts.add(new Person("zhaoliu",40)); ts.add(new Person("zhouqi",40));//两个人年龄一样,但是姓名不一样 for (Iterator it = ts.iterator(); it.hasNext(); ) { Object obj = it.next(); Person p = (Person)obj; sop("姓名= "+p.getName()+"...年龄为..."+p.getAge()); } } }
运行结果:
运行结果显示,那个年龄形同的人没有存进来
解释:每一个被添加进来的对象都会运行compareTo方法和已经在集合中的元素比较一次,如果返回为0,会认为这个对象和集合中的元素是同一个,不进行存储。
解决方法:设置完主要条件要设置次要条件。
假如年龄相同要在判断一次姓名是否相同,
//在TreeSet集合中添加自定义对象 import java.util.*; class Person implements Comparable//此接口强制让Person对象具备比较性 { private String name; private int age; Person(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 Person)) throw new RuntimeException("参数格式不正确"); Person p = (Person)obj; if (this.age>p.age) return 1; if(this.age==p.age) { return this.name.compareTo(p.name); //这里的this.name是String类型的,String类型有自己的比较方法(自然顺序) //因为Sting类实现了Comparable接口,所以字符串具有比较性。 //最后将String类比较完compareTo方法返回的值再返回去。 } return -1; } } public class TreeSetDemo1 { public static void sop(Object obj) { System.out.println(obj); } public static void main(String[] args) { TreeSet ts = new TreeSet(); ts.add(new Person("zhangsan",12)); ts.add(new Person("lisi",28)); ts.add(new Person("wangwu",17)); ts.add(new Person("wangwu",17)); ts.add(new Person("zhaoliu",40)); ts.add(new Person("zhouqi",40));//两个人年龄一样,但是姓名不一样 for (Iterator it = ts.iterator(); it.hasNext(); ) { Object obj = it.next(); Person p = (Person)obj; sop("姓名= "+p.getName()+"...年龄为..."+p.getAge()); } } }
运行结果:
实验结果,年龄相同,姓名不同的两个人,可以存储进来。
年龄相同,姓名相同的人(视为同一个人)存储不进来。
TreeSet中的数据存储方式图:二叉树
根据二叉树的示意图,就了解了TreeSet集合中数据的存储方式,
那么如果我想要将TreeSet集合中的对象按照存进去时候的顺序取出来呢?
只要将复写compareTo方法的内容中只写一句:return 1,
进来一个元素,元素判断时调用compareTo方法,一看返回值为1 ,放在右边
以此类推……….
最后存进去的顺序就和元素存进去的先后顺序一样的了。
那么如果我想要将TreeSet集合中的对象反向的取出来呢?
只要将复写compareTo方法的内容中只写一句:return -1,
进来一个元素,元素判断时调用compareTo方法,一看返回值为-1 ,放在左边
以此类推……….
最后存进去的顺序就是倒着的,取出来的顺序就和存进去的顺序相反了。
自定义比较器
像以上自定义对象存入TreeSet集合中,使用的是给对象强制加了比较性。
但是在实际开发中,已经定义好的Person类的排序方式(先判断年龄,再判断姓名)不是我们想要的。
我们想要的是:先按照姓名排序(主要条件),然后按照年龄排序(次要条件)
但是之前已经给了的Person类的代码不能动(因为我们知道,修改代码是灾难啊)
解决办法就是在集合自身上定义一个比较器:不管你自己的排序方式是什么样的,要进我的集合中,按照我的排序方式来。
如何自定义比较器呢?
自定义类实现Comparator接口,
覆盖里边的int compare(Object o1,Object o2)方法
同样是以return 0 来判断元素是否相同。
示例代码如下:
/* 当对象所具备的比较性不是我们想要的时候 我们需要给集合定义自己的比较器 只要将定义好的比较器作为参数传给TreeSet的构造函数就好了 */ //需求:自定义集合的比较器,让对象按照集合的比较器进行比较并存储 //而不按照对象的比较方式 import java.util.*; //这里定义Person类实现了接口,让Person对象具备比较性 class Person implements Comparable { private String name; private int age; Person(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 Person)) throw new RuntimeException("对象不正确"); Person p = (Person)obj; if (this.age>p.age) return 1; if (this.age==p.age) { return this.name.compareTo(p.name); } return -1; } } //定义比较器 class MyCompare implements Comparator { public int compare(Object o1,Object o2)//形参必须是Obj的,如果不是就不算复写接口中的方法。 { if ((!(o1 instanceof Person)) || (!(o1 instanceof Person)))//如果传入的参数不是Person类的,抛出运行时异常 { throw new RuntimeException("传入的对象不正确"); } //通过if条件了,就执行强转 Person p1 = (Person)o1; Person p2 = (Person)o2; //如果姓名相同,,再比较年龄 if ((p1.getName().compareTo(p2.getName()))==0) { //Integer类中有自己重写过的compareTo方法,这里直接借过来使用 return new Integer(p1.getAge()).compareTo(new Integer(p2.getAge())); } //如果姓名不相同,直接返回字符串之间的自然顺序比较的结果值 return p1.getName().compareTo(p2.getName()); } } public class TreeSetDemo2 { public static void sop(Object obj) { System.out.println(obj); } public static void main(String[] args) { TreeSet ts = new TreeSet(new MyCompare()); ts.add(new Person("java08",34)); ts.add(new Person("java04",24)); ts.add(new Person("java09",43)); ts.add(new Person("java43",12)); ts.add(new Person("java43",25)); ts.add(new Person("java01",39)); ts.add(new Person("java05",39)); //ts.add("java05");//这里抛出运行时异常 for (Iterator it = ts.iterator();it.hasNext() ; ) { Person p = (Person)it.next(); sop(p.getName()+"......"+p.getAge()); } } }
运行结果:正常
运行结果显示:对象按照姓名顺序排序,姓名相同的话,按照年龄排序。
而且,当第一种比较方式(对象类实现Comparable接口)和第二种比较方式(自定义比较器实现Compatator接口)共存的时候,使用的是第二种比较方式。
一个TreeSet集合的小练习:
//需求:TreeSet 中存放字符串对象,要求按照字符长度排序 import java.util.*; class MyCompare implements Comparator { public int compare(Object o1,Object o2) { //对象进来先进行判断 if ((!(o1 instanceof String)) || (!(o1 instanceof String))) throw new RuntimeException("对象不是字符串的对象"); //再进行强转 String s1 = (String)o1; String s2 = (String)o2; //再进行判断(长度) 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 MyCompare()); ts.add("abfdfdc"); ts.add("abcd"); ts.add("abcdf"); ts.add("aaaaa"); ts.add("c"); ts.add("cfd"); for (Iterator it = ts.iterator();it.hasNext() ; ) { System.out.println((String)it.next()); } } }
运行结果为:
运行结果,如果字符串的长度不相等,按照字符串的长度排序
如果字符串的长度相等,按照字符串的自然顺序排序。
记住,compare方法和compareTo方法,返回的都是大于0,小于0,等于0的整数,不是简单的1,0,-1。
泛型
jdk1.5版本以后出现的新特征,用于解决安全问题,是一个类型安全机制。看一个小程序来了解泛型:
//需求:想打印一下存在集合中的字符串对象的长度。 import java.util.*; public class GenericDemo { public static void main(String[] args) { ArrayList al = new ArrayList(); al.add("dsfd"); al.add("cvv"); al.add("eref"); al.add("dfdsd"); for (Iterator it =al.iterator();it.hasNext() ; ) { String s = (String)it.next(); System.out.println(s.length()); } } }
运行结果:
如果我在这个集合中一不小心存储了一个Integer类型的值呢?
//需求:想打印一下存在集合中的字符串对象的长度。 import java.util.*; public class GenericDemo { public static void main(String[] args) { ArrayList al = new ArrayList(); al.add("dsfd"); al.add("cvv"); al.add("eref"); al.add("dfdsd"); al.add(new Integer(4));//添加一个Integer类型的对象 for (Iterator it =al.iterator();it.hasNext() ; ) { String s = (String)it.next(); System.out.println(s.length()); } } }
运行结果显示:
由运行结果可以看到:编译可以通过,但是运行时出了问题,抛出了ClassCastException
Integer类型的对象不能被转换成String类型的。
这种编译时不出现问题,运行时出现问题的程序很危险,
为了让该程序在编译的时候,有什么问题都会显示 出来,也就是为了提高安全性,
在定义集合的时候给他加上一个标识,明确只有什么类型的对象才可以存入到集合中来,
只要是添加了不符合规则的类型对象进来,编译时期就报错
怎么添加标识呢?
这就用到了泛型,给TreeSet集合明确要存的对象类型
代码示例:
//需求:想打印一下存在集合中的字符串对象的长度。 import java.util.*; public class GenericDemo { public static void main(String[] args) { //泛型标识,用<>将集合中要存的对象类型写进来,集合中只可以存这种类型的对象 //如果存进来其他类型的对象,就会报错 ArrayList<String> al = new ArrayList<String>(); al.add("dsfd"); al.add("cvv"); al.add("eref"); al.add("dfdsd"); al.add(new Integer(4));//添加一个Integer类型的对象 //既然存的时候要限定类型,取得时候也要限定类型 //因为Iterator接口接收到的是Object对象, for (Iterator<String> it =al.iterator();it.hasNext() ; ) { //既然在迭代器上已经限定了要存进来的对象,所以取对象的时候就不用进行对象的向下强转了。 String s = it.next(); System.out.println(s.length()); } } }
编译结果:
发现,加上泛型之后,往集合中添加其他类型的对象的时候,在编译时期就出现了错误,可以让程序员发现并进行修改。提高了安全性。
我们重新将代码修改(将添加Integer对象的那一行代码注释),使代码编译能够通过,并且运行。
运行结果:
发现,编译正常通过,而且不再会提示:使用了未经检查的不安全操作了。
泛型的好处:
1,将运行时出现问题ClassCastException转移到了编译时期。
方便程序员解决问题,让运行时期问题减少,安全。
2,避免了强制转换的麻烦。
泛型格式:通过<>来定义要操作的引用数据类型。
在使用java中提供的对象时,什么时候写泛型呢?
通常在集合框架中很常见,
只要见到<>就要定义泛型
其实<>就是用来接收类型的。
当使用集合时,将集合中要存储的数据类型作为参数传递到<>中即可。
一个泛型在集合中比较器里边的应用:
/* 泛型在集合比较器中的应用 */ //需求:在集合中存入字符串对象,要求按照长度从长到短排序,用泛型类加强安全措施 import java.util.*; class MyCompare implements Comparator<String>//Comparator接口也要定义泛型类 { public int compare(String s1,String s2)//接口标识了泛型类,这里就不用再进行强转,进来的元素都是String类型的 { //按照长度从长到短的顺序,只要将先后传进来的对象的比较顺序进行调换就可以了。 int num = new Integer(s2.length()).compareTo(new Integer(s1.length())); if (num==0) return s2.compareTo(s1); return num; } } public class GenericDemo2 { public static void main(String[] args) { TreeSet<String> ts = new TreeSet<String>(new MyCompare()); ts.add("gfdgd"); ts.add("aaa"); ts.add("dcf"); ts.add("fdsfewwef"); ts.add("cv"); for (Iterator<String> it = ts.iterator();it.hasNext() ; ) { String s = it.next(); System.out.println(s); } } }
运行结果为:
运行结果显示,按照字符串从长到短的顺序进行排列的。
练习二:自定义具有泛型限制的工具类
前后作为对比:
没有泛型的时候是这样的:
/* 定义一个工具类,能够调用被创建出来的对象, */ import java.util.*; class Person { } class UtilClass//创建一个工具类 { private Person p; public void set(Person p)//set方法创建一个Person对象 { this.p = p; } public Person get()//get方法返回一个Person对象 { return p; } } public class GenericDemo3 { public static void main(String[] args) { UtilClass u = new UtilClass(); u.set(new Person()); Person p = (Person)u.get(); } }
这样的代码,可以执行也可以运行,
但是不止一个类需要有这样的工具,当其他类调用这样的工具的时候,
还要重新创建该工具类,设置参数类,这样的话不能提高代码的复用性,也降低了该工具程序的扩展性。
于是,我们将代码变成了这样:
/* 定义一个工具类,能够调用被创建出来的对象,使用泛型,让该方法可以被多个类调用 */ import java.util.*; class Person { } class Student { } class UtilClass { private Object obj; public void setObject(Object obj) { this.obj = obj; } public Object getObject() { return obj; } } public class GenericDemo3 { public static void main(String[] args) { UtilClass u = new UtilClass(); u.setObject(new Person());//在这里Person类会被提升为Object类 //这里要将提升到Object类型的对象进行强制向下转型 Person p = (Person)u.getObject(); } }
这样也可以,但是,当我在主函数中的setObject方法中new了一个Student对象,
u.setObject(new Student());
编译也能通过(因为setObject方法接收的参数是Object类型的)
但是运行时出了问题,
运行结果如图所示,编译能通过,但是运行时抛出来类型转换异常,因为到强制向下转型的时候不能将原本Student类型的对象转换成Person对象。
这种编译可以通过,但是运行出问题的方式是不可取的。
这种办法行不通,但是怎么样才可以提高代码的复用性,而且还能提高程序的扩展性呢?
这就用到了自定义泛型工具类
/* 定义一个工具类,能够调用被创建出来的对象,使用泛型,让该方法可以被多个类调用 */ import java.util.*; class Person { } class Student { } class UtilClass<T>//这里标识一个类型形式参数 { private T t;//里边的类型,变量全是参数值 public void setObject(T t) { this.t = t; } public T getObject() { return t; } } public class GenericDemo3 { public static void main(String[] args) { //在定义工具类的时候就要加泛型以约束 UtilClass<Person> u = new UtilClass<Person>(); //这里new对象作为参数 u.setObject(new Person()); //在这里就不用进行强转了。 Person p = u.getObject(); } }
运行结果正常,
如果我们在倒数第二行new错了对象
u.setObject(new Student());
在编译时期就会报错,提醒程序员修改代码,这样提高了安全性。
将泛型定义在方法上
在以上的示例中,我们将泛型定义在类上,泛型在全类中有效。
看以下代码:
/*演示将泛型添加在方法上*/ class Demo<T> { public void show(T t) { System.out.println("show.."+t); } public void print(T t) { System.out.println("print.."+t); } } public class GenericDemo4 { public static void main(String[] args) { Demo<String> d = new Demo<String>(); d.show("hahah"); d.print("hehe"); Demo<Integer> d1 = new Demo<Integer>(); d1.show(new Integer(7)); d1.print(4);//这里会自动装箱操作 } }
运行结果:
但是想要只new一个对象,然后用着一个对象打印多个类型的数据呢?
这就用到了泛型方法:
/*演示将泛型添加在方法上*/ class Demo { public<T> void show(T t)//在返回值类型前边添加类型参数 { System.out.println("show.."+t); } public<T> void print(T t) { System.out.println("print.."+t); } } public class GenericDemo4 { public static void main(String[] args) { Demo d = new Demo(); d.show("haha"); d.show(new Integer(7)); d.show(9); } }
运行结果:
泛型类定义的泛型,在整个类中有效,如果被方法调用
那么泛型类的对象明确要操作的具体类型后,所有要操作的类型就已经固定了。
为了让不同的方法可以操作不同类型,而且类型还不确定
那么可以将泛型定义在方法上
特殊之处:
静态方法不可以访问类上定义的泛型
如果静态 方法操作的应用数据类型不确定,可以将泛型定义在方法上。
为什么静态方法不可以访问类上定义的泛型呢?
看下面的代码:
/*演示将泛型添加在静态方法上*/ class Demo<T> { public<T> void show(T t)//该方法直接用的是类中的泛型,只能操作类上的泛型定义的数据 { System.out.println("show.."+t); } public<Q> void print(Q q)//该方法用的是自己方法上的泛型,可以存在,可以操作多种类型的数据 { System.out.println("print.."+q); } /* 这个编译会失败,因为静态方法优先于对象存在,而方法中的泛型参数T,要等到new了对象才可以确定。 public static void method(T t) { System.out.println("method.."+t); } */ //那么静态方法上的泛型应该怎么定义呢? //泛型写在修饰符后边,返回值类型前边 public static<W> void method(W w) { System.out.println("method.."+w); } } public class GenericDemo4 { public static void main(String[] args) { Demo.method("hahahahahah"); Demo.method(new Integer(7)); } }
运行结果:
泛型定义在接口上
//泛型定义在接口上 /* 这是第一种方法,当类实现了接口之后,明确自己要对什么样的数据进行操作 interface Inter<T> { public void show(T t); } class IntImpl implements Inter<String>//在实现的接口上写上类参数 { public void show(String t) { System.out.println(t); } } public class GrnericDemo5 { public static void main(String[] args) { IntImpl i = new IntImpl();//new对象的时候就不用写泛型了,因为接口已经确定了泛性 i.show("nihao"); } } */ //第二种方法,类实现了接口,但是要用什么泛型还不确定 interface Inter<T> { public void show(T t); } class IntImpl<T> implements Inter<T>//类也和接口用一样的泛型 { public void show(T t) { System.out.println(t); } } public class GrnericDemo5 { public static void main(String[] args) { IntImpl<String> i = new IntImpl<String>();//new对象的时候需要写泛型了,因为接口还没有确定泛性 i.show("nihao"); IntImpl<Integer> j = new IntImpl<Integer>(); j.show(4); } }
运行结果:
泛型限定
//泛型限定 //要用一个迭代器取出同一种集合中(ArrayList),两个集合(al,al1)的元素,两个集合的对象类型不一样(Ingeter,String)。 import java.util.*; public 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(3); al1.add(5); al1.add(6); printColl(al); printColl(al1); } public static <T>void printColl(ArrayList<T> al)//静态泛型限定,记得在返回值前边加泛型限定 { for (Iterator<T> it = al.iterator();it.hasNext() ; ) { T t = it.next(); System.out.println(t); } } /* printColl方法也可以这样写 public static void printColl(ArrayList<?> al)//不确定什么类型的限定,所以用一个?(占位符) { for (Iterator<?> it = al.iterator();it.hasNext() ; ) { System.out.println(it.next()); } } */ }
运行结果为:
?通配符:也可以理解为占位符
泛型的限定:
?extends E :可以接收E类型或者E的子类型。上限
? super E :可以接收E类型或者E的父类型,下限
通过代码巩固一下:
//泛型限定 //需求:有Person类和Student类 //Student类继承了Person类 //将两个对象分别装进两个集合中, //用一个方法将两个集合中的元素全取出来。 import java.util.*; 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); } } public class GenericDemo6{ public static void main(String[] args) { ArrayList<Student> al = new ArrayList<Student>(); al.add(new Student("lisi01")); al.add(new Student("lisi02")); al.add(new Student("lisi03")); ArrayList<Person> al1 = new ArrayList<Person>();//原则,必须前后一致 al1.add(new Person("lisi--01")); al1.add(new Person("lisi--02")); al1.add(new Person("lisi--03")); printColl(al); printColl(al1); } public static void printColl(ArrayList<? extends Person> al)//泛型限定为Person类他的子类。 //也就是说,在这个打印集合元素的方法中,该方法只接收Person和他的子类对象 { for (Iterator<? extends Person> it = al.iterator(); it.hasNext(); )//泛型限定必须上下一致 { System.out.println(it.next().getName()); } } }
运行结果为:
在开发中,还是上限用的比较多一些,
下限使用起来的话,父类会一直延伸到Object类中,而Object类中的方法不是很多,所以总会报出来没有哪个哪个方法。建议使用上限(个人看法)
不管是上限还是下限,都要保证需要进来的元素是泛型类的子类,出于多态的原因,父类可以将子类接收进来。
相关文章推荐
- eclipse快捷键-超实用
- HashMap存储数据赋值javabean简单示例
- Java中static的用法归纳
- Myeclipse集成Maven(图文说明)
- Java通过SMS短信平台实现发短信功能
- JAVA IO学习总结
- 【java设计模式】责任链模式
- 看看
- 浏览图片
- 词典
- 用线程和接口两种方法实现的java秒表
- ThreadPoolExecutor使用介绍
- Java基础—io--自画的框图
- 【Java】利用文件通道的方式改进Java复制单个文件的方法
- Java中的单例模式
- java定时器的使用(Timer)
- CXF开发webservice需要的最少jar包以及CXF 和 Spring集成所需jar包
- eclipse 相同变量高亮显示
- Java中主函数的含义
- [LeetCode][Java] Text Justification