Java List 通用排序工具类

最新推荐文章于 2024-04-30 17:32:41 发布
置顶 最新推荐文章于 2024-04-30 17:32:41 发布
阅读量4.5k 收藏 11
点赞数 3
分类专栏： Java 文章标签： java compare Comparator 泛型
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xyj0808xyj/article/details/51814534
版权

场景：Java 类 需 重新排序，有时升序、有时倒序，有时是按照多字段排序

功能描述：

1.支持 对象的一个属性或多个属性进行排序.
2.支持 对象属性正序和倒序排列.

3.支持 数字字符类型的List排序

4.泛型实现，结合Comparable接口， 支持多类型数据格式 

代码：

package GenericTest;

import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Collections;
import java.util.Comparator;
import java.util.Date;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;


/**
 * [简述]:List通用排序工具类
 * User: xyj
 * Date:2016/7/2
 * Time:10:24
 * To change this template use File | Settings | File Templates.
 */
public class ListSortUtil {


    private static final String SORT_ASC = "asc";


    private static final String SORT_DESC = "desc";


    /**
     * [简述]： 对List数组排序
     * @param list 源数据 排序集合
     * @param sort 升序 还是 降序，默认升序
     * @return List
     */
    public static List<?> sort(List<?> list,final String sort){
        Collections.sort(list, new Comparator<Object>() {
            @Override
            public int compare(Object o1, Object o2) {
                int ret = 0;
                if(o1 instanceof Integer){
                    ret = ((Integer)o1).compareTo((Integer)o2);
                } else if(o1 instanceof Double){
                    ret = ((Double)o1).compareTo((Double)o2);
                } else if(o1 instanceof Long){
                    ret = ((Long)o1).compareTo((Long)o2);
                } else if(o1 instanceof Float){
                    ret = ((Float)o1).compareTo((Float)o2);
                } else if(o1 instanceof Date){
                    ret = ((Date)o1).compareTo((Date) o2);
                } else if(isDouble(String.valueOf(o1)) && isDouble(String.valueOf(o2))){
                    ret = (new Double(o1.toString())).compareTo(new Double(o2.toString()));
                } else {
                    ret = String.valueOf(o1).compareTo(String.valueOf(o2));
                }
                if(null != sort && SORT_DESC.equalsIgnoreCase(sort)){
                    return -ret;
                }else{
                    return ret;
                }
            }
        });
        return list;
    }


    /**
     *[简述]: List 泛型 排序
     * @param list 源数据 排序集合
     * @param field 排序的数据字段名称
     * @param sort 升序 还是 降序，默认升序
     * @param <T> 泛型T
     * @return List
     */
    public static <T> List<T> sort(List<T> list,final String field,final String sort){
        Collections.sort(list, new Comparator<T>() {
            @Override
            public int compare(T o1, T o2) {
                int ret = 0;
                try {
                    Method method1 = o1.getClass().getDeclaredMethod(getMethodName(field),null);
                    Method method2 = o2.getClass().getDeclaredMethod(getMethodName(field), null);
                    Field field1 = o1.getClass().getDeclaredField(field);
                    field1.setAccessible(true);
                    Class<?> type = field1.getType();
                    if(type == int.class){
                        ret = ((Integer)field1.getInt(o1)).compareTo((Integer)field1.getInt(o2));
                    } else if(type == double.class){
                        ret = ((Double)field1.getDouble(o1)).compareTo((Double)field1.getDouble(o2));
                    } else if(type == long.class){
                        ret = ((Long)field1.getLong(o1)).compareTo((Long)field1.getLong(o2));
                    } else if(type == float.class){
                        ret = ((Float)field1.getFloat(o1)).compareTo((Float)field1.getFloat(o2));
                    } else if(type == Date.class){
                        ret = ((Date)field1.get(o1)).compareTo((Date) field1.get(o2));
                    } else if(isDouble(String.valueOf(field1.get(o1))) && isDouble(String.valueOf(field1.get(o2)))){
                        ret = (new Double(method1.invoke(o1).toString())).compareTo(new Double(method2.invoke(o2).toString()));
                    } else {
                        ret = String.valueOf(field1.get(o1)).compareTo(String.valueOf(field1.get(o2)));
                    }


                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                } catch (NoSuchFieldException e) {
                    e.printStackTrace();
                } catch (NoSuchMethodException e) {
                    e.printStackTrace();
                } catch (InvocationTargetException e) {
                    e.printStackTrace();
                }
                if(null != sort && SORT_DESC.equalsIgnoreCase(sort)){
                    return  -ret;
                }else{
                    return ret;
                }
            }
        });
        return list;
    }


    private static boolean isDouble(String str){
        boolean flag = false;
        if(isInteger(str) || isFloat(str)){
            flag = true;
        }
        return flag;
    }


    private static boolean isInteger(String str){
        Matcher matcher = Pattern.compile("^[+-]?[0-9]+$").matcher(str);
        return matcher.find();
    }


    private static boolean isFloat(String str){
        return str.matches("[\\d]+\\.[\\d]+");
    }


    /**
     *[简述]: List 泛型 排序
     * @param list 源数据 排序集合
     * @param fields 排序的数据字段名称
     * @param sorts 升序 还是 降序
     * @param <T> 泛型T
     * @return List
     */
    public static <T> List<T> sort(List<T> list,final String [] fields,final String [] sorts){
        if(null != fields && fields.length > 0){
            for(int index = 0;index < fields.length;index ++){
                String sortRule = SORT_ASC;
                if(null != sorts && sorts.length >= index && null != sorts[index]){
                    sortRule = sorts[index];
                }
                final String sort = sortRule;
                final String field = fields[index];
                Collections.sort(list, new Comparator<T>() {
                    @Override
                    public int compare(T o1, T o2) {
                        int ret = 0;
                        try {
                            Method method1 = o1.getClass().getDeclaredMethod(getMethodName(field),null);
                            Method method2 = o1.getClass().getDeclaredMethod(getMethodName(field), null);
                            Field field1 = o1.getClass().getDeclaredField(field);
                            field1.setAccessible(true);
                            Class<?> type = field1.getType();
                            if(type == int.class){
                                ret = ((Integer)field1.getInt(o1)).compareTo((Integer)field1.getInt(o2));
                            } else if(type == double.class){
                                ret = ((Double)field1.getDouble(o1)).compareTo((Double)field1.getDouble(o2));
                            } else if(type == long.class){
                                ret = ((Long)field1.getLong(o1)).compareTo((Long)field1.getLong(o2));
                            } else if(type == float.class){
                                ret = ((Float)field1.getFloat(o1)).compareTo((Float)field1.getFloat(o2));
                            } else if(type == Date.class){
                                ret = ((Date)field1.get(o1)).compareTo((Date) field1.get(o2));
                            } else if(isDouble(String.valueOf(field1.get(o1))) && isDouble(String.valueOf(field1.get(o2)))){
                                ret = (new Double(method1.invoke(o1).toString())).compareTo(new Double(method2.invoke(o2).toString()));
                            } else {
                                ret = String.valueOf(field1.get(o1)).compareTo(String.valueOf(field1.get(o2)));
                            }


                        } catch (NoSuchMethodException e) {
                            e.printStackTrace();
                        } catch (InvocationTargetException e) {
                            e.printStackTrace();
                        } catch (IllegalAccessException e) {
                            e.printStackTrace();
                        } catch (NoSuchFieldException e) {
                            e.printStackTrace();
                        }
                        if(null != sort && SORT_DESC.equalsIgnoreCase(sort)){
                            return  -ret;
                        }else{
                            return ret;
                        }
                    }
                });
            }
        }
        return list;
    }


    private static String getMethodName(String str){
        StringBuffer name = new StringBuffer();
        name = name.append("get").append(firstLetterToCapture(str));
        return name.toString();
    }


    private static String firstLetterToCapture(String name){
        char[] arr = name.toCharArray();
        arr[0] -= 32;
        return String.valueOf(arr);
    }


}

测试类： 

package utils.ListSortTest;

import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.testng.AbstractTestNGSpringContextTests;
import org.testng.annotations.Test;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;

/**
 * Created by with IntelliJ IDEA.
 * User:xyj
 * Date:2016/7/11
 * Time:17:21
 * To change this template use File | Settings | File Templates.
 */
@ContextConfiguration("classpath:spring/applicationContext.xml")
public class TestListSort extends AbstractTestNGSpringContextTests{

    @Test
    public void testListSortNumberString(){
        List<String> arrays = new ArrayList<String>();
        arrays.add("2");
        arrays.add("13");
        arrays.add("4.5");
        arrays.add("26");
        List<String> afterSortArrays = (List<String>) ListSortUtil.sort(arrays, "asc");
        for(String s:afterSortArrays){
            System.out.println(String.valueOf(s));
        }
    }

    @Test
    public void testListSortString(){
        List<String> arrays = new ArrayList<String>();
        arrays.add("ac");
        arrays.add("cd");
        arrays.add("ab");
        arrays.add("bf");
        arrays.add("bfd");
        arrays.add("bg");
        arrays.add("ba");
        List<String> afterSortArrays = (List<String>) ListSortUtil.sort(arrays, "asc");
        for(String s:afterSortArrays){
            System.out.println(String.valueOf(s));
        }
    }

    @Test
    public void testListSortNumber(){
        List<Integer> arrays = new ArrayList<Integer>();
        arrays.add(12);
        arrays.add(56);
        arrays.add(2);
        arrays.add(-5);
        arrays.add(21);
        arrays.add(0);
        List<Integer> afterSortArrays = (List<Integer>) ListSortUtil.sort(arrays, "asc");
        for(Integer s:afterSortArrays){
            System.out.println(String.valueOf(s));
        }
    }

    @Test
    public void testListSortDouble() {
        List<Double> arrays = new ArrayList<Double>();
        arrays.add(-0.12);
        arrays.add(-0.102);
        arrays.add(12.0);
        arrays.add(0.0);
        arrays.add(9.2);
        arrays.add(-1.2);
        arrays.add(-1.20001);
        arrays.add(3.0);
        arrays.add(31.0);
        List<Double> afterSortArrays = (List<Double>) ListSortUtil.sort(arrays, "asc");
        for(Double s:afterSortArrays){
            System.out.println(String.valueOf(s));
        }
    }

    @Test
    public void testListSortDate(){
        List<Date> arrays = new ArrayList<Date>();
        arrays.add(DateUtil.parseDate("2015-01-12",DateUtil.DATE_FORMAT_EN));
        arrays.add(DateUtil.parseDate("2015-11-12",DateUtil.DATE_FORMAT_EN));
        arrays.add(DateUtil.parseDate("2015-12-12",DateUtil.DATE_FORMAT_EN));
        arrays.add(DateUtil.parseDate("2015-02-12",DateUtil.DATE_FORMAT_EN));
        arrays.add(DateUtil.parseDate("2015-06-12",DateUtil.DATE_FORMAT_EN));
        arrays.add(DateUtil.parseDate("2015-10-12",DateUtil.DATE_FORMAT_EN));
        arrays.add(DateUtil.parseDate("2015-10-31",DateUtil.DATE_FORMAT_EN));
        arrays.add(DateUtil.parseDate("2015-10-02",DateUtil.DATE_FORMAT_EN));
        List<Date> afterSortArrays = (List<Date>) ListSortUtil.sort(arrays, "asc");
        for(Date s:afterSortArrays){
            System.out.println(String.valueOf(DateUtil.date2Str(s,DateUtil.DATE_FORMAT_EN)));
        }
    }

}

测试类 Two:

package utils.ListSortTest;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.testng.AbstractTestNGSpringContextTests;
import org.testng.annotations.AfterClass;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.Test;

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

/**
 * Created by with IntelliJ IDEA.
 * User:xyj
 * Date:2016/7/11
 * Time:14:48
 * To change this template use File | Settings | File Templates.
 */

@ContextConfiguration("classpath:spring/applicationContext.xml")
public class TestListSortUtils extends AbstractTestNGSpringContextTests{

    private static final Logger logger = LoggerFactory.getLogger(TestListSortUtils.class);

    List<SysUser> sysUsers = new ArrayList<SysUser>();

    private List<SysUser> getUsers(){
        List<SysUser> sysUsers = new ArrayList<SysUser>();

        SysUser sysUser3 = new SysUser();
        sysUser3.setPkid("12");
        sysUser3.setLoginName("naver");
        sysUser3.setPassword("4");
        sysUser3.setContact("15153");
        sysUser3.setEnabled(2);
        sysUsers.add(sysUser3);

        SysUser sysUser2 = new SysUser();
        sysUser2.setPkid("3");
        sysUser2.setLoginName("Tex");
        sysUser2.setPassword("3");
        sysUser2.setContact("415151");
        sysUser2.setEnabled(2);
        sysUsers.add(sysUser2);

        SysUser sysUser0 = new SysUser();
        sysUser0.setPkid("1");
        sysUser0.setLoginName("tommy");
        sysUser0.setPassword("1");
        sysUser0.setContact("123456");
        sysUser0.setEnabled(1);
        sysUsers.add(sysUser0);

        SysUser sysUser1 = new SysUser();
        sysUser1.setPkid("2");
        sysUser1.setLoginName("tony");
        sysUser1.setPassword("2");
        sysUser1.setContact("5621232");
        sysUser1.setEnabled(1);
        sysUsers.add(sysUser1);

        return sysUsers;
    }

    @BeforeClass
    public void setInitBeforeSortList(){
        sysUsers = getUsers();
        logger.info("before sort ：");
        for(SysUser sysUser:sysUsers){
            logger.info("sysUser: pkid: [ " + sysUser.getPkid() + " ]"
                    + " userCode: [ "+ sysUser.getLoginName() + " ]"
                    + " contact: [ "+ sysUser.getContact() + " ]"
            );
        }
    }



    @Test
    public void testListSort(){
        List<SysUser> afterSysUsers  = ListSortUtil.sort(sysUsers,"loginName",null);
        logger.info("after sort ：");
        for(SysUser sysUser:afterSysUsers){
            logger.info("sysUser: pkid: [ " + sysUser.getPkid() + " ]"
                    + " userCode: [ "+ sysUser.getLoginName() + " ]"
                     + " contact: [ "+ sysUser.getContact() + " ]"
            );
        }
    }

    @AfterClass
    public void destroy(){
        logger.info("运行结束！");
    }


}
测试 Three: 

package utils.ListSortTest;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.testng.AbstractTestNGSpringContextTests;
import org.testng.annotations.AfterClass;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.Test;

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

/**
 * Created by with IntelliJ IDEA.
 * User:xyj
 * Date:2016/7/11
 * Time:14:48
 * To change this template use File | Settings | File Templates.
 */

@ContextConfiguration("classpath:spring/applicationContext.xml")
public class TestListSortOrderUtils extends AbstractTestNGSpringContextTests{

    private static final Logger logger = LoggerFactory.getLogger(TestListSortOrderUtils.class);

    List<SysUser> sysUsers = new ArrayList<SysUser>();

    private List<SysUser> getUsers(){
        List<SysUser> sysUsers = new ArrayList<SysUser>();

        SysUser sysUser3 = new SysUser();
        sysUser3.setPkid("12");
        sysUser3.setLoginName("naver");
        sysUser3.setPassword("4");
        sysUser3.setContact("15153");
        sysUser3.setEnabled(2);
        sysUsers.add(sysUser3);

        SysUser sysUser2 = new SysUser();
        sysUser2.setPkid("3");
        sysUser2.setLoginName("Tex");
        sysUser2.setPassword("3");
        sysUser2.setContact("415151");
        sysUser2.setEnabled(2);
        sysUsers.add(sysUser2);

        SysUser sysUser0 = new SysUser();
        sysUser0.setPkid("1");
        sysUser0.setLoginName("tommy");
        sysUser0.setPassword("1");
        sysUser0.setContact("123456");
        sysUser0.setEnabled(1);
        sysUsers.add(sysUser0);

        SysUser sysUser1 = new SysUser();
        sysUser1.setPkid("2");
        sysUser1.setLoginName("tony");
        sysUser1.setPassword("2");
        sysUser1.setContact("5621232");
        sysUser1.setEnabled(1);
        sysUsers.add(sysUser1);

        return sysUsers;
    }

    @BeforeClass
    public void setInitBeforeSortList(){
        sysUsers = getUsers();
        logger.info("before sort ：");
        for(SysUser sysUser:sysUsers){
            logger.info("sysUser: pkid: [ " + sysUser.getPkid() + " ]"
                    + " userCode: [ "+ sysUser.getLoginName() + " ]"
                    + " contact: [ "+ sysUser.getContact() + " ]"
            );
        }
    }



    @Test
    public void testListSort(){
        List<SysUser> afterSysUsers  = ListSortUtil.sort(sysUsers,new String[] {"pkid","contact"},new String[] {"asc","desc"});
        logger.info("after sort ：");
        for(SysUser sysUser:afterSysUsers){
            logger.info("sysUser: pkid: [ " + sysUser.getPkid() + " ]"
                    + " userCode: [ "+ sysUser.getLoginName() + " ]"
                     + " contact: [ "+ sysUser.getContact() + " ]"
            );
        }
    }

    @AfterClass
    public void destroy(){
        logger.info("运行结束！");
    }


}


0808xyj
关注
  • 3
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
java list集合分类
weixin_42274773的博客
11-06 494
JDK1.8 新特性实现 List<Bean> list = new ArrayList<>(); for (int i = 0; i < 10; i++) { if (i % 2 == 0) { list.add(new Bean("小明", "7"+i,2)); ...
Java类列表总结
qq_23246143的博客
08-09 686
核心jar：rt.jar 类列表均是以个人见解总结，根据平时使用总结，总结不完全，还在补充中。。。 Lang类包 不需要借用包就可以使用的类 类Object java.lang.Object;//所有类的初始类 Object[]{}//一维数组单位，可以自身嵌套自身构成多维数组 wait();//进程等待 notify();//唤醒某个进程 notifyAll();//唤醒所有进程 getClass();//返回对象运行时类 类Boolean java.lang.Boolean;//布尔 类Enum
List 排序工具类
ws - 兮的博客空间
06-15 1647
按对象单字段属性排序 按多个字段属性 按方法排序 支持正序-倒序 支持时间，字符串，数字 工具类api // 按 age (Integer) ---> 1、正序排序 2、倒序排序 SortListUtil.sort(list, "age", null); SortListUtil.sort(list, "age", SortListUtil.DESC); ...
List集合中根据对象属性进行排序
lang09的博客
08-30 1840
//针对list多个属性排序,heartFlag ：心率；breatheFlag 呼吸 ;outOfBedFlag：离床 。outOfContactFlag：失 联(灰色) String[] sortNameArr = {"heartFlag","breatheFlag","outOfBedFlag","outOfContactFlag"}; //true升序，false降序 boolean[] isAscArr = {false,fa.
排序工具类（List动态字段排序）
最新发布
qq_22858799的博客
04-30 253
@param sort 需要进行排序的对象字段（需要含有相应的get方法）* @param order asc 正序，desc 反序。* @param chinese 是否中文拼音排序。* @param list 需要排序的列表。//获取指定字段的get方法名。* 对list进行排序。
List排序工具类，ListSortUtil
smile
04-17 1372
package com.fms.util; import java.lang.reflect.Field; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; import java.util.Collections; import java.util.Comparator; ...
对象数组根据字段排序工具类SortListUtil
踟蹰千年的博客
02-14 597
import java.lang.reflect.Field; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; import java.text.Collator; import java.util.Collections; import java.util.Comparat...
Java8中List排序--让代码更加优雅的排序方法
热门推荐
向死而生
08-13 5万+
在做wab项目中不免会做后台管理，后台最常见的就是表格了，这时候按照一般规则都会按照某个属性进行排序，像这种List<实体>类型的甚为常见。下面给大家分享三种按照属性中的某一个字段排序的例子，有用到的朋友自取~~
java.util.list.sort_List sort(Comparator<T> c)排序方法案例
weixin_35628777的博客
02-17 1371
listsort(Comparator super E> c)方法是java1.8提供的新方法，用于list集合排序，使用了Comparator比较器来比较，实现里面的compare方法，compareTo比较之后，返回的参数是int类型，0则表示相等，1表示大于，-1负数则表示小于。importjava.util.ArrayList;importjava.util.Comparato...
JAVA SortList 通用排序类
10-12
JAVA SortList 通用排序类 从网上搜到一个java 对 List 排序的工具，自己改了下 支持 整数 和 浮点数 比较后排序，浮点数小数部分的有点问题，期待大牛帮忙优化。
JAVA对list集合进行排序Collections.sort()
08-31
在Java编程语言中，`Collections.sort()` 方法是一个非常重要的工具，用于对List接口实现的集合进行排序。这个方法使得开发者能够方便地按照指定的顺序排列集合中的元素。本篇文章将详细探讨如何使用 `Collections....
Java对List进行排序的两种实现方法
08-31
然后，你可以使用List的`sort(Comparator<? super E> c)`方法或`Collections.sort(List<T> list)`工具类方法对List进行排序，如下所示： ```java List<Student> students = new ArrayList(); students.add(new ...
通用工具类
02-17
8.利用反射机制进行排序工具类，支持数组、List、Set、Map的排序，可以支持多属性排序，支持子对象中的属性排序（例user对象中的role的name属性进行排序，method="role.name"） 9.JVM参数获取工具 10.Java对象比较、...
java常用工具类的使用
03-19
在Java开发类库中，提供了很多工具类，我们即将学习最常见的工具类，比如对日期的操作，对集合的操作等。具体更多的工具类，请参考JavaDoc文档。 2. java.util.Date类 Date类包装了毫秒值，毫秒值表示自1970年1月1...
Java 分类上移/下移/拖拽排序工具类
weixin_43298522的博客
06-29 1783
前端 需要传被拖拽的对象的id,开始/结束后的下标索引[下标从0开始] /** * @param allList 排序序 的集合(跟列表顺序保持一致) * @param targetId 目标对象的Id * @param startIndex 对象在列表的开始索引值[索引值从0 开始] * @param endIndex 移动后的目标索引值[索引值从0 开始] * @param isAsc 集合列表 是否正序 TRUE 正序
【Java 8 新特性】Java List sort() 排序示例 | 列表自定义排序
猫巳的博客
09-16 1万+
@[TOC](Java List sort() 排序示例 | 列表自定义排序) sort是java.util.List接口的默认方法。 List的排序方法在Java 8中被引入。 1. 排序方法接受比较器作为参数，并根据指定的比较器对这个列表进行排序。 default void sort(Comparator<? super E> c) 2. 如果List中的元素是可比较的，即元素类实现了Comparable接口，那么我们可以把null传给sort方法，排序将按照自然排序进行。 3. 列表不
List工具类详解
上班摸鱼，下班躺平
04-28 1263
Collections是Java提供的一个工具类，主要用于操作集合类数据，提供了一系列静态方法，方便对集合进行排序、查找、替换等操作。Java提供的一个数组工具类，包含了许多静态方法，可以将数组转换成List、将List转换成数组、排序等操作。Java工具库，提供了许多实用的工具类和数据类型，包括集合、缓存、并发、字符串处理、IO等等。一个集合工具类，包含了许多静态方法，可以对List进行排序、查找、替换、反转、打乱等操作。方法将其初始化为一个空的不可变的列表。
hutool(列表工具-ListUtil)
madleep的博客
11-02 6235
List在集合中中使用最为频繁，因此新版本的Hutool中针对List单独封装了工具方法。其他方法与CollUtil工具类似，很多工具也有重复。
java List集合常用工具类
zhaoyang10的专栏
12-03 9045
比较一个list集合里是否有重复的值 /** * 比较一个list集合里是否有重复的值 最优法 * */ public static boolean isRepeat(List&amp;amp;amp;amp;amp;amp;amp;lt;Object&amp;amp;amp;amp;amp;amp;amp;gt; list) { Set&amp;amp;amp;amp;amp;amp;amp;lt;Object&amp;amp;amp;amp;amp;am
5_介绍 Java 的集合类
03-29
Java的集合类是一组用于管理和操作对象集合的类和接口。集合类的主要目的是提供一组常用的数据结构和算法，以便程序员可以更方便地处理数据。 Java的集合类主要分为两种：基于接口的集合类和基于实现的集合类。 1. 基于接口的集合类：这些集合类都是基于Java集合框架中提供的接口来实现的。这些接口包括List、Set、Queue和Map等。这些接口提供了通用的集合操作，如添加元素、删除元素、搜索元素等。 2. 基于实现的集合类：这些集合类是基于Java集合框架中提供的接口的实现来实现的。例如，ArrayList是List接口的一个实现，HashSet是Set接口的一个实现。 Java的集合类包括以下常用类和接口： 1. List接口：List是一个有序的集合，允许重复的元素。常用的List实现类包括ArrayList、LinkedList和Vector等。 2. Set接口：Set是一个无序的集合，不允许重复的元素。常用的Set实现类包括HashSet、TreeSet和LinkedHashSet等。 3. Map接口：Map是一个键值对的集合，每个键对应一个值。常用的Map实现类包括HashMap、TreeMap和LinkedHashMap等。 4. Queue接口：Queue是一个队列，用于存储元素，可以实现先进先出的操作。常用的Queue实现类包括LinkedList和PriorityQueue等。 5. Stack类：Stack是一个栈，用于存储元素，可以实现后进先出的操作。 6. Collections类：Collections是一个包含许多静态方法的工具类，用于操作集合。包括排序、查找、替换、反转等常用操作。 总之，Java的集合类提供了丰富的数据结构和算法，使得程序员可以更加方便地进行数据操作和处理。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值