Collections工具类，增强for循环、通配符

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( );
	}
}