Collections工具类
java.util.Collection集合操作的工具类,提供单发来操作,方法全部都是静态方法
- static void shuffle( List list)集合元素随机排列
- static void sort(List list)集合中的元素自然排序
- static void sort(List list,Comparator c)比较器 好东西!!!!!
。Comparator是比较器接口,我们需要重写方法 - static 传递什么返回什么 synchronized开头(传递集合)不安全线程变为安全线程
//好东西
public class CollectionsDemo {
public static void main(String[] args) {
List<Person> list=new ArrayList<Person>();
list.add(new Person("a",10) );
list.add(new Person("b",8) );
//list.add(new Person("c",13) );
System.out.println(list);
Collections.sort(list,new myComparator());
}
}
class myComparator implements Comparator<Person>{
public int compare(Person p1,Person p2) {
return p1.getAge()-p2.getAge();
}
}
增强for循环
增强型的for循环,出现在JDK1.5版本
java.lang.Iterable接口,实现这个接口允许对象成为"foreach"语句的目标
谁是接口的实现类:Collection继承接口Iterable
格式:
for(数据类型 变量名 : 集合或者数组){
}
好处:减少代码量
弊端:无索引,不能修改容器中元素的内容
public static void main(String[] args) {
array();
}
public static void array() {
int[]arr= {1,2,3,4,5};
for (int i:arr) {
System.out.println(i);
}
}
增强for循环是个假象,属于编译特效,javac后台编译
for遍历数组: javac编译为传统for形式
for遍历集合:javac编译为迭代器
泛型技术
JDK1.5以后出现的新特性(generic),泛型技术是一种安全机制,保证程序的安全运行,不使用泛型出现的安全问题
public static void main(String[] args) {
List list=new ArrayList();
list.add("a");
list.add("a1");
list.add("a12");
list.add("a2");
list.add(1);
Iterator iterator=list.iterator();
while (iterator.hasNext()) {
Object object=iterator.next();
String string=(String)object;
System.out.println(object);
}
}
泛型的写法格式
类名<容器要存储的数据类型> 变量名=new 类名<容器要存储的数据类型>();
注意:数据类型必须是引用类型,不能是基本类型要写就写包装类 Integer
注意版本:JDK1.7开始,后面的数据类型可以不写new 类名<>();
**作用:如何保证安全性:**强制集合存储指定的数据类型
泛型的好处
- 强制集合存储指定的数据类型
- 安全的问题.由运行时期提前到编译时期
- 避免了数据类型的强制转换
- 锁定了数据类型,for增强的写法
泛型中的E,T,K,V含义
E:Element元素,T:Type 类型,K:key键,V:Value值
实际表现:是一个未知的数据类型而已,等待程序人员指定类型
例子ArrayList
ArrayList<String> al=newArrayList<String>();
源码:public class ArrayList<E>继承父类实现接口....
public boolean add(E e)
泛型类和泛型方法(自定义)
public class Factory<Q> {
private Q q;
/*
* 静态方法,泛型不能和类上的相同
* 静态不能调用非静态的问题
*/
public static <T> void print(T q) {
System.out.println(q);
}
/*
* 方法中使用的泛型,和类上的不同
* 单独定义这个类型
*/
public <T> void printT(T t) {
System.out.println(t);
}
public void printQ(Q q) {
System.out.println(q);
}
public Q getQ() {
return q;
}
public void setQ(Q q) {
this.q = q;
}
}
public static void main(String[] args) {
// TODO Auto-generated method stub
Factory<Integer> fi=new Factory<Integer>();
fi.printQ(123);
Factory<String> fs=new Factory<String>();
fs.printQ("abc");
fi.setQ(1);
fi.getQ();
fi.printT(true);
Factory.print(1.5);
}
接口泛型
public class Demo01 {
public static void main(String[] args) {
InterfaceDemo<String> in= new MyImpl<String>();
in.inter("傻逼");
}
}
public interface InterfaceDemo <E>{
public abstract void inter(E e);
}
//实现类,实现接口,不实现泛型
class MyImpl<E> implements InterfaceDemo<E>{
public void inter(E e) {
System.out.println(e);
}
}
泛型通配符
泛型的通配符是 ? 匹配任何数据类型.泛型使用通配符? ,什么都可以接收I
但是遍历取出的时候,方法next(返回Object类型,不能强制转换
适合于遍历输出
泛型限定
需求:面向对象课程中,曾经完成过-一个例子(抽象类abstract class)公司类:开发部,财务部
定义2个集合,分别存储开发部对象和财务部对象
使用1个方法,同时遍历2个集合,遍历的同时调用对象的方法work()
?extends E泛型可以是E类型,或者是E子类,泛型的上限限定
?super E 泛型可以是E类型,或者是E父类,泛型的下限限定
public static void main(String[] args) {
//定义2个集合,分别存储开发部对象和财务部对象。
List<Development> devList = new ArrayList<Development>();
List<Finance> finList = new ArrayList<Finance>();
//创建开发部对象
Development d1 = new Development();
d1. setName("张三");
d1. setId("开发部001");
Development d2 = new Development( ) ;
d2. setName("李四张三");
d2. setId("开发部001");
//创建财务部对象
Finance f1 = new Finance();
f1. setName("翠花");
f1. setId("财务部001");
Finance f2 = new Finance();
f2. setName("翠花2");
f2. setId("财务部002");
//对象存储到集合
devList.add(d1);
devList .add(d2);
finList. add(f1);
finList. add(f2);
iterator(devList);
iterator(finList);
}
/*使用1个方法,同时遍历2个集合,遍历的同时调用对象的方法work()
*表示通配符,可以接收任意类型,但是 ? 接收的类型必须是Company的子类
*/
pub1ic static void iterator(List<? extends Company> list) {
Iterator<? extends Company> it = list. iterator();
while(it. hasNext()) {
//next() 方法取出就不会是0bject, 是确定的类型Company
Company C= it.next();
C. work( );
}
}