精华内容
下载资源
问答
  • 2020-09-18 11:59:09

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

    list.add("111");

    list.add("222");

    list.add("333");

    list.add("444");

    //要截取的长度,先判断是否大于指定的长度,大于再截取,不然会报错

    //比如截取前三的数据

    if(list.size() > 3){

          list = list.subList(0, 3);//重新给list赋值

    }

     

     

    更多相关内容
  • Java LIst集合全解

    千次阅读 2021-05-08 08:40:23
    集合的优势: (1)数组存储的不足与缺陷: 长度开始必须执行,而且一旦指定,无法修改 ...Collection接口有两个重要的子接口List、Set,他们的实现子类都是单列集合 Map接口的实现子类是双列集合,存放K-

    集合的优势:

    (1)数组存储的不足与缺陷:

    1. 长度开始必须执行,而且一旦指定,无法修改
    2. 保存的必须为同一类型的元素
    3. 使用数组进行增加/删除操作比较麻烦

    (2)集合的好处:

    1. 可以动态保存多个对象,使用方便
    2. 提供了一系列方便的操作对象的方法,如add、remove、set、get等
    3. 使用集合增加/删除较方便

    集合的框架图 (重要)

    集合主要是两组:单列集合、双列集合

    Collection接口有两个重要的子接口List、Set,他们的实现子类都是单列集合

    Map接口的实现子类是双列集合,存放K-V 

     

    Collection 接口和常用方法

    1、Collection接口实现类的特点:

    public interface Collection<E> extends Iterable<E>

    1)Collection实现子类可以存放多个元素,每个元素可以是Object

    2)有些Collection的实现类,可以存放重复的元素,有些不可以

    3)有些Collection的实现类,可以是有序的(List), 有些也是无序的(Set)

    4)Collection接口没有直接的实现子类,是通过他的子接口Set和List来实现的

    2、Collection接口的常用方法,以实现子类ArrayList来演示:

    public class T {
        public static void main(String[] args) {
            List list = new ArrayList();
            //add添加元素
            list.add("jack");
            list.add(10);
            list.add(true);
            System.out.println("list = " + list);
            //remove 删除指定元素
            //list.remove(0); //删除第一个元素
            list.remove(true);
            //contains查找元素是否存在
            System.out.println(list.contains("jack"));
            //size:获取元素个数
            System.out.println(list.size());
            //isEmpty判断是否为空
            System.out.println(list.isEmpty());
            //clear 清空
            list.clear();
            System.out.println("list = " + list);
    
            //addAll添加多个元素
            ArrayList list2 = new ArrayList();
            list2.add("hlm");
            list2.add("sgyy");
            list.addAll(list2);
            System.out.println("list = " + list);
            //containsAll:判断多个元素是否存在
            System.out.println(list.containsAll(list2));
            //removeAll 删除多个元素
            list.add("lz");
            list.removeAll(list2);
            System.out.println("list = " + list);
        }
    
    }
    
    

    3、Collection接口遍历元素方式:

    (1)使用Iterator(迭代器):

    • Iterator对象称为迭代器,主要用于遍历Collection集合中的元素
    • 所有实现了Collection接口的集合类都有一个iterator()方法,用于返回一个实现了Iterator接口的对象,即可以返回一个迭代。
    • Iterator结构如图所示
    • Iterator仅用于遍历集合,Iterator本身不存放对象。

     

    public class CollectionIterator {
        @SuppressWarnings({"all"})
        public static void main(String[] args) {
            Collection col = new ArrayList();
            col.add(new Book("三国演义", "罗贯中", 10.1));
            col.add(new Book("小李飞刀", "古龙", 5.1));
            col.add(new Book("三红楼梦", "曹雪芹", 34.6));
    //        System.out.println("col : " + col);
            // 遍历集合:
            //1、 先得到col对应的迭代器
            Iterator iterator = col.iterator();
            //2、使用while循环遍历
            while(iterator.hasNext()) {
                //返回下一个元素, 类型是Object
                Object obj = iterator.next();
                System.out.println("obj=" + obj);
            }
            //快捷键,快速生成while =》 itit
    
        }
    }
    
    class Book {
        private String name;
        private String author;
        private double price;
    
        public Book(String name, String author, double price) {
            this.name = name;
            this.author = author;
            this.price = price;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public String getAuthor() {
            return author;
        }
    
        public void setAuthor(String author) {
            this.author = author;
        }
    
        public double getPrice() {
            return price;
        }
    
        public void setPrice(double price) {
            this.price = price;
        }
    
        @Override
        public String toString() {
            return "Book{" +
                    "name='" + name + '\'' +
                    ", author='" + author + '\'' +
                    ", price=" + price +
                    '}';
        }
    }
    

    (2)增强for循环(底层是iterator)

    基本语法:

    for(元素类型 元素名: 集合名/数组名){
        访问元素;
    }

    List 接口和常用方法

    1、List接口的特点

    • List集合类中元素有序(添加顺序和取出顺序一致),且可重复
    • List集合中的每个元素都有其对应的顺序索引,即支持索引
    • List容器中的元素都对应一个整数型的序号记载其在容器中的位置,额可以根据序号存取容器中的元素
    • JDK API中List接口的实现类非常多,常用的有ArrayList、Set、Vector

    2、List接口常用方法

    public class ListMethod {
        @SuppressWarnings({"all"})
        public static void main(String[] args) {
            List list = new ArrayList();
            list.add("张三丰");
            list.add("贾宝玉");
    //        void add(int index, Object ele):在index位置插入ele元素
            //在index = 1的位置插入一个对象
            list.add(1, "韩顺平");
            System.out.println("list=" + list);
    //        boolean addAll(int index, Collection eles):从index位置开始将eles中的所有元素添加进来
            List list2 = new ArrayList();
            list2.add("jack");
            list2.add("tom");
            list.addAll(1, list2);
            System.out.println("list=" + list);
    //        Object get(int index):获取指定index位置的元素
            //说过
    //        int indexOf(Object obj):返回obj在集合中首次出现的位置
            System.out.println(list.indexOf("tom"));//2
    //        int lastIndexOf(Object obj):返回obj在当前集合中末次出现的位置
            list.add("韩顺平");
            System.out.println("list=" + list);
            System.out.println(list.lastIndexOf("韩顺平"));
    //        Object remove(int index):移除指定index位置的元素,并返回此元素
            list.remove(0);
            System.out.println("list=" + list);
    //        Object set(int index, Object ele):设置指定index位置的元素为ele , 相当于是替换.
            list.set(1, "玛丽");
            System.out.println("list=" + list);
    //        List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex位置的子集合
            // 注意返回的子集合 fromIndex <= subList < toIndex
            List returnlist = list.subList(0, 2);
            System.out.println("returnlist=" + returnlist);
    
        }
    }

    3、List三种遍历方式(ArrayList、LinkedList,Vector):

    ArrayList底层结构和源码分析

    1、注意事项:

    • 允许存储所有元素,包括null,ArrayList可以加入一个或者多个null
    • ArrayList是由数组来实现数据存储的
    • ArrayList基本等同于Vector,除了ArrayList是线程不安全的(源码中没有synchronized关键字,执行效率高),在多线程的情况下不建议使用ArrayList

    2、ArrayList底层操作机制源码分析

    • ArrayList中维护了一个Object类型的数组elementData:
    transient Object[] elementData;//transient关键字表示,该属性不会被序列化
    •  当创建ArrayList对象的时候,如果使用的是无参构造器,则初始elementData容量为0,第一次添加,则扩容elementData为10,如需再次扩容, 则扩容elementData1.5倍
    • 如果使用的是指定大小的构造器,则初始化elementData容量为指定大小,如果需要扩容,则直接扩容elementData为1.5倍

     (1)无参与有参构造器创建和使用ArrayList源码分析:

    Vector底层结构和源码分析

    1、注意事项:

     2、Vector和ArrayList比较:

    3、Vector底层扩容:

    public class Vector_ {
        public static void main(String[] args) {
            //无参构造器
            //有参数的构造
            Vector vector = new Vector(8);
            for (int i = 0; i < 10; i++) {
                vector.add(i);
            }
            vector.add(100);
            System.out.println("vector=" + vector);
            //老韩解读源码
            //1. new Vector() 底层
            /*
                public Vector() {
                    this(10);
                }
             补充:如果是  Vector vector = new Vector(8);
                走的方法:
                public Vector(int initialCapacity) {
                    this(initialCapacity, 0);
                }
             2. vector.add(i)
             2.1  //下面这个方法就添加数据到vector集合
                public synchronized boolean add(E e) {
                    modCount++;
                    ensureCapacityHelper(elementCount + 1);
                    elementData[elementCount++] = e;
                    return true;
                }
              2.2  //确定是否需要扩容 条件 : minCapacity - elementData.length>0
                private void ensureCapacityHelper(int minCapacity) {
                    // overflow-conscious code
                    if (minCapacity - elementData.length > 0)
                        grow(minCapacity);
                }
              2.3 //如果 需要的数组大小 不够用,就扩容 , 扩容的算法
                  //newCapacity = oldCapacity + ((capacityIncrement > 0) ?
                  //                             capacityIncrement : oldCapacity);
                  //就是扩容两倍.
                private void grow(int minCapacity) {
                    // overflow-conscious code
                    int oldCapacity = elementData.length;
                    int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
                                                     capacityIncrement : oldCapacity);
                    if (newCapacity - minCapacity < 0)
                        newCapacity = minCapacity;
                    if (newCapacity - MAX_ARRAY_SIZE > 0)
                        newCapacity = hugeCapacity(minCapacity);
                    elementData = Arrays.copyOf(elementData, newCapacity);
                }
             */
    
        }
    }

    LinkedList:

    LinkedList说明:

    1. LinkedList底层实现了双向链表和双端队列的特点
    2. 可以添加任意元素(可以重复), 包括null
    3. 线程不安全,没有实现同步

    LinkedList底层机制

    1. LinkedList底层维护了一个双向链表
    2. LinkedList中维护了两个属性first和last分别指向首节点和尾节点
    3. 每个节点(Node对象),里面又维护了prev、next、item三个属性,其中prev指向前一个,通过next指向后一个节点,最终实现双向链表
    4. 所以LinkedList的元素添加和删除,不是通过数组实现的,相对来说效率较高

    LinkedList基本操作:

    public class LinkedListCRUD {
        public static void main(String[] args) {
    
            LinkedList linkedList = new LinkedList();
            linkedList.add(1);
            linkedList.add(2);
            linkedList.add(3);
            System.out.println("linkedList=" + linkedList);
    
            //演示一个删除结点的
            linkedList.remove(); // 这里默认删除的是第一个结点
            //linkedList.remove(2); //指定删除第几个元素
    
            System.out.println("linkedList=" + linkedList);
    
            //修改某个结点对象,按照索引
            linkedList.set(1, 999);
            System.out.println("linkedList=" + linkedList);
    
            //得到某个结点对象
            //get(1) 是得到双向链表的第二个对象
            Object o = linkedList.get(1);
            System.out.println(o);//999
    
            //因为LinkedList 是 实现了List接口, 遍历方式
            System.out.println("===LinkeList遍历迭代器====");
            Iterator iterator = linkedList.iterator();
            while (iterator.hasNext()) {
                Object next =  iterator.next();
                System.out.println("next=" + next);
    
            }
    
            System.out.println("===LinkeList遍历增强for====");
            for (Object o1 : linkedList) {
                System.out.println("o1=" + o1);
            }
            System.out.println("===LinkeList遍历普通for====");
            for (int i = 0; i < linkedList.size(); i++) {
                System.out.println(linkedList.get(i));
            }
    
    
            //老韩源码阅读.
            /* 1. LinkedList linkedList = new LinkedList();
                  public LinkedList() {}
               2. 这时 linkeList 的属性 first = null  last = null
               3. 执行 先进行装箱 再调用添加,
                   public boolean add(E e) {
                        linkLast(e);
                        return true;
                    }
                4.将新的结点,加入到双向链表的最后
                Node(Node<E> prev, E element, Node<E> next) {
                    this.item = element;
                    this.next = next;
                    this.prev = prev;
                }
    
                 void linkLast(E e) {
                    final Node<E> l = last;
                    final Node<E> newNode = new Node<>(l, e, null);
                    last = newNode;
                    if (l == null)
                        first = newNode;
                    else
                        l.next = newNode;
                    size++;
                    modCount++;
                }
    
             */
    
            /*
              老韩读源码 linkedList.remove(); // 这里默认删除的是第一个结点
              1. 执行 removeFirst
                public E remove() {
                    return removeFirst();
                }
             2. 执行
                public E removeFirst() {
                    final Node<E> f = first;
                    if (f == null)
                        throw new NoSuchElementException();
                    return unlinkFirst(f);
                }
              3. 执行 unlinkFirst, 将 f 指向的双向链表的第一个结点拿掉
                private E unlinkFirst(Node<E> f) {
                    // assert f == first && f != null;
                    final E element = f.item;
                    final Node<E> next = f.next;
                    f.item = null;
                    f.next = null; // help GC
                    first = next;
                    if (next == null)
                        last = null;
                    else
                        next.prev = null;
                    size--;
                    modCount++;
                    return element;
                }
             */
        }
    }

     ArrayList(线程不安全)和LinkedList(线程不安全)的比较:

     

    如何选择ArrayList和LinkedList:

    1)如果改查操作多,选择ArrayList

    2)如果增删操作多,选择LinkedList

    3)一般来说,在程序中,80%-90%都是查询,因此大部分情况下都会选择ArrayList

    4)在一个项目中,根据业务灵活选择。

    展开全文
  • javaList集合的两种赋值方式

    千次阅读 2021-02-05 20:11:19
    List转换 使用BeanUtils工具类 集合转换是不是也想使用copyProperties方法?对你想的没错,想对了一半 只不过要对copyProperties方法进行封装 像这样 /** * @param sources: 数据源类 * @param target: 目标类 * @...
    写在之前

    在开发中难免会有entity,vo,dto之间的转换那么如何优雅快速的进行转换呢?当然你可以get在set显然不推荐这样做!

    对象转换

    使用BeanUtils工具类copyProperties方法

    像这样

    //将merchantDTO赋值给entity(相同的属性)
    BeanUtils.copyProperties(merchantDTO,entity);
    

    使用mapstruct转换

    首先在项目中引入依赖

    <!--       MapStruct代码生成器,对象转换 -->
            <dependency>
                <groupId>org.mapstruct</groupId>
                <artifactId>mapstruct-jdk8</artifactId>
            </dependency>
            <dependency>
                <groupId>org.mapstruct</groupId>
                <artifactId>mapstruct-processor</artifactId>
                <version>${org.mapstruct.version}</version>
            </dependency>
    

    新建接口

    @Mapper//这里的mapper是包org.mapstruct.Mapper
    public interface AppCovert {
        AppCovert INSTANCE = Mappers.getMapper(AppCovert.class);
        /**
         * entity转dto
         */
        AppDTO entityTodto(App entity);
    
        /**
         * dto转entity
         * @param dto
         * @return
         */
        App dtoToEntity(AppDTO dto);
    }
    
    

    注:使用泛型支持所有类型的List转换
    使用

    //将entity转换为dto
    MerchantDTO merchantDTO = MerchantDetailConvert.INSTANCE.entityTodto(merchantInfo);
    

    List转换

    使用BeanUtils工具类

    集合转换是不是也想使用copyProperties方法?对你想的没错,想对了一半
    只不过要对copyProperties方法进行封装
    像这样

     /**
         * @param sources: 数据源类
         * @param target: 目标类
         * @return 赋值后的list
         */
        public static <S, T> List<T> copyListProperties(List<S> sources, Supplier<T> target, BeanCopyUtilCallBack<S, T> callBack) {
            List<T> list = new ArrayList<>(sources.size());
            for (S source : sources) {
                T t = target.get();
                BeanUtils.copyProperties(source, t);
                list.add(t);
            }
            return list;
        }
    

    使用

     List<Merchant> entity = new ArrayList<>();
            Merchant merchant = new Merchant();
            entity.add(merchant);
            List<MerchantDTO> ts = BeanCopyUtil.copyListProperties(entity, MerchantDTO::new);
    

    使用mapstruct转换

    定义接口

    @Mapper
    public interface AppCovert {
    AppCovert INSTANCE = Mappers.getMapper(AppCovert.class);
        /**
         * entityList转dtoList
         * @param app
         * @return
         */
        List<AppDTO> listEntityToDto(List<App> app);
    
    }
    
    

    使用

    List<App> apps = new ArrayList<>();
    List<AppDTO> appDtos = AppCovert.INSTANCE.listEntityToDto(apps);
    

    对比BeanUtils工具类,mapstruct对象转换显得比较繁琐!

    展开全文
  • java list集合元素根据某些字段排序

    千次阅读 2021-03-17 03:52:46
    一、jdk1.6的环境下新建ComparatorSort类,并实现Comparator接口,重写compare方法降序排序:o1的元素>o2的元素,并返回-1;o1的元素小于o2的元素,并返回1升序排序...import java.util.Comparator;import app.com...

    一、jdk1.6的环境下

    新建ComparatorSort类,并实现Comparator接口,重写compare方法

    降序排序:o1的元素>o2的元素,并返回-1;o1的元素小于o2的元素,并返回1

    升序排序:o1的元素>o2的元素,并返回1;o1的元素小于o2的元素,并返回-1

    在方法中可对多个元素进行判断。

    import java.util.Comparator;

    import app.component.app.entity.AppProjectContRankVo;

    public class ComparatorSort implements Comparator {

    @Override

    public int compare(AppProjectContRankVo o1, AppProjectContRankVo o2) {

    if(o1.getOverdueRatio().compareTo(o2.getOverdueRatio())==1){

    return -1;

    }else if(o1.getOverdueRatio().compareTo(o2.getOverdueRatio())==-1){

    return 1;

    }else{

    return 0;

    }

    }

    }

    然后对需要排序的集合执行collections.sort

    Collections.sort(conBalCountByOrgNoList,new ComparatorSort());

    二、jdk1.8环境下

    可使用stream进行排序

    多条件排序使用:thenComparing

    降序排序使用:reversed()

    List list = new ArrayList();

    User user1 = new User();

    user1.setAge(19);

    user1.setScore(29);

    list.add(user1);

    User user2 = new User();

    user2.setAge(65);

    user2.setScore(322);

    list.add(user2);

    User user3 = new User();

    user3.setAge(19);

    user3.setScore(89);

    list.add(user3);

    List listSort = list.stream().sorted(Comparator.comparing(User::getAge).reversed().thenComparing(User::getScore)).collect(Collectors.toList());

    for(User u:listSort){

    System.out.println(u.getAge()+"|"+u.getScore());

    }

    Java Map集合按照key和value排序之法

    一.理论基点 Map是键值对的集合接口,它的实现类主要包括:HashMap,TreeMap,Hashtable以及LinkedHashMap等. TreeMap:基于红黑树(Red-Black-Tre ...

    Java&colon;List集合内的对象进行排序

    List集合中的对象进行排序,除了for外,还有java的Collections对象来对摸个集合进行排序的用法. 比如说我有一个List集合,集合元素为: public class TaskAutoE ...

    java数组集合元素的查找

    java数组和集合的元素查找类似,下面以集合为例. 数组集合元素查找分为两类: 基本查找: 二分折半查找: 基本查找: 两种方式都是for循环来判断,一种通过索引值来判断,一种通过数组索引判断. 索引 ...

    Java依据集合元素的属性,集合相减

    两种方法:1.集合相减可以使用阿帕奇的一个ListUtils.subtract(list1,list2)方法,这种方法实现必须重写集合中对象的属性的hashCode和equals方法,集合相减判断的会 ...

    java 判断集合元素唯一的原理

    一 ArrayList的contains方法判断元素是否重复原理 ArrayList的contains方法会使用调用方法时,传入的元素的equals方法依次与集合中的旧元素 所比较,从而根据返回的布尔 ...

    Java基础知识强化之集合框架笔记47:Set集合之TreeSet保证元素唯一性和比较器排序的原理及代码实现(比较器排序:Comparator)

    1. 比较器排序(定制排序) 前面我们说到的TreeSet的自然排序是根据集合元素的大小,TreeSet将它们以升序排列. 但是如果需要实现定制排序,比如实现降序排序,则要通过比较器排序(定制排序)实 ...

    java的list集合如何根据对象中的某个字段排序?

    转自:http://blog.csdn.net/wangjuan_01/article/details/51351633 List集合按某个字段排序 package wjtest_01; import ...

    Java基础知识强化之集合框架笔记44:Set集合之TreeSet保证元素唯一性和自然排序的原理和图解

    1. TreeSet保证元素唯一性和自然排序的原理和图解 2. TreeSet唯一性以及有序性底层剖析: 通过观察TreeSet的add()方法,我们知道最终要看TreeMap的put()方法. 跟踪 ...

    Java:集合,对列表(List)中的自定义对象按属性(字段)排序(正序、倒序)的方法

    1. 要求 对列表(List)中的自定义对象,要求能够按照对象的属性(字段)进行排序(正序.倒序). 如:用户对象(Member)有用户名(username).级别(level).出生日期(birth ...

    随机推荐

    提高PHP代码质量的36个技巧

    1.不要使用相对路径 常常会看到: require_once('../../lib/some_class.php'); 该方法有很多缺点: 它首先查找指定的php包含路径, 然后查找当前目录. 因此会 ...

    MySql unique的实现原理简析

    1.测试过程如下: CREATE TABLE `test` ( `id` ) NOT NULL AUTO_INCREMENT, `name` ) DEFAULT NULL, PRIMARY KEY ( ...

    Cordova 打包 Android release app 过程详解

    Cordova 打包 Android release app 过程详解 时间 -- :: SegmentFault 原文 https://segmentfault.com/a/119000000517 ...

    IIS SMTP Queue stuck

    1. review smtp logs in C:\Windows\System32\LogFiles\SMTPSVC1, 2. find 421 error 2014-12-08 02:02:40 ...

    CSDN中根据文章自动生成文章目录

    概述 CSDN中有根据文件内容中H标签在文章中自动生成文章目录,看起来比较专业,就想把它搬到自己的博客园中.类似下图 提取JS脚本 通过浏览器开发者工具(IE/Chrome)找到产生文章目录javas ...

    UserAgentStringLibrary

    It is at WebWorkContext.CurrentCustomer's part. //check whether request is made by a search engine / ...

    Sublime themes&sol; lint themes setup

    [Sublime 3 Setup for ES6 / Babel] https://www.youtube.com/watch?v=L8nmOqyyJLA [config oceanic next t ...

    grep 及正则表达式

    grpe 及正则表达式 文本查找的需要:grep,egrep,fgrepgrep: 根据模式,搜索文本,并将符合模式的文本行显示出来.Pattern : 文本字符以及正则表达式的元字符组合而成的匹配条 ...

    c&sol;c&plus;&plus; linux 进程间通信系列5,使用信号量

    linux 进程间通信系列5,使用信号量 信号量的工作原理: 由于信号量只能进行两种操作等待和发送信号,即P(sv)和V(sv),他们的行为是这样的: P(sv):如果sv的值大于零,就给它减1:如果 ...

    展开全文
  • Java List集合Stream流的使用(常用方法)

    千次阅读 2020-09-19 16:02:12
    引言:Java stream流在对集合的操作中提供了很多非常好用的方法,下面的这些方法是在开发中比较常用的,可以实现对集合数据的过滤、查找、求和等等。 1、按条件查找,找到了返回一个对象,反之返回null // 查找id为...
  • Java List集合实现倒倒序排列

    千次阅读 2019-12-02 21:02:39
    Collections.reverse(dataList);
  • java List集合中元素移除的几种方法整理: /** * @author zly * @date 2020/6/29 10:23 */ public class Test { /** * 集合移除元素实现 */ public static void main(String[] args) { List<String>...
  • java list集合去重的两种方式

    万次阅读 2018-09-09 00:12:17
    package test; import java.util.ArrayList;...import java.util.List; import java.util.Set; public class Test { public static void main(String[] args) { List&lt;String&gt; ...
  • Java List集合数据修改

    万次阅读 2018-06-03 21:42:02
    为了方便,我写的读取Excel的工具类返回的是Map类型数据,map里面放入List集合,通过返回的List集合获取数据,这样我就可以获取很多类型的数据而不必局限于返回值类型 这里是我循环赋值的语句: public Map,...
  • java list集合按日期分组

    千次阅读 2020-03-06 16:11:57
    结果: { "code": 1, "data": { "mapDate": [ { "fomTime": "2019-11-14", "list": [ { "id": 0, "userId": 1, "viewerId": 3, ...
  • StringUtils.strip(word.toString(),"[]") //第一个参数放集合,第二个参数去掉中括号"[]" StringUtils工具类代码: package com.ktamr.common.utils; import com.ktamr.common.core.text.St...
  • Java list集合转换Map集合

    千次阅读 2020-07-30 19:12:53
    Java list集合转换Map集合 在我们平常处理数据的时候,常常需要将list集合转换为Map集合,其中的key可以是list集合元素对象中的某个唯一属性,以此作为key,对象作为value,方便后续处理的时候,对于相同key的对象...
  • JAVA List集合导出为CSV

    千次阅读 2017-09-28 16:19:00
    下载Jar包该方法需要调用一个名为javacsv.jar的包,下载地址为 http://central.maven.org/maven2/net/sourceforge/javacsv/javacsv/2.0/javacsv-2.0.jar2.代码部分public static <T> void writeCSV(Collectio
  • Java List集合转换为String[]数组

    万次阅读 2018-12-13 21:51:14
    今天遇到一个极端的情况,Swing...集合,需要把String集合转换String数组,马上想到了toArray()函数,但是直接使用toArray()函数返回的Object[]数组,就需要使用toArray(T[] argo); eg:  List&lt;String&...
  • //用于排序处理的实体类,可以根据具体的属性参数和降序升序参数来动态处理list集合对象的数据 package com.compile; import java.util.Comparator; public class ComparatorUser implements ...
  • Java List集合分割

    千次阅读 2019-07-19 13:40:21
    Java List集合分割 在某些业务场景里,我们需要将一个大的List集合分割成多个小的集合,将小的集合作为业务参数的入参 1.代码如下 import java.util.ArrayList; import java.util.Collections; import java.util....
  • JAVA List集合取交集并集差集

    万次阅读 2018-03-23 17:00:20
    //并集 //list1.addAll(list2); //交集 //list1.retainAll(list2); //差集 //list1.removeAll(list2);
  • java list集合排序按某一属性排序

    千次阅读 2018-06-13 17:08:55
    public List&lt;FreightM&gt; sortList(List&lt;FreightM&gt; list){ Collections.sort(list, new Comparator&lt;FreightM&gt;(){ @Override public int compare(FreightM o1,...
  • Java集合------List集合

    千次阅读 2021-03-14 01:23:04
    public interface List extends Collection {}是一个有序的允许重复的集合,可以通过索引查找list中的具体元素。在开发中常用实现类有:ArrayList、LinkedList、Vector:ArrayList 是一个数组队列,相当于动态数组。...
  • java list集合中有几十万条数据,每900条为一组取出/** * 实现javalist集合中有几十万条数据,每900条为一组取出 * @param list 可穿入几十万条数据的List * @return map 每一Kye中有900条数据的List */ @...
  • JavaList集合的遍历

    千次阅读 2021-11-12 17:36:30
    List集合Java日常开发中是必不可少的,只要懂得运用各种各样的方法就可以大大提高我们开发的效率,适当活用各种方法才会使我们开发事半功倍。  本文总结了三种List集合的遍历方式,下面将依次进行介绍。 二、...
  • JavaList集合排序

    千次阅读 2021-06-08 10:38:30
    1.单属性变量集合排序,如LIst<Integer> List<Integer> intList = new ArrayList<>(); intList.add(54); intList.add(7674); intList.add(636); intList.add(4325); intList.add(21); ...
  • Java List 集合去除null元素

    万次阅读 2018-03-05 11:03:30
    一、使用 for 循环处理集合 思路:这种处理方式是把要处理的集合进行遍历,取出其中不为空的元素,添加到新的集合中 public static &lt;T&gt; List&lt;T&gt; removeNull(List&lt;...
  • JAVA List集合取最大最小元素

    千次阅读 2020-01-07 20:19:43
    List<Integer> list = new ArrayList<Integer>(); Collections.addAll(list, 4, 8, 6); 取最小元素 int min = Collections.min(list); 取最大元素 int max = Collections.max(list); ...
  • import java.util.ArrayList;...import java.util.List; /** * 项目名称:Test * 类名称:CollectionTest.java * 类描述: * 创建人:beyond * 创建时间:2016年4月1日 下午2:17:05 ...
  • Java删除List集合中元素的方法

    千次阅读 2021-11-12 16:05:11
    先初始化一个List集合 List list = new ArrayList(){ {add(1); add(2); add(3); }}; 1、增强for循环 错误示范 for (Integer i : list) { list.remove(i); } 这样做会抛出异常,因为不允许在元素被使用的时候同时被...
  • java List集合中contains方法

    万次阅读 2018-12-29 09:58:00
    今天在用ArrayList类的caontains方法是遇到了问题,我写了一个存放User类的ArrayList ,但在调用list.contains(user)时总是返回false。 去看了下ArrayList的源码,源码如下:  Java代码 public boolean contains...
  • 由于List元素可以重复,去重用循环很low,但由于Set是不可重复的,所以可借用set进行去重 ... * list1 -- 未去重的集合  * list2 -- 去重后的集合  *   * */      List&lt;String&gt; list1 = new ...
  • java List集合常用工具类

    千次阅读 2018-12-03 15:40:39
    比较一个list集合里是否有重复的值 /** * 比较一个list集合里是否有重复的值 最优法 * */ public static boolean isRepeat(List&amp;amp;amp;amp;amp;amp;amp;lt;Object&amp;amp;amp;amp;amp;amp;amp;gt;...
  • java list集合中元素删除方法小结

    千次阅读 2017-11-07 11:10:00
    印象中循环删除list中的元素使用for循环的方式是有问题的,但是可以使用增强的for... JAVA中循环遍历list有三种方式for循环、增强for循环(也就是常说的foreach循环)、iterator遍历。   1、for循环遍历list fo

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 692,819
精华内容 277,127
关键字:

javalist集合

java 订阅