常用对象API_集合框架_工具类

Utilities工具类

Collections方法

此类仅由静态方法组合或返回集合。 它包含对集合进行操作的多态算法，“包装器”，返回由指定集合支持的新集合，以及其他一些可能的和最终的。

下面是排序问题，可以自定义对集合内元素的长度进行排序

import java.util.Comparator;

public class ComparatorByLength implements Comparator<String> {
    @Override
    public int compare(String o1,String o2){
        int temp=o1.length()-o2.length();
        return temp==0?o1.compareTo(o2):temp;
    }
}

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

public class CollectionsDemo {
    public static void main(String[] args){
        /*Collections:是集合框架的工具类
        * 里面的方法都是静态的*/
        demo_1();
    }
    public static void demo_1(){
        List<String> list=new ArrayList<String>();

        list.add("abcde");
        list.add("cba");
        list.add("aa");
        list.add("zz");
        list.add("cba");
        list.add("nbaa");
        System.out.println(list);
       /* //对list集合进行指定顺序排序
        Collections.sort(list);*/
       mySort(list,new ComparatorByLength());
        System.out.println(list);
    }
    public static<T extends Comparable<? super T>> void mySort(List<T> list, Comparator<? super T> comp){
        for (int i=0;i<list.size()-1;i++){
            for (int j=i+1;j<list.size();j++){
                if (comp.compare(list.get(i),list.get(j))>0) {
                   /* T temp = list.get(i);
                   list.set(i,list.get(j));
                   list.set(j,temp);*/
                   Collections.swap(list,i,j);
                }
            }
        }
    }
}

折半查找和最值

 public static void demo_2() {
        List<String> list=new ArrayList<String>();
        list.add("abcde");
        list.add("cba");
        list.add("aa");
        list.add("zzz");
        list.add("cba");
        list.add("nbaa");
        Collections.sort((list));
        System.out.println(list);
        //折半查找cba的位置，前提得排序
        int index=Collections.binarySearch(list,"cba");
        System.out.println("index="+index);
        //获取最大值
        String max=Collections.max(list);
        System.out.println("max="+max);
    }

逆序和替换和随机排序

逆序：

public static void demo_3() {
        //根据元素长度逆序
        TreeSet<String> ts=new TreeSet<String>(Collections.reverseOrder(new ComparatorByLength()));
        ts.add("abc");
        ts.add("hahaha");
        ts.add("zzz");
        ts.add("aa");
        ts.add("cba");
        System.out.println(ts);
    }

替换和随机排序：

public static void demo_4(){
        List<String> list=new ArrayList<String>();
        list.add("abcde");
        list.add("cba");
        list.add("aa");
        System.out.println(list);
        //将cba替换成nba
        Collections.replaceAll(list,"cba","nab");
        //全部替换成一个元素
        Collections.fill(list,"cc");
        //随机对list里的元素进行排序
        Collections.shuffle(list);
        System.out.println(list);
    }

给非同步集合加锁

static <T> Collection<T>     synchronizedCollection(Collection<T> c) //返回由指定集合支持的同步（线程安全）集合
static <T> List<T>     synchronizedList(List<T> list) 返回由指定列表支持的同步（线程安全）列表
static <T> Set<T>     synchronizedSet(Set<T> s) 返回由指定集合支持的同步（线程安全）集

Arrays方法

 arrays:集合框架的工具类，里面的方法都是静态的

static <T> List<T>     asList(T... a) //返回由指定数组支持的固定大小的列表
static int     binarySearch(byte[] a, byte key) //使用二进制搜索算法搜索指定值的指定字节数组
static boolean[]     copyOf(boolean[] original, int newLength) //使用 false （如有必要）复制
指定的数组，截断或填充，以使副本具有指定的长度
static int     deepHashCode(Object[] a)//根据指定数组的“深度内容”返回哈希码 
static boolean[]     copyOfRange(boolean[] original, int from, int to) //将指定数组的指定范围复制到新数组中  
static boolean     equals(boolean[] a, boolean[] a2) //如果两个指定的布尔数组彼此 相等 ，则返回 true 
static void     fill(boolean[] a, boolean val)//将指定的布尔值分配给指定的布尔数组的每个元素   
static int     hashCode(boolean[] a) //根据指定数组的内容返回哈希码 
static void     sort(byte[] a)//按照数字顺序排列指定的数组  
static String toString(boolean[] a) //返回指定数组的内容的字符串表示形式  

重点：List asList(数组)将数组转成集合

import java.util.Arrays;
import java.util.List;

public class ArraysDemo {
    public static void main(String[] args) {
    /*List asList(数组)将数组转成集合
    * 好处：其实可以使用集合方法操作数组中的元素
    * 注意：数组的长度是固定的，所以对于集合的增删方法是不可以使用的
    * 否则会发生UnsupportedOperationException*/
    String[] arr={"abc","haha","xixi"};
        List<String> list= Arrays.asList(arr);
        System.out.println(list);
    }
}
结果:[abc, haha, xixi]

 public static void demo_2(){
        /*如果数组中的元素是对象，那么转成集合时，直接将数组中的元素作为集合中的元素进行集合存储
        *
        * 如果数组中的元素时基本数据类型数值，那么会将该数组作为集合中的元素进行存储*/
        /*int[] arr={31,61,11,25};//集合装的是数组，打印[[I@4554617c]*/
        Integer[] arr={31,61,11,25};//装的是对象，打印[31, 61, 11, 25]
        List list=Arrays.asList(arr);
        System.out.println(list);
    }

Collection

集合转数组

Object[]     toArray() //返回一个包含此集合中所有元素的数组。  

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class ToArray {
    public static void main(String[] args){
        /*集合转成数组
        *
        * 使用的就是Collection接口中的toArray方法
        * 集合转成数组：可以对集合中的元素操作的方法进行限定，不允许对其进行增删*/
        List<String> list=new ArrayList<String>();
        list.add("abc1");
        list.add("abc2");
        list.add("abc3");
        /*toArray方法需要传入一个指定类型的数组
        * 长度该如何定义呢
        * 如果长度小于集合的size，那么该方法会创建一个同类型并和集合相同的size数组
        * 如果长度大于集合的size，那么该方法就会使用指定的数组，存储集合中的元素，其他位置默认值null
        *
        * 所以建议，最后长度就指定为集合的size*/
        String[] arr=list.toArray(new String[2]);
        System.out.println(Arrays.toString(arr));
    }
}