JAVA中集合的英文单词 java中集合的使用

转载

mob64ca13f937ae 2023-08-16 19:52:43

文章标签 JAVA中集合的英文单词集合 java List System 文章分类 Java 后端开发

Collections

1.sort(Comparator<? super E>):void List 对集合中的元素排序：
 2.reverse(List<?>):void 反转集合中的元素：
 3.shuffle(List<?>):void 打乱元素中的元素：
 4.fill(List<? super T>,T):void 用T元素替换掉集合中的所有的元素：
 5.copy(List<? super T>,List<? extend T>):void 复制并覆盖相应索引的元素:
 6.min/max(Collection<? extends T>):T 找到集合中最大/小的元素:
 7.swap(List<?>,int,int):void 交换集合中指定元素索引的位置:
 8.rotate(List<?>,int):void 集合中的元素向后移m个位置，在后面被遮盖的元素循环到前面来.
 9.indexOfSubList(List<?>,List<?>):int / lastIndexOfSubList(List<?>,List<?>):int 找出参数2在参数1第一次出现的位置：
 10.replaceAll(List,T,T):boolean 替换成指定的元素：
 11.synchronizedXxx方法 可以将某集合转化成线程安全的容器之后再使用：
 12.unmodifiableCollection(Collection<? extends T>):Collection将集合变为不可修改：

Guava

依赖

<dependency>
    <groupId>com.google.guava</groupId>
    <artifactId>guava</artifactId>
    <version>30.1.1-jre</version>
</dependency>
 1.BiMap提供了一种key和value双向关联的数据结构
2.Multimap提供了将一个键映射到多个值的形式
3.RangeMap描述了一种从区间到特定值的映射关系，让我们能够以更为优雅的方法来书写代码
4.ClassToInstanceMap是一个比较特殊的Map，它的键是Class，而值是这个Class对应的实例对象
5.Joiner指定分隔符关联集合，可以过滤空值
6.Splitter可以对字符串进行分割，其分割的方式有两种——按字符/字符串分割和按正则进行分割，结果是集合

Hutool

依赖

<dependency>
     <groupId>cn.hutool</groupId>
     <artifactId>hutool-all</artifactId>
     <version>4.5.15</version>
 </dependency> MapUtil，针对Map的一一列工具方法的封装
 .isEmpty、isNotEmpty 判断Map为空和非空方法，空的定义为null或没有值
 .newHashMap 快速创建多种类型的HashMap实例
 .createMap 创建自定义的Map类型的Map
 .of 此方法将一个或多个键值对加入到一个新建的Map中
 .toListMap 行转列，合并相同的键，值合并为列表
 .toMapList 列转行。将Map中值列表分别按照其位置与key组成新的map
 .join、joinIgnoreNull 将Map按照给定的分隔符转换为字符串
 .filter 1、过滤出需要的对象，如果返回null表示这个元素对象抛弃 2、修改元素对象，返回集合中为修改后的对象
 .reverse Map的键和值互换
 .sort 排序Map
 .getAny 获取Map的部分key生成新的Map
 .get、getXXX 获取Map中指定类型的值
集合工具-CollUtil
 1. join 方法 将集合转换为字符串
 2. sortPageAll 将给定的多个集合放到一个列表（List）中，根据给定的Comparator对象排序，然后分页取数据
 3.newHashMap、newHashSet、newArrayList方法 这些方法是新建相应的数据结构
 4.sub方法 对集合切片，其他类型的集合会转换成List
 5.zip方法 给定两个集合，然后两个集合中的元素一一对应

常用操作

1.8以前map操作

按照value排序

// Map的value值降序排序
    public static <K, V extends Comparable<? super V>> Map<K, V> sortDescend(Map<K, V> map) {
        List<Map.Entry<K, V>> list = new ArrayList<>(map.entrySet());
        Collections.sort(list, new Comparator<Map.Entry<K, V>>() {
            @Override
            public int compare(Map.Entry<K, V> o1, Map.Entry<K, V> o2) {
                int compare = (o1.getValue()).compareTo(o2.getValue());
                return -compare;
            }
        });
 
        Map<K, V> returnMap = new LinkedHashMap<K, V>();
        for (Map.Entry<K, V> entry : list) {
            returnMap.put(entry.getKey(), entry.getValue());
        }
        return returnMap;
    }
 
    // Map的value值升序排序
    public static <K, V extends Comparable<? super V>> Map<K, V> sortAscend(Map<K, V> map) {
        List<Map.Entry<K, V>> list = new ArrayList<Map.Entry<K, V>>(map.entrySet());
        Collections.sort(list, new Comparator<Map.Entry<K, V>>() {
            @Override
            public int compare(Map.Entry<K, V> o1, Map.Entry<K, V> o2) {
                int compare = (o1.getValue()).compareTo(o2.getValue());
                return compare;
            }
        });
 
        Map<K, V> returnMap = new LinkedHashMap<K, V>();
        for (Map.Entry<K, V> entry : list) {
            returnMap.put(entry.getKey(), entry.getValue());
        }
        return returnMap;
    }

  /**
     * 利用Collections.sort 对map排序
     */
    public void testSort(){
        List<Map.Entry<String, Integer>> res = new ArrayList();
        Map<String,Integer> map=new HashMap<>();
        for(Map.Entry<String, Integer> entry : map.entrySet()) {
            res.add(entry);
        }
        Collections.sort(res, new Comparator<Map.Entry<String, Integer>>(){
            public int compare(Map.Entry<String, Integer> e1, Map.Entry<String, Integer> e2) {
                if(e2.getValue() != e1.getValue()) {
                    return e1.getValue() - e2.getValue();
                } else {
                    return e1.getKey().compareTo(e2.getKey());
                }
            }
        });
    }

  // map截取
    public static <K, V extends Comparable<? super V>> Map<K, V> subMap(Map<K, V> map,int subN) {
        Map<K, V> returnMap = new LinkedHashMap<K, V>();
        int i=0;
        for (Map.Entry<K, V> entry : map.entrySet()) {
            if(++i>subN){
                break;
            }
            returnMap.put(entry.getKey(),entry.getValue());
        }
        return returnMap;
    }

按照key排序

public static void main(String[] args) {
        TreeMap<Student2,String> treeMap = new TreeMap<>(new Comparator<Student2>() {
            @Override
            public int compare(Student2 o1, Student2 o2) {
                // 基本和key实现Comparable接口，重写compareTo方法一致
                // 升序排序就是这么写的
                if(o1.getAge() > o2.getAge()){
                    return 1;
                }else if(o1.getAge() < o2.getAge()){
                    return -1;
                }
                // 相等的时候不能返回0
                return o1.getAge();
            }
        });
        treeMap.put(new Student2("大哥",24),"大哥");
        treeMap.put(new Student2("二哥",23),"二哥");
        treeMap.put(new Student2("三哥",22),"三哥");
        treeMap.put(new Student2("四哥",21),"四哥");
        Set<Student2> studentSet = treeMap.keySet();
        for (Student2 student : studentSet) {
            System.out.println(student.toString());
        }
    }

1.8以后对map排序

import com.alibaba.fastjson.JSON;
import java.util.*;
import java.util.stream.Collectors;
 
/**
 * Hello world!
 *
 */
public class App {
    public static void main( String[] args ) {
        Map<String,Integer> mapRepeat = new HashMap<>();
        mapRepeat.put("aa", 1);
        mapRepeat.put("bb", 45);
        mapRepeat.put("cc", 32);
        mapRepeat.put("dd", 226);
        mapRepeat.put("ee", 16);
        mapRepeat.put("ff", 320);
        mapRepeat.put("gg", 99);
 
        // 1.8以后 使用lambda表达式和Stream处理
        // 1.对Map的value进行降序排序，并取前5个key
        List<String> mobileList = mapRepeat.entrySet().stream()
                .sorted((Map.Entry<String, Integer> e1, Map.Entry<String, Integer> e2) -> e2.getValue() - e1.getValue())
                .map(entry -> entry.getKey()).collect(Collectors.toList())
                .subList(0, 5);
        System.out.println(JSON.toJSONString(mobileList));
 
 
        // 2、正向对Map的value排序并将结果输出到LinkedHashMap
        final Map<String, Integer> sortedByCount1 = mapRepeat.entrySet()
                .stream()
                .sorted(Map.Entry.comparingByValue())
                .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (e1, e2) -> e1, LinkedHashMap::new));
        System.out.println(JSON.toJSONString(sortedByCount1));
 
        // 3、反向 reversed对Map的value排序并将结果输出到LinkedHashMap
        final Map<String, Integer> sortedByCount2 = mapRepeat.entrySet()
                .stream()
                .sorted((Map.Entry.<String, Integer>comparingByValue().reversed()))
                .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (e1, e2) -> e1, LinkedHashMap::new));
        System.out.println(JSON.toJSONString(sortedByCount2));
 
 
        // 4.正向 Comparator 对Map的value排序并将结果输出到LinkedHashMap
        final Map<String, Integer> sortedByCount3 = mapRepeat.entrySet()
                .stream()
                .sorted((e1, e2) -> e1.getValue().compareTo(e2.getValue()))
                .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (e1, e2) -> e1, LinkedHashMap::new));
        System.out.println(JSON.toJSONString(sortedByCount3));
 
 
        //反向 Comparator 对Map的value排序并将结果输出到LinkedHashMap
        final Map<String, Integer> sortedByCount4 = mapRepeat.entrySet()
                .stream()
                .sorted((e1, e2) -> e2.getValue().compareTo(e1.getValue()))
                .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (e1, e2) -> e1, LinkedHashMap::new));
        System.out.println(JSON.toJSONString(sortedByCount4));
 
        // 1.8以前
        List<Map.Entry<String, Integer>> list1 = new ArrayList<>();
        list1.addAll(mapRepeat.entrySet());
        Collections.sort(list1, new Comparator<Map.Entry<String, Integer>>() {
            @Override
            public int compare(Map.Entry<String, Integer> o1, Map.Entry<String, Integer> o2) {
                return o1.getValue() - o2.getValue();
            }
        });
        for (Map.Entry<String, Integer> entry : list1) {
            System.out.println("key:" + entry.getKey() + ",value:" + entry.getValue());
        }
    }
}

List操作

/**
 * 将一组数据固定分组，每组n个元素
 * @param source 要分组的数据源
 * @param n      每组n个元素
 * @param <T>
 * @return
 */
public static <T> List<List<T>> fixedGrouping(List<T> source, int n) {

    if (null == source || source.size() == 0 || n <= 0)
        return null;
    List<List<T>> result = new ArrayList<List<T>>();

    int sourceSize = source.size();
    int size = (source.size() / n) + 1;
    for (int i = 0; i < size; i++) {
        List<T> subset = new ArrayList<T>();
        for (int j = i * n; j < (i + 1) * n; j++) {
            if (j < sourceSize) {
                subset.add(source.get(j));
            }
        }
        result.add(subset);
    }
    return result;
}

/**
 * 将一组数据平均分成n组
 *
 * @param source 要分组的数据源
 * @param n      平均分成n组
 * @param <T>
 * @return
 */
public static <T> List<List<T>> averageAssign(List<T> source, int n) {
    List<List<T>> result = new ArrayList<List<T>>();
    int remainder = source.size() % n;  //(先计算出余数)
    int number = source.size() / n;  //然后是商
    int offset = 0;//偏移量
    for (int i = 0; i < n; i++) {
        List<T> value = null;
        if (remainder > 0) {
            value = source.subList(i * number + offset, (i + 1) * number + offset + 1);
            remainder--;
            offset++;
        } else {
            value = source.subList(i * number + offset, (i + 1) * number + offset);
        }
        result.add(value);
    }
    return result;
}

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。