Java 集合17 泛型限定的练习

获取集合中的最大元素（承接之前的继承体系）
思路：
1.定义变量记录每一次比较后的最大值，初始化为任意一个
2.便利容器
3.在遍历时将记录的元素和遍历到的元素进行比较
4.遍历结束，都得到最大值
代码一：（没有泛型）

package Collection;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class GenericTest1 {
    public static void main(String[] args){
        //创建集合
        Collection c= new ArrayList();
        //添加元素
        c.add( new Worker("Zhnagsan1",45));
        c.add(new Worker("Zhnagsan2",18));
        c.add(new Worker("Zhnagsan3",20));
        Worker max = getMax(c);
        System.out.println(max);
    }
    public static Worker getMax(Collection c){
        //获取迭代器
        Iterator it = c.iterator();
        Worker max = (Worker) it.next();//要进行强转

        while(it.hasNext()){//遍历容器
            Worker temp = (Worker)it.next();//要进行强转
            if(max.compareTo(temp)<0){
                max=temp;
            }
        }
        return max;
    }
}

此时我们是明确集合中是什么元素的因此加上泛型

Collection<Worker> c= new ArrayList<>();
 public static Worker getMax(Collection<Worker> c)
 Iterator<Worker> it = c.iterator();
 //此时类型强转就可以不要了

代码修改到这个地步，需求我们解决了，同时还使用了泛型，让集合中的元素更加的安全，但是这个功能太过局限：这能对存储Worker 的集合进行操作。
所以我们要扩大这个功能所能操作的元素的类型范围。

扩大功能可以操作的元素范围
public class GenericTest2_Fangxing {
    public static void main(String[] args){

        Collection c= new ArrayList();

        c.add( new Worker("Zhnagsan1",45));
        c.add(new Worker("Zhnagsan2",18));
        c.add(new Worker("Zhnagsan3",20));

        Worker max = (Worker)getMax(c);
        System.out.println(max);
    }
    public static Object getMax(Collection c){

        Iterator it = c.iterator();
    Object max =  it.next();

        while(it.hasNext()){
           Comparable temp = (Comparable) it.next();
           //compareTo 是Compareble 的方法，所以将temp 转换成 comparable  类型
           //因为集合现在是实现了Comparable  这个接口的（worker）
            if(temp.compareTo(temp)>0){
                max=temp;
            }
        }
        return max;
    }
}
//但是这段代码还是存在问题，如果存入一个没有实现 Comparable 的类，就会在运行时发生类型转换的异常  ，存入的元素类型必须是Comparable 的子类

终极版本：

package Collection;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class GenericTest3_Fanxing {
    public static void main(String[] args){

        Collection<Worker> c= new ArrayList<Worker>();

        c.add( new Worker("Zhnagsan1",45));
        c.add(new Worker("Zhnagsan2",18));
        c.add(new Worker("Zhnagsan3",20));

        Worker max =  getMax(c);
        System.out.println(max);
    }
    //使用泛型，将功能的使用范围扩大

    public static<T extends Comparable<? super T>>  T getMax(Collection<? extends T> c){
/*
1.静态方法的静态是定义在Static 返回值 之间的  这个方法操作的元素类型是T  所以集合中的元素也是T 类型，返回值也是T
2.T 这个类型是有限定的，方法中接受的集合中的元素，他必须实现了 Comparable (这样才能调用  comparTo  方法)
3.Comparable  中的泛型，只要是这个元素的父类都可以接收
4.集合中的元素只要继承了 这个元素就是符合传入条件的
 */
        Iterator<? extends T> it = c.iterator();
        T max =  it.next();

        while(it.hasNext()){
            T temp = it.next();
            if(temp.compareTo(temp)>0){
                max=temp;
            }
        }
        return max;
    }
}
//当类型不符合时，会在编译时就出错

//
//

当我们自己要写这样的一些方法，还是比较麻烦，所以在集合体系中为我们提供了一个工具类
Collections 对集合对象操作的工具类
里面定义了很多操作集合对象的方法，都是静态的。

常用方法：
1.获取最值

//自然排序
public static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll)
//根据其元素的自然顺序返回给定集合的最大元素。 集合中的所有元素必须实现Comparable接口。
//其实在源代码中和我们写的差不多

只要集合满足要求，直接调用就行了

//使用比较器
public static <T> T max(Collection<? extends T> coll, Comparator<? super T> comp)
//根据指定的比较器引发的顺序返回给定集合的最大元素。 集合中的所有元素必须由指定的比较器相互比较
//他的源码其实和自然排序差不多，只是多了要有比较器，要出传入一个比较器

自己写的代码：

 //假设已经存在一个比较器
 public static <T extends Comparable<? super T>> T getMax2(Collection<? extends T> c, Comparator<? super T> comp){
 //将比较器也传入
            if(comp==null){
                return getMax(c);//比较器为空则使用自然排序
            }
            else{
                Iterator<? extends T> it = c.iterator();
                T max = it.next();
                while(it.hasNext()){
                    T temp = it.next();
                    if(comp.compare(temp,max)>0 ){
                        max=temp;
                    }
                }
                return max;
            }
    }

2.取得最小值 min
3.对List 集合元素进行排序（元素有重复） ，二分查找
自然排序： sort(List 集合)
定义排序规则：自己传入一个比较器
3.元素交换 只能对List 因为他需要角标
4.reverOrder 返回自然排序或者是比较器排序 的逆转
5.使集合 同步，synchronizedList() 将集合”包装起来“

List  list  = Collections.synchronzedList( new   ArrayList())