Java中Collections的魅力

Java中Collections的魅力

代码块

package com.jasonk.datatypeconversion;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class Demo_011 {
    /**
     * @author MIJasonK
     * @see 内部排序及外部排序
     */

    public static void main(String[] args) {
        /**
         *  经典内部排序
         *  1.内部排序需要对象bean实现Comparable接口并且实现其compareTo方法
         */
        List<UserInfo> infos = new ArrayList<UserInfo>();
        for(int i = 1<<5; i>0; i=i>>1){
            infos.add(new UserInfo(i, (i<<i)+""));
        }
        /* java 1.8 新遍历方式Lambda方式 */
        infos.forEach((o)-> {System.out.print("UserInfo [age=" + o.age + ", name=" + o.name + "]" +"  ");});
        System.out.println();
        //System.out.println(infos);// 默认插入顺序

        Collections.sort(infos);// 调用内部排序
        /* java 1.8 新遍历方式Lambda方式 */
        infos.forEach((o)-> {System.out.print("UserInfo [age=" + o.age + ", name=" + o.name + "]" +"  ");});
        System.out.println();
        //System.out.println(infos);

        /**
         * 经典外部排序
         *  1.利用Collections工具类的sort方法，构建排序判断判断方法
         *  2.Collections是针对集合类的一个帮助类，他提供一系列静态方法实现对各种集合的搜索、排序、线程安全等操作
         */
        Collections.sort(infos,new Comparator<Object>() {// 自定义外部排序

            @Override
            public int compare(Object o1, Object o2) {
                // 兼容性排序
                if(o1 instanceof UserInfo && o2 instanceof UserInfo){
                    UserInfo userInfo1 = (UserInfo)o1;
                    UserInfo userInfo2 = (UserInfo)o2;
                    if(userInfo2.age>userInfo1.age){
                        return 1;// 1   如果自身比比较者（o）小 那么就移动到比较者前边
                    }else if(userInfo2.age<userInfo1.age){
                        return -1;// -1 如果自身比比较者（o）大 那么就移动到比较者后边
                    }
                }
                return 0;// 0   代表两个对象是相同的
            }
        });
        /* java 1.8 新遍历方式Lambda方式 */
        infos.forEach((o)-> {System.out.print("UserInfo [age=" + o.age + ", name=" + o.name + "]" +"  ");});
        System.out.println();
        //System.out.println(infos);
    }

}
/*
 * 测试使用对象   UserInfo
 */
class UserInfo implements Comparable<Object>{
    int age;
    String name;
    @Override
    public String toString() {
        return "UserInfo [age=" + age + ", name=" + name + "]";
    }
    public UserInfo(int age, String name) {
        super();
        this.age = age;
        this.name = name;
    }

    public UserInfo() {
        super();
    }
    @Override
    public int compareTo(Object o) {
        // 兼容性排序
        if(o instanceof UserInfo){
            UserInfo userInfo = (UserInfo)o;
            if(this.age>userInfo.age){
                return 1;// 1   如果自身比比较者（o）小 那么就移动到比较者前边
            }else if(this.age<userInfo.age){
                return -1;// -1 如果自身比比较者（o）大 那么就移动到比较者后边
            }
        }
        return 0;// 0   代表两个对象是相同的
    }
}

Collections

（1）sort()排序方法
函数定义： public static <T extends Comparable<? super T>> void sort(List<T> list)根据元素的自然顺序对指定列表按升序进行排序。
参数：要排序的列表。
函数定义：public static <T> void sort(List<T> list,Comparator<? super T> c)，根据指定比较器产生的顺序对指定列表进行排序。此列表内的所有元素都必须可使用指定比较器相互比较。
参数：list-要排序的列表；c-确定列表顺序的比较器。
（2）binarySearch()二分查找方法
函数定义：public static <T> int binarySearch(List<? extends Comparable<? super T>> list,T key)
使用二分搜索法搜索指定列表，以获得指定对象，在进行此方法调用前比较要将列表元素按照升序排序，否则结果不确定，此方法会执行O(n)次链接遍历和O(log n)次元素比较。
参数: list-要搜索的链表，key-要搜索的键。
函数定义： public static <T> int binarySearch(List<? extends T> list, T key, Comparator<? super T> c)根据指定的比较器对列表进行升序排序。
参数：list-要搜索的列表，key-要搜索的键，c-排序列表的比较器。
（3）reverse()反转方法
函数定义：public static void reverse(List<?> list)，反转指定列表中元素的顺序，此方法以线性时间运行。
参数：list-元素要被反转的列表
（4）shuffle()改组方法
函数定义：public static void shuffle(List<?> list)，使用默认随机源对指定列表进行置换，所有置换发生的可能性都是大致相等的。
参数：list-要改组的列表
函数定义：public static void shuffle(List<?> list,Random rnd),使用指定的随机源对指定列表进行置换。
参数：list-要改组的列表，rnd-用来改组列表的随机源。
（5）swap()交换方法
函数定义：public static void swap(List<?> list,int i，int j)，在指定列表的指定位置处交换元素。
参数：list-进行元素交换的列表，i-要交换的一个元素的索引，j-要交换的另一个元素的索引。
（6）fill()替换方法
函数定义：public static <T> void fill(List<? super T> list,T obj)，使用指定元素替换指定列表中的所有元素，线性时间运行。
参数:list-使用指定元素填充的列表，obj-用来填充指定列表的元素。
（7）copy()复制方法
函数定义：public static <T> void copy(List<? super T> dest,List<? extends T> src)，将所有元素从一个列表复制到另一个列表。执行此操作后，目标列表中每个已复制元素的索引将等同于源列表中该元素的索引，目标列表的长度至少必须等于源列表。
参数：dest-目标列表，src-源列表。
（8）min()最小值法
函数定义：public static <T extends Object & Comparable<? super T>> T min(Collection<? extends T> coll)，根据元素的自然顺序返回给定Collection的最小元素，Collection中的所有元素必须实现Comparable接口，此外，collection中的所有元素都必须是可相互比较的。
参数：coll-将确定其最小元素的collection。
函数定义：public static <T> T min(Collection<? extends T> coll,Comparator<? super T> comp),根据指定比较器产生的顺序，返回给定collection的最小元素。
参数：coll-将确定其最小元素的collection，comp-用来确定最小元素的比较器。
（9）max()最大值方法
函数定义：public static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll)，根据元素的自然顺序，返回给定collection的最大元素。
参数：coll-将确定其最大元素的collection。
函数定义：public static <T> T max(Collection<?extends T> coll,Comparator<? super T> comp)，根据指定比较器产生的顺序，返回给定collection的最大元素。
参数：coll-将确定其最大元素的collection，comp-用来确定最大元素的比较器
（10）rotate()轮换方法
函数定义：public static void rotate(List<?> list，int distance)，根据指定的距离轮转指定列表中的元素。
参数：list-要轮换的列表，distance-列表轮换的距离，可以使0、负数或者大于list.size()的数。
（11）replaceAll()替换所有函数
函数定义：public static <T> boolean replaceAll(List<T> list,T oldVal,T newVal)，使用另一个值替换列表总出现的所有的某一指定值。
参数：list-在其中进行替换的列表；oldVal-将被替换的原值；newVal-替换oldVald的新值。