常用工具类1.0

常用工具类

Collections工具类

1.添加、排序
Collections工具类提供了一系列方法用于对list集合进行添加和排序操作。
常用方法：

static <T> boolean addAll(Collection <? super T> c,T...elements);       //将指定元素添加到指定集合c中。T...elements代表可变参数
static void reverse(List list);                                         //反转指定List集合中的元素顺序
static void shuffle(List list);                                         //随机打乱List集合中元素的顺序
static void sort(List list);                                            //根据元素的自然排序(从小到大)对List集合中的元素进行排序
static void swap(List list,int i,int j);                                //将指定的List集合中索引为i的元素和索引为j的元素交换

只看方法的话可能不太好理解，主要还是看例子进行理解
例：

package text1;

import java.util.ArrayList;
import java.util.Collections;

public class Test23 {
    public static void main(String[] args) {
        //常见ArrayList集合
        ArrayList<String> as=new ArrayList<String>();
        //向集合中添加元素
        Collections.addAll(as,"z","x","c","v","b");
        //使集合中的元素进行自然排序
        Collections.sort(as);
        System.out.println("自然排序后集合中元素的顺序:"+as);
        //使集合中的元素顺序反转
        Collections.reverse(as);
        System.out.println("反转后集合中元素的顺序:"+as);
        //交换第一个元素和最后一个元素
        Collections.swap(as,0,as.size()-1);
        System.out.println("交换第一个元素和最后一个元素后集合元素的顺序:"+as);
        //随机打乱集合中的元素
        Collections.shuffle(as);
        System.out.println("随机打乱后集合中元素的顺序:"+as);
    }
}

结果显示：

2.查找、替换
常用方法：

static int binarySearch(List list,Object key)       //使用二分法搜索指定对象在List集合中的索引，要求查找的List集合中的元素必须使有序的
static Object max(Collection col)     				//根据元素的自然顺序，返回给定集合最大的元素
static Object min(Collection col)    				//根据元素的自然顺序，返回指定集合中最小的元素
staticBollean replaceAll(List list,Object oldVal,Object newVal)		//用新值(newVal)替换List集合中所有的旧值(oldVal)

例子：

package text1;

import java.util.ArrayList;
import java.util.Collections;

public class Test24 {
    public static void main(String[] args){
        //创建ArrayList集合对象
        ArrayList<Integer> ai=new ArrayList<Integer>();
        //向集合中添加元素
        Collections.addAll(ai,-3,2,9,5,8);
        System.out.println("集合中的元素初始排序:"+ai);
        //输出集合中最大的元素
        System.out.println("集合中最大的元素:"+ Collections.max(ai));
        //输出集合中最小的元素
        System.out.println("集合中最小的元素:"+ Collections.min(ai));
        //将集合中的数值替代
        Collections.replaceAll(ai,8,10);
        System.out.println("输出后的集合"+ai);
        //因为使用二分法前必须保证元素有序，所以先使用一次sort()方法
        Collections.sort(ai);
        System.out.println("排序后："+ai);
        System.out.println("9的索引位置是:"+ Collections.binarySearch(ai,9));
    }
}

Arrays工具类

这个是针对数组操作的数组工具类Arrays。Arrays工具类提供了大量针对数组操作的静态方法
1.使用sort()方法排序
例：

package text1;

import java.util.Arrays;

public class Test25 {
    public static void main(String[] args){
        //创建一个int型数组并赋初值
        int[] arr={9,5,7,3,7,8};
        //排序前
        System.out.println("排序前:");
        Print(arr);
        Arrays.sort(arr);
        System.out.println("排序后:");
        Print(arr);
    }
    //写一个打印数组的方法
    public static void Print(int[] a){
        System.out.print("[");
        for(int i=0;i<a.length-1;i++)
            System.out.print(a[i]+",");
        System.out.println(a[a.length-1]+"]");
    }
}

结果如下：

这个排序是按照自然排序进行的，Arrays工具类还提供了多个重载的sort()方法，这个排序可以按照自然排序，又可以使用自定义的排序方法。
2.使用binarySearch()方法查找元素binarySearch(Object[] a,Object value);a是被查询的集合，value是被查询的元素值采用的是二分查找方法。这样的效率较高。
例：

package text1;

import java.util.Arrays;

import static java.util.Arrays.binarySearch;

public class Test26 {
    public static void main(String[] args) {
        int[] a={6,34,7,3,45,7,22,234,6,8,3};
        Arrays.sort(a);
        Print(a);
        int index=binarySearch(a,6);
        System.out.println(index);
    }
    public static void Print(int[] a){
        System.out.print("[");
        for(int i=0;i<a.length-1;i++)
            System.out.print(a[i]+",");
        System.out.println(a[a.length-1]+"]");
    }
}

结果如下：

其中，对数组进行查询之前一定要进行一次排序，即查询前保证数组是有序的，如果数组中有多个相同的元素，查询结果是第一次该数出现的位置。
3.使用copyOfRange()方法复制元素
在不破坏数组的情况下使用数组中的某些数据，需要用到Arrays工具类的copyOfRange()方法，这个方法可以将一个数组的指定范围内的元素复制到另一个新的数组中。copyOfRange(int[] ariginal,int from,int to);参数original表示被复制的数组，from表示开始索引（包括），to表示结束索引（不包括）。返回值是一个数组。
例：

package text1;

import java.util.Arrays;



public class Test27 {
    public static void main(String[] args) {
        int[] arr={3,5,2,7,8,2,9,4,};
        for(int i:arr){
            System.out.print(i+" ");
        }
        System.out.println();
        int[] b=Arrays.copyOfRange(arr,2,6);
        for(int i:b){
            System.out.print(i+" ");
        }
    }
}

结果如下：

4.使用fill()方法替换元素
fill(Object[] a,Object val)是用val替换数组a中的全部元素
例子：

package text1;

import java.util.Arrays;

public class Test28 {
    public static void main(String[] args) {
        int[] a={2,5,6,2,6};
        //替换前
        for(int i:a){
            System.out.print(i+" ");
        }
        System.out.println();
        Arrays.fill(a,8);
        for(int i:a){
            System.out.print(i+" ");
        }
    }
}

结果如下：

Lambda表达式

()- > System. out.println("Hello Lambda!");         //无参数,无返回值
(x)一> System. out. println(x)              //有一个参数，无返回值

x一> System. out. println(x)         //若只有一个参数,小括号可以省略不写

Comparator<Integer> com = (x, y)一> > {  //有两个以上的参数,有返回值，并且Lambda方法体中有多条语句
        System.out. println("函数式接口");
        return Integer. compare(x, y);
        } ;

Comparator< Integer> com = (x, y) - - >     //若Lambda方法体中只有一条语句,return和大括号都可以省略不写
Integer.compare(x, y);

(Integer x, Integer y)-> Integer.compare(x, y);     //Lambda表达式的参数列表的数据类型可以省略不写,因为Java虚拟机的编译器可以通过上下文推断出数据类型，即“类型推断”

例子：

package text1;

import java.util.Arrays;

public class Test29 {
    public static void main(String[] args) {
        String[] arr={"Program","creek","is","a","java","site"};
        Arrays.sort(arr,(m, n)->Integer.compare(m.length(),n.length()));
        System.out.println("Lambda语句体中只有一条语句，参数类型可以推断为："+Arrays.toString(arr));
        Arrays.sort(arr,(String m,String n)->{
            if(m.length()>n.length())
                return -1;
            else
                return 0;
        });
        System.out.println("Lambda语句体中有多条语句:"+Arrays.toString(arr));
    }
}

结果如下：