JavaSE基础自学------集合工具类 Collections/Arrays/可变参数/静态导入/高级for

Collections:用于操作集合的工具类

Collections常用代码演示-----

import java.util.*;  //导入集合类包

class Stringlenght implements Comparator<String>{
       //定义字符串长度比较器
    public int compare(String s1,String s2){
     

        int num=new Integer(s1.length()).compareTo(s2.length());
        if (num==0){
     
            return s1.compareTo(s2);
        }
        return num;
    }
}

public class DEMO {
     
    public static void main(String[] args) {
     

        List<String>  al=new ArrayList<>();

        al.add("asad");
        al.add("adsadsa");
        al.add("adsad");
        al.add("aaa");
        al.add("a");

        Collections.sort(al);  //按照默认自然顺序排序
        sop("没有比较器"+al);

        Collections.sort(al,new Stringlenght());  //根据插入的比较器进行排序
        sop("插入比较器"+al);
        sop("max="+Collections.max(al,new Stringlenght()));//根据插入的比较器获取最大值

        sop("index="+Collections.binarySearch(al,"adsadsa",new Stringlenght()));  //二分查找指定元素位置  集合必须是有序的

        //Collections.fill(al,"hehe");  //使用指定元素替换指定列表中的所有元素。

        Collections.replaceAll(al,"a","aa"); //相当于al.set
        sop("replaceAll:"+al);

        Collections.reverse(al);   //反转指定列表中元素的顺序。
        sop("reverse:"+al);

         Collections.swap(al,0,1); //交换角标上元素的位置
        sop("交换swap"+al);

        Collections.shuffle(al);  //随机置换
        sop("随机交换"+al);
    }
    public static void sop(Object obj) {
     
        System.out.println(obj);
    }
}

---

代码演示2-------
reverseOrder() ------返回一个比较器，它强行逆转实现了 Comparable 接口的对象 collection 的自然顺序。
reverseOrder(Comparator cmp) ------返回一个比较器，它强行逆转指定比较器的顺序。

import java.util.*;  //导入集合类包

class Stringlenght implements Comparator<String>{
       //定义字符串长度比较器
    public int compare(String s1,String s2){
     

        int num=new Integer(s1.length()).compareTo(s2.length());
        if (num==0){
     
            return s1.compareTo(s2);
        }
        return num;
    }
}
public class DEMO {
     
    public static void main(String[] args) {
     
    
                                      //返回一个比较器，它强行逆转指定比较器的顺序。
        Set<String> ts=new TreeSet<>(Collections.reverseOrder(new Stringlenght()));

        ts.add("d");
        ts.add("ccc");
        ts.add("dddd");
        ts.add("bb");

        sop(ts);

        Iterator<String>  it=ts.iterator();

        while (it.hasNext()){
     
            System.out.println(it.next());
        }
        
    }
    public static void sop(Object obj) {
     
        System.out.println(obj);
    }
}

---

---

Arrays:用于操作数组的工具类

asList(T… a); : 将数组变成List集合
有何好处 : 可以使用集合的方法来操作数组中的元素
注意:

• 将数组变成集合,不可以使用集合的增删方法, 因为数组的长度是固定的
• 如果数组中的元素是对象,那么转换成集合时,数组中的元素就直接转换成集合中的元素
• 如果数组中的元素是基本数据类型时(intdouble…),那么该数组就作为集合中的元素存在

---

集合变成数组 : Collection接口中的 toArray() 方法

• toArray(T[] a) ----- 返回包含此 collection 中所有元素的数组；返回数组的运行时类型与指定数组的运行时类型相同。
• 好处:将集合转换成数组,限制了对元素的操作,只能查阅不能增删,

import java.util.*;  //导入集合类包
public class DEMO {
     
    public static void main(String[] args) {
     

        String[] s = {
     "ss", "aa", "bb"};
        List<String> al = Arrays.asList(s);  //将数组变成List集合
        sop(al.contains("ss"));
        sop("al ="+al);

        int[] arr = {
     1, 4, 6};
        List<int[]> al1 = Arrays.asList(arr);  //arr数组为基本数据类型,所以集合中存放了arr这个数组元素
        sop("al1 =" + al1);

        Integer[] arr1 = {
     1, 5, 6};
        List<Integer> al2 = Arrays.asList(arr1);  //arr1里元素为对象,可以直接转换成集合中的元素
        sop("al2 =" + al2);

        List<String> al3=new ArrayList<>();
        al3.add("aaa");
        al3.add("bb");
        al3.add("bbbb");
        String[]  s1=al3.toArray(new String [al3.size()]); //将集合转换成数组..String 数组的长度为集合的size;
        sop("s1="+Arrays.toString(s1));
    }

    public static void sop(Object obj) {
     
        System.out.println(obj);
    }
}

---

---

• 高级for循环 : 对集合或数组进行遍历,只能获取集合(Collection)或数组,不能操作集合(不能增删)

import java.util.*;  //导入集合类包
public class DEMO {
     
    public static void main(String[] args) {
     
        Set<String > hs=new HashSet<>();       
        hs.add("aa");
        hs.add("ss");
        for (String s:hs ){
           //使用高级for遍历集合
            sop(s);
        }


        Map<String ,String > m=new HashMap<>();
        m.put("1","a");
        m.put("2","b");
        m.put("3","c");
        Set<Map.Entry<String,String>> entrySet=m.entrySet();
        for (Map.Entry<String,String> me: entrySet){
                  //使用高级for遍历集合
           sop(me.getKey()+" :: "+me.getValue());
        }
    }
    public static void sop(Object obj) {
     
        System.out.println(obj);
    }
}

---

• 可变参数 / 静态导入

import java.util.*;  //导入集合类包

import static java.util.Arrays.*; //静态导入,导入Arrays类中所有的静态成员;

public class DEMO {
     
    public static void main(String[] args) {
     
        int[] a={
     6,7,8,9};
        sop(binarySearch(a,6));  //因为静态导入.所有不用加类名
        sop(Arrays.toString(a));  //因为Object类中也有toString方法,所有必须要加类名
        

        
        int [] arr={
     1,5,6};
        show2(arr);

        show1("sss",2,3,4,5);
        /*
        可变参数...其实就是上面 arr的简写
        不需要每次都手动创建数组
        只要把要操作的元素作为参数写入即可
        隐式将这些参数封装成了数组
        */
    }

    public static void show1(String s,int...arr){
       //注:可变参数一定要定义在参数列表的最后面
        sop(Arrays.toString(arr));
        sop(s);
    }
    
    public static void show2(int [] arr){
     

        sop(Arrays.toString(arr));

    }
    public static void sop(Object obj) {
     
        System.out.println(obj);
    }
}