獲取集合中的最大元素（承接之前的繼承體系） 思路： 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())