精华内容
下载资源
问答
  • Java 对象集合

    千次阅读 2018-08-13 19:56:34
    java 对象集合 1.JDK中对象集合和相关接口 JDk中主要集合类型主要分为以下四种; set:无序不可重复集合 list:有序可重复集合 map:具有映射关系集合 queue:具有队列性质集合 集合相关接口和类: ...

    java 对象集合

    1.JDK中对象集合和相关接口

    JDk中主要集合类型主要分为以下四种;

    • set:无序不可重复集合
    • list:有序可重复集合
    • map:具有映射关系集合
    • queue:具有队列性质集合

    集合相关接口和类:

    这里写图片描述

    Collection是JDK中集合类型上层接口,很多相关接口和集合类都派生自它。

    对象集合的一个限制:Java集合不能保存原始数据类型的数据,传入原始数据类型将转换为包装类

    集合主要操作:

    • 遍历集合中元素
    • 按照内容在集合中查找元素
    • 向集合中插入或删除元素

    遍历操作:

    1.使用迭代器对象(Iterator)

    import java.util.Collection;
    import java.util.HashSet;
    import java.util.Iterator;
    
    public class TestMain {
    
        public static void main(String[] args) {
            Collection books = new HashSet();
            books.add("One book");
            books.add("Two book");
            books.add("Three book");
            //获取books集合对应的迭代器
            Iterator it = books.iterator();
            while(it.hasNext())
            {
                String book = (String)it.next();
                System.out.println(book);
            }
            System.out.println("集合中的元素为:"+books);
        }
    }

    Iterator接口定义了三个方法:

    public Iterator<E> {
        boolean hasNext(); // return true if the iteration has more elements
        E next(); // return the next element in the iteration
        void remove(); // remove the last element returned by the iterator
    } 

    所有实现了Collection接口的集合对象,都提供了一个iterator()方法,因此可以像上述方式遍历

    如果非要在遍历时非要删除集合中的元素,则必须通过迭代器对象的remove方法,而不能通过集合 对象直接删除

    import java.util.Collection;
    import java.util.HashSet;
    import java.util.Iterator;
    
    public class TestMain {
    
        public static void main(String[] args) {
            //创建一个集合
            Collection books = new HashSet();
            books.add("One book");
            books.add("Two book");
            books.add("Three book");
            //获取books集合对应的迭代器
            Iterator it = books.iterator();
            while(it.hasNext())
            {
                String book = (String)it.next();
                System.out.println(book);
                if (book.equals("Three book"))
                {
                    //使用Iterator迭代过程中,通过它来移除集合元素是安全的
                    it.remove();//是it.remove()不是books.remove()
                }
            }
            System.out.println("移除元素之后:"+books);
        }
    }

    2.foreach:

    这个比较简单,但要注意当使用foreach循环遍历集合时,注意不要再向集合中追加或删除元素,否则,会引发 ConcurrentModificationException

    2.list和queue

    List可以看成是一种动态改变大小的数组,接口方法如下:

    这里写图片描述

    注意,List只是一个接口,并不是类!!!

    List为变量名,其真实对象需要是实现该接口的子类如ArrayList

    ArrayList:可以看成一个动态数组

    除了ArrayList,JDK中还有另一个类Vector同样实现了List接口,两者功能基本一样,但前者不是线程安全的。

    下面实例以List接口变量名ArrayList为真实对象:

    import java.util.ArrayList;
    import java.util.List;
    
    public class TestMain {
    
        public static void main(String[] args) {
            List<String> books = new ArrayList();
            //向books集合中添加三个元素
            books.add(new String("One book"));
            books.add(new String("Two book"));
            books.add(new String("Three book"));
            System.out.println(books);
            //将新字符串对象插入在第二个位置
            books.add(1 , new String("new book"));
            for (int i = 0 ; i < books.size() ; i++ )
            {
                System.out.println(books.get(i));
            }
            //删除第三个元素
            books.remove(2);
            System.out.println(books);
            //判断指定元素在List集合中位置:输出1,表明位于第二位
            System.out.println(books.indexOf(new String("new book")));
            //将第二个元素替换成新的字符串对象
            books.set(1, new String("new book2"));
            System.out.println(books);
            //将books集合的第二个元素(包括)到第三个元素(不包括)截取子集合
            System.out.println(books.subList(1 , 2));
        }
    }

    List中的indexOf(Object o)和lastIndexOf(Object o)方法:传入的类需要实现equal方法,即需要能够判断两个对象的内容是否完全一致。

    固定大小List:定义于Arrays类的内部类ArrayList,是一个固定长度的List集合,只能遍历访问,不能增加和删除元素,否则,会引发 UnsupportedOperationException。

    Stack:JDK中提供了现成的堆栈类——Stack,注意它派生自Vector,所以它是线程安全的。

    import java.util.Stack;
    
    public class TestMain {
    
        public static void main(String[] args) {
            Stack<String> names = new Stack<>();
            names.push("Raymond");
            names.push("David");
            System.out.println("Top of stack: " + names.peek());
            names.pop();
            System.out.println("Top of stack: " + names.peek());
            names.push("Cynthia");
            System.out.println("Top of stack: " + names.peek());
            //如果堆栈为空,再次pop会抛出EmptyStackException
            if (!names.empty()) {
               names.pop();
            }
            System.out.println("Top of stack: " + names.peek());
            names.pop();
            if (!names.empty()) {
               System.out.println("Top of stack: " + names.peek());
            } else {
               System.out.println("Stack empty.");
            }
        }
    }

    Vector更多参考:https://www.cnblogs.com/skywang12345/p/3308833.html

    LinkedList更多参考:https://www.cnblogs.com/skywang12345/p/3308807.html

    Queue接口代表的是“经典”的队列,JDK中还扩充定义了另一个Deque接口,代表“双向队列”,用途更广。

    这里写图片描述

    PriorityQueue:非线程安全,无容量限制。允许元素重复。其顺序由元素自己(如果实现了Comparable接口)或 Compartor提供,会将它所包容的元素自动排序。

    import java.util.PriorityQueue;
    
    public class TestMain {
    
        public static void main(String[] args) {
            PriorityQueue pq = new PriorityQueue();
            //下面代码依次向pq中加入四个元素
            pq.offer(6);
            pq.offer(-3);
            pq.offer(9);
            pq.offer(0);
            pq.offer(110);
            //输出pq队列,并不是按元素的加入顺序排列,而是按元素的二叉树顺序排列
            System.out.println(pq);
            //访问队列第一个元素,其实就是队列中最小的元素:-3
            System.out.println(pq.peek());
    
            pq.poll();
            System.out.println("\n 移除队列中的head元素之后");
            System.out.println(pq);
            pq.remove(9);
            System.out.println("\n 移除队列中的元素9之后");
            System.out.println(pq);
        }
    }

    CurrentLinkedQueue:这是一个线程安全的(FIFO:First In First Out)的容量不限的队列。其内部使用一种基于 “CAS(Compare and Swap)”的算法,能保证访问它的线程总能完 成它要执行的操作而不会被提前中断

    BlockingQueue接口:此接口派生自Queue,最适合于实现生产者-消费者问题

    Deque接口:双向队列。既像Queue,又像Stack。

    3.Map

    这里写图片描述

    • Map集合给每个元素定义了一个Key,通过Key来访问对象
    • 要求每个对象的Key应该不一样,否则,会带来混乱

    Map接口成员:

    这里写图片描述

    HashMap:

    • 使用put(Key,Value)方法追加元素,使用get(Key)方法提取元素
    • 通过HashMap对象的keySet()方法引用其Key的集合,通过其values()方法引用其Value的集合。Key和Value之间的对应关系,是通过HashMap内部的一个Map.Entry对象集合实现的,HashMap对象的entrySet方法引用这一对象集合

    HashMap简单使用(遍历):

    import java.util.HashMap;
    import java.util.Iterator;
    import java.util.Map;
    import java.util.Set;
    
    public class TestMain {
    
        public static void main(String[] args) {
            HashMap<String, Integer> hm = new HashMap<>();
            for (int i = 1; i < 10; i++) {
                hm.put("Key" + i, i);
            }
            // 使用KeySet遍历集合
            Set<String> keySet = hm.keySet();
    
            for (String key : keySet) {
    
                System.out.println(key + ":" + hm.get(key));
                // 循环遍历过程中,不允许移除元素,否则,引发ConcurrentModificationException
            }
    
            System.out.println("\n使用Iterator遍历并移除元素");
            Set<Map.Entry<String, Integer>> entrySet = hm.entrySet();
            Iterator<Map.Entry<String, Integer>> itor = entrySet.iterator();
            while (itor.hasNext()) {
                Map.Entry<String, Integer> entry = itor.next();
                if(entry.getValue() % 2!=0){
                    itor.remove();
                    System.out.println(entry.getKey() + ":" + entry.getValue()+" is removed");
                }
                else{
                    System.out.println(entry.getKey() + ":" + entry.getValue());    
                }
            }
        }
    }

    HashMap可以使用null作为key,且只会有一个null作key的键值对,多的会覆盖掉。

    HashTable:HashMap和HashTable两者功能基本一样,但HashTable是线程安全的

    Map集合对Key要求:

    • 用作Key的对象必须覆盖hashCode和equals方法
    • Key相等:两个对象的hashCode一致,并且equals方法返回true
    • Value相等:equals方法返回true

    上述特性对HashTable的containsValue()方法返回值的影响如实例:

    import java.util.*;
    
    public class TestMain {
    
        public static void main(String[] args) {
            Hashtable ht = new Hashtable();
            ht.put(new MyKey(60000) , "key值为60000所对应的Value");
            ht.put(new MyKey(87563) , "Key值为87563所对应的Value");
            ht.put(new MyKey(1232) , new B());
            System.out.println(ht);
            //只要两个对象通过equals比较返回true,Hashtable就认为它们是相等的value。
            //因为Hashtable中有一个B对象,它与任何对象通过equals比较都相等,所以下面输出true。
            System.out.println(ht.containsValue("测试字符串"));
            //只要两个A对象的count属性相等,它们通过equals比较返回true,且hashCode相等
            //Hashtable即认为它们是相同的key,所以下面输出true。
            System.out.println(ht.containsKey(new MyKey(87563)));
            //下面语句可以删除最后一个key-value对
            ht.remove(new MyKey(1232));
            for (Object key : ht.keySet())
            {
                System.out.print(key + "---->");
                System.out.print(ht.get(key) + "\n");
            }
        }
    }
    class MyKey
    {
        int value;
        public MyKey(int count)
        {
            this.value = count;
        }
        public boolean equals(Object obj)
        {
            if (obj == this)
            {
                return true;
            }
            if (obj != null &&  obj.getClass() == MyKey.class)
            {
                MyKey a = (MyKey)obj;
                if (this.value == a.value)
                {
                    return true;
                }
            }
            return false;
        }
        public int hashCode()
        {
            return this.value;
        }
        public String toString(){
            return "MyKey:"+this.value;
        }
    }
    class B
    {
        public boolean equals(Object obj)
        {
            return true;
        }
    }

    Properties类:派生自HashTable,可以方便地处理“属性-值”对,并且可以很方便地将其保存到文件中

    NavigableMap接口:,保证在遍历集合时,一定是按照升序进行的

    实现NavigableMap接口最常用的类型是 TreeMap,它的用法与标准的Map没什么两样

    TreeMap的独特之处在于:它内部基于红黑树 (red-black tree)对Key进行排序。因此,它的元素是“有序”的。

    import java.util.*;
    
    public class TestMain {
    
        public static void main(String[] args) {
            TreeMap tm = new TreeMap();
            tm.put(new R(3) , "Key值为3的value");
            tm.put(new R(-5) , "Key值为-5的value");
            tm.put(new R(9) , "Key值为9的value");
            System.out.println("TreeMap集合中的所有元素:\n"+tm);
            //返回该TreeMap的第一个Entry对象
            System.out.println("\n第一个Entry对象:"+tm.firstEntry());
            //返回该TreeMap的最后一个key值
            System.out.println("最后一个key值:"+tm.lastKey());
            //返回该TreeMap的比new R(2)大的最小key值。
            System.out.println("比new R(2)大的最小key值:"+tm.higherKey(new R(2)));
            //返回该TreeMap的比new R(2)小的最大的key-value对。
            System.out.println("比new R(2)小的最大的key-value对:"+tm.lowerEntry(new R(2)));
            //返回该TreeMap的子TreeMap
            System.out.println("该TreeMap的子TreeMap:"+tm.subMap(new R(-1) , new R(4)));
        }
    }
    
    //R类,重写了equals方法,如果value属性相等返回true
    //重写了compareTo(Object obj)方法,如果value属性相等返回0;
    class R implements Comparable
    {
        int value;
        public R(int value)
        {
            this.value = value;
        }
        public String toString()
        {
            return "R(value属性:" + value + ")";
        }
        public boolean equals(Object obj)
        {
            if (this == obj)
            {
                return true;
            }
            if (obj != null && obj.getClass() == R.class)
            {
                R r = (R)obj;
                if (r.value == this.value)
                {
                    return true;
                }
            }
            return false;
        }
        public int compareTo(Object obj)
        {
            R r = (R)obj;
            if (this.value > r.value)
            {
                return 1;
            }
            else if (this.value == r.value)
            {
                return 0;
            }
            else
            {
                return -1;
            }
        }
    }

    JDK中提供了以下Map类型实现多线程环境下的安全访问:

    ConcurrentHashMap
    ConcurrentNavigableMap
    ConcurrentSkipListMap 

    4.Set

    Set也是一种Collection,其中不允许有重复元素。Set通过调用对象的equals方法确定两个对象是否相同。

    HashSet原理:

    • HashSet将对象的哈希码作为访问对象 的“索引(index)”。
    • 当向HashSet存入一个对象时,它会同时调用hashCode()和equals()两个方法确定此对象是否己在集合中,如果发现己经有了,则不会把此对象加入到集合中
    • HashSet中每个存储元素的“Slot(槽)”通常被称为“bucket”,如果有多个元素的hashCode相等,但它们 equals()方法返回False,这就导致同一个槽中放置多个元素,这会导致性能下降
    • HashSet在内部包容一个HashMap,以对象的 hashCode作为这一Map的Key
    import java.util.*;
    
    public class TestMain {
    
        public static void main(String[] args) {
            HashSet books = new HashSet();
            //分别向books集合中添加2个A对象,2个B对象,2个C对象
            books.add(new A());
            books.add(new A());//hash值不同,故可以添加,位于不同槽
            books.add(new B());
            books.add(new B());//hash值相同,但equal返回false,可添加位于同一个槽
            books.add(new C());
            books.add(new C());//hash值相同,equal返回true,故不可再添加
            //输出:[B@1, B@1, C@2, A@15db9742, A@6d06d69c]
            System.out.println(books);
        }
    }
    //类A的equals方法总是返回true,但没有重写其hashCode()方法
    class A
    {
        public boolean equals(Object obj)
        {
            return true;
        }
    }
    //类B的hashCode()方法总是返回1,但没有重写其equals()方法
    class B
    {
        public int hashCode()
        {
            return 1;
        }
    }
    //类C的hashCode()方法总是返回2
    class C
    {
        public int hashCode()
        {
            return 2;
        }
        public boolean equals(Object obj)
        {
            return true;
        }
    }

    使用HashSet集合(TreeSet类似)保存对象时要注意,尽量不要修改对象的属性值,否则,可能会出现很奇怪的现象。推荐在HastSet中保存不可变类的实例。

    LinkedHashSet:派生自HashSet,也是按照对象的hashCode来保存,但它同时使用双向链表来维护对象的顺序,当遍历LinkedHashSet时,将按插入顺序来显示集合中的对象

    SortedSet接口:SortedSet保证总是按照升序方式访问集合中的数据。使用SortedSet的一个最大好处是:如果合并两个这样的集合,合并之后,集合仍然是有序的。JDK中的TreeSet实现了SortedSet接口。

    TreeSet:

    • 在任何时刻访问TreeSet时,总能得到一个”己经排好序的对象集合”,TreeSet内部调用compareTo(Object obj)方法来比较集合 中各个对象的大小,然后在内部使用红黑树进行排序
    • TreeSet要求其元素必须实现Comparable接口,并且应该是同一个类型的,否则,将引发ClassCastException
    import java.util.*;
    
    public class TestMain {
    
        public static void main(String[] args) {
            TreeSet nums = new TreeSet();
            //向TreeSet中添加四个Integer对象
            nums.add(5);
            nums.add(2);
            nums.add(10);
            nums.add(-9);
            //输出集合元素,看到集合元素已经处于排序状态
            System.out.println("集合元素:"+nums);
            //输出集合里的第一个元素
            System.out.println("集合里的第一个元素:"+nums.first());
            //输出集合里的最后一个元素
            System.out.println("集合里的最后一个元素:"+nums.last());
            //可以输出指定元素的“前一个”和“后一个”
            System.out.println("10之前的那个元素是:"+nums.lower(10));
            System.out.println("10之后的那个元素是:"+nums.higher(10));
            //返回小于4的子集,不包含4
            System.out.println("返回小于4的子集,不包含4:"+nums.headSet(4));
            //返回大于5的子集,如果Set中包含5,子集中还包含5
            System.out.println("返回大于5的子集:"+nums.tailSet(5));
            //返回大于等于-3,小于4的子集。
            System.out.println("返回大于等于-3,小于4的子集:"+nums.subSet(-3 , 4));
        }
    }

    参考:

    金旭亮Java编程系列(大部分内容摘自该教程)

    展开全文
  • 利用stream流将一个对象集合转换成另一个对象集合! List<BVideoHistory> bVideoHistoryList=new ArrayList<>(); List<BVideoRank> bVideoRankList = bilibiliRank.bVideoRankArraylist(0); ...

    利用stream流将一个对象集合转换成另一个对象集合!

      List<BVideoHistory> bVideoHistoryList=new ArrayList<>();
    
            List<BVideoRank> bVideoRankList = bilibiliRank.bVideoRankArraylist(0);
            if (CollectionUtils.isNotEmpty(bVideoRankList)){
                bVideoHistoryList=bVideoRankList.stream().map(bVideoRank->{
                    BVideoHistory bVideoHistory=new BVideoHistory();
                    bVideoHistory.setBvNumber(bVideoRank.getBvNumber());
                    bVideoHistory.setBvTitle(bVideoRank.getBvTitle());
                    bVideoHistory.setBvUp(bVideoRank.getBvUp());
                    bVideoHistory.setBvUpuuid(bVideoRank.getBvUpuuid());
                    return bVideoHistory;
                }).collect(Collectors.toList());
            }
    
    展开全文
  • // 从数据库中查询出的对象集合 List<OperationStation> operationStations = operationStationJoinMapper.selectJoinByExample(example); // 判端是否为空 if (CollectionUtils.isNotEmpty...
            // 从数据库中查询出的对象集合
            List<OperationStation> operationStations = operationStationJoinMapper.selectJoinByExample(example);
            // 判端是否为空
            if (CollectionUtils.isNotEmpty(operationStations)) {
                // 进行拆解封装
                List<StationDictVO> stationDictVOS = operationStations.stream().map(operationStation -> {
                    StationDictVO stationDictVO = new StationDictVO();
                    stationDictVO.setStationId(operationStation.getStationId());
                    stationDictVO.setStationName(operationStation.getStationName());
                    return stationDictVO;
                }).collect(Collectors.toList());
            }
    

     

    展开全文
  • 利用java8 stream流将一个对象集合转换成另一个对象集合 // 从数据库中查询出的对象集合 List<OperationStation> operationStations = operationStationJoinMapper.selectJoinByExample(example); // 判端...

    利用java8 stream流将一个对象集合转换成另一个对象集合

        public List<UserCheckData> getUserCheckTableData(){
    
            List<UserCheckData> userCheckDataList = null;
            
            List<UserCheckPO> list = userCheckPORepository.findAll();
            if(CollectionUtils.isNotEmpty(list)){
                userCheckDataList = list.stream().map(userCheckPO -> {
                    UserCheckData userCheckData = new UserCheckData();
                    BeanUtils.copyProperties(userCheckPO, userCheckData);
    
                    return userCheckData;
                }).collect(Collectors.toList());
            }
    
            return userCheckDataList;
    
        }
    
    展开全文
  • Java8对象集合转id集合

    千次阅读 2019-12-27 16:28:05
    Java8对象集合转id集合 List<Integer> ids = members.stream().map(TeamMemberInfo::getId). collect(Collectors.toList());
  • List<String> patientIdList = relationDOList.stream().map(RelationDO::getPatientId).collect(Collectors.toList());...relationDOList 目标对象集合 RelationDO 目标对象 getPatientId 获得该属性的方法 ...
  • 如下为JSONArray到Java对象集合的转换,其中responseInfo.getData()为JSONArray类型 String JSONStr = JSON.toJSONString(responseInfo.getData()); List&lt;BusLine&gt; busLineList = JSON.parseObject...
  • JS解析后台传的对象集合

    千次阅读 2020-02-26 17:35:05
    如题,当我们直接从后台传了一个对象集合当前台进行JS解析,首先我们需要把对象集合转换成JSON串, 用 JSON.toJSONString(planList) 其中planList是对象集合, 然后前台直接获取 var planList = ‘${planList}’; ...
  • json格式对象集合解析

    千次阅读 2019-04-20 17:58:24
    json格式对象集合解析 JSONArray解析json字符串并使用JSONObject解析为对象 String userList = goodsStd.getGoodsStds(); JSONArray jsonArray = JSONArray.parseArray(userList); for (Object ob : jsonArray) { ...
  • //所有学生 List<Student> students = getAllStudents(); //从所有学生集合中获取名字集合 List<String> supplierCodes = students.stream().map...students:所有学生的对象集合 getName:name属性 ...
  • java将对象或对象集合序列化成string

    千次阅读 2019-06-03 10:56:05
    java将对象或对象集合序列化成string 一、介绍 在日常java开发中,可能需要将java中的对象转化成String类型进行存储在数据库或者Redis中。自己可能很难完成这个转化的过程,所以使用以下代码工具类进行快速转化。 ...
  • Java关于List对象集合的遍历、对象赋值和向前台传递 在前几天的编程过程中,发现前台需要的数据不完整。从数据库查出来的字段不够,如果再多表联查或者左联会有我不想要的重复数据,而且会使SQL更加复杂,不利于维护...
  • 假如我们有一个User对象对象字段如下: @Data @Builder class User{ private String name; private int id; } 如果我们存在这样的一个List列表,如果我们希望找出这个List中name为ONE的对象,当然我们可以...
  • Java8的Stream为我们提供了方便的分组收集器groupingBy,利用这个收集器我们可以很方便的根据某个对象集合的每个元素的某个属性的值来进行分组。普通用法进行分组之后,会将整个对象集合分成我们选定的属性的值的...
  • java反射机制 结果集封装为对象和对象集合
  • MVC传递数据-传递对象或对象集合

    千次阅读 热门讨论 2015-07-20 22:18:44
    本文主要介绍从View(或者js)文件向Controller提交对象或者对象集合,比如,将表格中的一行数据作为一个对象提交,或将多行数据作为一个集合提交到Controller。 回顾 从View(或者js)文件向Controller提交数据,你...
  • JAVA 对象集合转换为SQL

    千次阅读 2017-02-21 09:15:08
    JAVA 对象集合转换为SQL对象集合是从别数据库获得,有的字段是null(或者根据其他要求),转换为insert SQL语句,用于存储过程(数据量较大时使用)。 根据一个对象,获取对象的属性类型,属性名称,属性值得集合; ...
  • JAVA 8 lambda 表达式实现按某个属性值查找对象集合中符合条件的对象   当前的需求是从数据库或者其他服务中获取到了一个对象集合,假设对象是Cart购物车,里面有product_id,product_name,count等。  需要从...
  • 后端对象集合 传到前端

    千次阅读 2019-06-06 17:42:04
    1.直接传对象集合 List<Area> proList = new ArrayList<>(); model.addAttribute("proList2", proList); <select id="province" name="provinceCode"> ...
  • 对象集合中判断其中对象的某一个属性是否有重复 // 新建一个List List<String> carriageNO = new ArrayList(); for (DisRlyLoadCarriage disRlyLoadCarriage : disRlyLoadCarriages){ // 添加要判断的...
  • 适用Lambda对对象集合去重

    千次阅读 2018-07-19 10:33:01
    适用Lambda对对象集合去重 -List Newlist = list.Select(x =&gt; new Model_DOC_MI_LIST_FOR_ORT { ORT_LIST_FLAG = x.ORT_LIST_FLAG, ORT_LIST_ID = x.ORT_LIST_ID, ...
  • Java 8使用Stream和Lambda表达式求对象集合的交集、差集
  • java8对象集合根据字段去重复

    千次阅读 2019-12-27 16:41:33
    java8对象集合根据字段去重复 //根据投资主体名称去重复 List<DiFiCounterpartySimple> teamMemberInfoArrayList = counterpartySimples.stream().collect( collectingAndThen(Collectors.toCollection(() -&...
  • JSON字符串转换成List对象集合

    万次阅读 2018-12-06 15:07:54
    有一个json字符串,我想通过jackson把json字符串转换成list对象集合,网上找了很多,但都不尽人意。后来还是看jackson文档,才知道怎么做。 需要的包: &lt;dependency&gt; &lt;groupId&gt;org....
  • Mybatis foreach 请求参数是对象集合

    千次阅读 2018-03-19 09:27:09
    需求 参数是对象集合/** * 查询对应客户的联系人信息 * @param qeury * @return */ public List&lt;CustomerContactInfoList&gt; getCustomerContactInfoList(List&lt;CustomerContactInfoList&...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 136,267
精华内容 54,506
关键字:

对象集合