Java基础17：集合工具类Collections；高级for循环；静态导入；可变参数

最新推荐文章于 2023-08-14 17:00:00 发布

若云_bai

最新推荐文章于 2023-08-14 17:00:00 发布

阅读量742

点赞数

分类专栏： java基础

本文链接：https://blog.csdn.net/zxloveooo/article/details/10488653

版权

java基础专栏收录该内容

39 篇文章 0 订阅

订阅专栏

关键字：集合工具类Collections；高级for循环；静态导入；可变参数

一、集合工具类Collections-sort
工具类
public class Collections extends Object此类完全由在 collection 上进行操作或返回 collection 的静态方法组成。它包含在 collection 上操作的多态算法，即“包装器”，包装器返回由指定 collection 支持的新 collection，以及少数其他内容。

/*
map扩展知识。
map结合被使用，是因为具备映射关系。


一个学校，每个学校都有班级，班级都有名称


*/
import java.util.*;
public class Demo{
    public static void main(String[] args){
        List<String> list = new ArrayList<String>();
        list.add("abcd");
        list.add("aaa");
        list.add("aaa");
        list.add("ddd");
        list.add("fff");
        sop(list);
        Collections.sort(list);
        sop(list);
    }
    public static void sortDemo(){
    
    }
    public static void sop(Object obj){
        System.out.println(obj);
    }
}
//还支持自定义排序

二、集合工具类(Collections-max)
static <T extends Object & Comparable<? super T>>
T
max(Collection<? extends T> coll)
根据元素的自然顺序，返回给定 collection 的最大元素。
static <T> T
max(Collection<? extends T> coll, Comparator<? super T> comp)
根据指定比较器产生的顺序，返回给定 collection 的最大元素。
static <T extends Object & Comparable<? super T>>
T
min(Collection<? extends T> coll)
根据元素的自然顺序返回给定 collection 的最小元素。
static <T> T
min(Collection<? extends T> coll, Comparator<? super T> comp)
根据指定比较器产生的顺序，返回给定 collection 的最小元素。

import java.util.*;
public class Demo{
    public static void main(String[] args){
        List<String> list = new ArrayList<String>();
        list.add("abcd");
        list.add("aaa");
        list.add("aaa");
        list.add("ddd");
        list.add("fff");
        sop(list);
        sop(Collections.max(list));
    }
    public static void sortDemo(){
    
    }
    public static void sop(Object obj){
        System.out.println(obj);
    }
}
//还支持自定义排序

三、集合(Collections-binarySearch) 必须是有序集合，只要是二分法，就必须是有序集合
static <T> int
binarySearch(List<? extends Comparable<? super T>> list, T key)
使用二分搜索法搜索指定列表，以获得指定对象。
static <T> int
binarySearch(List<? extends T> list, T key, Comparator<? super T> c)
使用二分搜索法搜索指定列表，以获得指定对象。
如果搜索键包含在列表中，则返回搜索键的索引；否则返回 (-(插入点) - 1)。插入点被定义为将键插入列表的那一点：即第一个大于此键的元素索引；如果列表中的所有元素都小于指定的键，则为 list.size()。注意，这保证了当且仅当此键被找到时，返回的值将 >= 0。

import java.util.*;
public class Demo{
    public static void main(String[] args){
        List<String> list = new ArrayList<String>();
        list.add("abcd");
        list.add("aaa");
        list.add("aaa");
        list.add("ddd");
        list.add("fff");
        sop(list);
        sop(Collections.binarySearch(list,"ddd"));
    }
    public static void sortDemo(){
    
    }
    public static void sop(Object obj){
        System.out.println(obj);
    }
}
//还支持自定义排序

四、集合(Collections-替换反转)
static void swap(List<?> list, int i, int j)
在指定列表的指定位置处交换元素。
static <T> void
fill(List<? super T> list, T obj)
使用指定元素替换指定列表中的所有元素。

static <T> boolean
replaceAll(List<T> list, T oldVal, T newVal)
使用另一个值替换列表中出现的所有某一指定值。

static void reverse(List<?> list)
反转指定列表中元素的顺序。

五、集合(Collections-reverseOrder)
static <T> Comparator<T>
reverseOrder()
返回一个比较器，它强行逆转实现了 Comparable 接口的对象 collection 的自然顺序。
static <T> Comparator<T>

reverseOrder(Comparator<T> cmp)
返回一个比较器，它强行逆转指定比较器的顺序。
也可以逆转自己编写的比较器

import java.util.*;
public class Demo{
    public static void main(String[] args){
        //TreeSet<String> ts = new TreeSet<String>(new myComparator());自定义的是从小到大排序
        TreeSet<String> ts = new TreeSet<String>(Collections.reverseOrder(new myComparator()));
        ts.add("aaaa");
        ts.add("ddddddd");
        ts.add("sss");
        ts.add("SDccFS");
        Iterator<String> it = ts.iterator();
        while(it.hasNext()){
            sop(it.next());
        }
    }
    public static void sortDemo(){
    
    }
    public static void sop(Object obj){
        System.out.println(obj);
    }
}
class myComparator implements Comparator<String>{
    public int compare(String s1,String s2){
        int l1 = s1.length();
        int l2 = s2.length();
        if(l1>l2){
            return 1;
        }else if(l1<l2){
            return -1;
        }else{
            return 0;
        }
    }
}

六、集合(Collections-SynList)
< T> Collection<T>
synchronizedCollection(Collection<T> c)
返回指定 collection 支持的同步（线程安全的）collection。
static <T> List<T>
synchronizedList(List<T> list)
返回指定列表支持的同步（线程安全的）列表。
static <K,V> Map<K,V>
synchronizedMap(Map<K,V> m)
返回由指定映射支持的同步（线程安全的）映射。
static <T> Set<T>
synchronizedSet(Set<T> s)
返回指定 set 支持的同步（线程安全的）set。
static <K,V> SortedMap<K,V>
synchronizedSortedMap(SortedMap<K,V> m)
返回指定有序映射支持的同步（线程安全的）有序映射。
static <T> SortedSet<T>
synchronizedSortedSet(SortedSet<T> s)
返回指定有序 set 支持的同步（线程安全的）有序 set。

static void shuffle(List<?> list)
使用默认随机源对指定列表进行置换。
static void shuffle(List<?> list, Random rnd)
使用指定的随机源对指定列表进行置换。


七、集合(Arrays)
注意，将数组编程的集合，不可以使用集合的增删方法，因为数组的长度是固定的，
如果你增删了，会发发生不支持操作异常
static <T> List<T>
asList(T... a)
返回一个受指定数组支持的固定大小的列表。

static int binarySearch(byte[] a, byte key)
使用二分搜索法来搜索指定的 byte 型数组，以获得指定的值。

static boolean[] copyOf(boolean[] original, int newLength)
复制指定的数组，截取或用 false 填充（如有必要），以使副本具有指定的长度。

static boolean[] copyOfRange(boolean[] original, int from, int to)
将指定数组的指定范围复制到一个新数组。

static void sort(byte[] a)
对指定的 byte 型数组按数字升序进行排序。

static String toString(boolean[] a)
返回指定数组内容的字符串表示形式。

/*
Arrays：用于操作数组的工具类
里面都是静态方法
注意，将数组编程的集合，不可以使用集合的增删方法，因为数组的长度是固定的，
如果你增删了，会发发生不支持操作异常
*/
import java.util.*;
public class Demo{
    public static void main(String[] args){
        String[] arr = {"dsfasad","sad","sdfsd","sfd"};
        //把数组编程集合，变成集合可以方便的使用集合的思想和方法，比如判断是否有某个方法
        //注意，将数组编程的集合，不可以使用集合的增删方法，因为数组的长度是固定的，
        //如果你增删了，会发发生不支持操作异常
        List<String> list = Arrays.asList(arr);
        sop(arr);
        sop(list);
        
        int[] nums = {2,4,5};
        //数字数组得这样写
        List<int[]> li = Arrays.asList(nums);//或者 Integer[] nums = {2,4,5};List<Integer> li = Arrays.asList(nums);
        /*
        如果数组中的元素，都是都像，变成集合时，数组中的元素就直接转换成集合中的元素
        如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的元素存在
        */
        
        
    }
    public static void sop(Object obj){
        System.out.println(obj);
    }
}

八、集合(集合转成数组)
Object[] toArray()
返回包含此 collection 中所有元素的数组。
< T> T[]
toArray(T[] a)
返回包含此 collection 中所有元素的数组；返回数组的运行时类型与指定数组的运行时类型相同。

import java.util.*;
public class Demo{
    public static void main(String[] args){
        ArrayList<String> al = new ArrayList<String>();
        al.add("sdfsda");
        al.add("afs");
        al.add("sd");
        /*
            1、指定类型的数组到底要定义多长呢？
                当指定类型的数组长度小于了集合的size，那么该方法内部都会创建一个新的数组，长度为集合的size
                当指定类型的数组长度大于了集合的size，就不会新创建数组，而是使用传递进来的数组
                所以应该创建一个刚刚好的
                String[] arr = al.toArray(new String[al.size()]);
            
            2、为什么要将集合变数组？
                为了限定对元素的操作。不需要进行增删。
        */
        String[] arr = al.toArray(new String[5]);
        sop(Arrays.toString(arr));
    }
    public static void sop(Object obj){
        System.out.println(obj);
    }
}

九、集合(增强for循环)

/*
高级 for 循环
格式：
for(数据类型 变量名 ： 被变量的集合（Collection）或者数组){


}


对集合进行遍历，只能获取集合元素，但是不能对集合进行操作。


迭代器出了遍历，还可以进行remove集合中元素的动作


如若果使用ListIterator，还可以在遍历过程中对集合进行增删改查动作


传统for和高级for有什么区别呢？
高级for有一个局限性，必须有便利的目标
建议在遍历数组的时候，还是希望使用传统for，因为传统for可以定义脚标


*/
import java.util.*;
public class Demo{
    public static void main(String[] args){
    
        ArrayList<String> al = new ArrayList<String>();
        al.add("sdfsda");
        al.add("afs");
        al.add("sd");
        for(String s : al){
            sop(s);
        }
        
        HashMap<Integer,String> hm = new HashMap<Integer,String>();
        hm.put(1,"1");
        hm.put(2,"2");
        hm.put(3,"3");
        hm.put(4,"4");
        Set<Integer> keyset = hm.keySet();
        for(Integer i : keyset){
            sop(hm.get(i));
        }
        
        Set<Map.Entry<Integer,String>> entryset = hm.entrySet();
        for(Map.Entry<Integer,String> me : entryset){
            sop(me.getKey()+":"+me.getValue());
        }
    }
    public static void sop(Object obj){
        System.out.println(obj);
    }
}

十、集合(可变参数)

/*
JDK 1.5 版本出现的新特性
方法的可变参数
注意：
可变参数一定要定义在函数参数的末尾
*/
import java.util.*;
public class Demo{
    public static void main(String[] args){
        //比如要调用一个函数，传入的参数格式类型，一样，但是个数不一样，普通方式是重载，很麻烦
        //所以应该传入一个数组，但是自己定义一个数组也麻烦，所以java有了这种 函数参数定义方法接收  public static void show(int... arr){
        /*
            可变数组，
            其实就是上一种数组参数的简写形式
            不用每一次都手动的建立数组对象
            只要将操作的元素作为参数传递即可
            隐式将这些参数封装成数组
            可以传入空参数，0长度数组
        */
        
    }
    
    //public static void show(int... arr,String a ){ 错误
    //public static void show(String a ，int... arr){正确
    public static void show(int... arr){
        
    }
    // public static void show(int[] arr){
        
    // }
    public static void sop(Object obj){
        System.out.println(obj);
    }
}

十一、集合(静态导入)

/*
JDK 1.5 版本出现的新特性
StaticImport  集合(静态导入)
*/
import java.util.*;
import static java.util.Arrays.*;//导入的是Arrays这个类中所有的静态成员，使用的时候，可以直接写方法，不用写类名
//但是可能方法重名，比如，Arrays中有toString(),object中也有toString ，要使用 类名.方法名
//当类名重名时，需要指定具体的包名            import packa.*;  import packb.*;
//当方法重名时，指定具备所属的对象或者类
public class Demo{
    public static void main(String[] args){
        int[] arr = (3,1,5);
        Arrays.sort(sort);
        sop(Arrays.toString(arr));
    }
    public static void sop(Object obj){
        System.out.println(obj);
    }
}

若云_bai

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java基础17：集合工具类Collections；高级for循环；静态导入；可变参数

十、集合(Collections-sort)工具类public class Collectionsextends Object此类完全由在 collection 上进行操作或返回 collection 的静态方法组成。它包含在 collection 上操作的多态算法，即“包装器”，包装器返回由指定 collection 支持的新 collection，以及少数其他内容。 sta
复制链接

扫一扫