Java 19-7 集合工具类

Collections 为工具类 操作Collection的静态方法
对list排序 sort(list);

public class Collections_Test1 {
    public static void main(String[] args) {
        methodDemo_1();
    }

    private static void methodDemo_1() {
        List<String> list=new ArrayList<>();
        list.add("asdzx");
        list.add("zxcx");
        list.add("zaw");
        list.add("qwes");
//        Collections.sort(list);
//        Collections.sort(list,new ListLenthCom()); 调用自定义比较器
//        倒叙排 使用.reverseOrder();方法
        Collections.sort(list,Collections.reverseOrder(new ListLenthCom()));
        System.out.println(list);

    }
}

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

模拟最大值方法

public class Collection_Test2 {
    public static void main(String[] args) {
        ArrayList<String> list=new ArrayList<>();
        list.add("asdzx");
        list.add("zxcx");
        list.add("zaw");
        list.add("qwes");
        String s=getMax(list);
        System.out.println(s);
//        模拟获取集合最大值

    }
//    T不继承Comparable接口没有CompareTo方法
    public static <T extends Object&Comparable<? super T>> T getMax(Collection<? extends T> coll){
//取出容器中的一个元素定义为变量max Collection只能迭代
        Iterator<? extends T> it=coll.iterator();
        T max=it.next();
//        遍历所有元素
//        在遍历中比较，只要比变量中的值大。用变量记录下来
        while (it.hasNext()) {
            T next = it.next();
            if (max.compareTo(next)>0)
                max=next;
        }
        return max;
    }
    /* max方法源码
    public static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll) {
        Iterator<? extends T> i = coll.iterator();
        T candidate = i.next();

        while (i.hasNext()) {
            T next = i.next();
            if (next.compareTo() > 0)
                candidate = next;
        }
        return candidate;
    }*/
}

Arrays
从来操作数组 方法为静态

public class Arrays_Test1 {
    public static void main(String[] args) {
        int[] arr={12,32,51,32,32,15,51,};
        System.out.println(Arrays.toString(arr));
    }
}

//asList(); 将数组转化为固定长度的list集合
public class Arrays_Test2 {
    public static void main(String[] args) {
//查找数组中是否存在abc
        String arr[]={"asd","wes","zxc","abc"};
       /* Boolean b=myContains(arr);
        System.out.println(b);*/
//       发现数组本身可以将数组转化成集合 使用数组方法进行判断
        List<String> list= Arrays.asList(arr);
        list.set(3,"ass");//0开始
        Boolean b=list.contains("abc");
//        list.add("qq");//java.lang.UnsupportedOperationException
//        不能使用集合的增删方法  可以替换不能改变长度
        System.out.println(b);
    }

  /*  private static Boolean myContains(String[] arr) {
        for (int i = 0; i <arr.length; i++) {
            if (arr[i].equals("abc"))//内容相等
            return true;
        }
        return false;
    }*/
}

public class Arrays_Test4 {
    public static void main(String[] args) {
//传入的数组长度，如果小于集合长度，方法中会创建一个新的长度和集合长度一致的数组
//如果传入数组长度大于等于集合长度，会使用传入的数组，所以建议长度定义为集合的size();
//限定对元素的操作,比如增删

        List<String> list=new ArrayList<>();
        list.add("asd");
         list.add("zcq");
//        String[] s= list.toArray(new String[0]);
        String[] s=list.toArray(new String[list.size()]);
        System.out.println(Arrays.toString(s));
    }
}

public class Arrays_Test5 {
    public static void main(String[] args) {
        int sum=add(2,4,5,6);
        System.out.println(sum);
//        可变参数需要注意,自能定义在参数列表最后
    }
    public static int add(int x,int...arr){
        int sum1=0;
        for (int i = 0; i <arr.length; i++) {
            sum1+=arr[i];
        }
        return sum1;
    }

}