精华内容
下载资源
问答
  • Java List集合深入学习

    千次阅读 多人点赞 2018-10-29 07:25:39
    Java List是一个有序集合。Java List是扩展Collection接口的接口。Java List提供对可插入元素的位置的控制。您可以按索引访问元素,也可以搜索列表中的元素。 目录 Java列表 Java列表类图 Java列表方法 要列出...

     

    Java List是一个有序集合。Java List是扩展Collection接口的接口。Java List提供对可插入元素的位置的控制。您可以按索引访问元素,也可以搜索列表中的元素。

    目录

    Java列表

    Java列表类图

    Java列表方法

    要列出的Java数组

    Java List to Array

    Java列表排序

    Java列表常见操作

    Java List迭代器


    Java List

    关于Java List的一些重要观点是;

    • Java List接口是Java Collections Framework的成员。
    • List允许您添加重复元素。
    • List允许您拥有'null'元素。
    • List接口在Java 8中有许多默认方法,例如replaceAll,sort和spliterator。
    • 列表索引从0开始,就像数组一样。
    • List支持泛型,我们应尽可能使用它。将Generics与List一起使用将在运行时避免ClassCastException。

    Java列表类图

    Java List接口扩展了Collection接口。集合界面externs Iterable接口。一些最常用的List实现类是ArrayList,LinkedList,Vector,Stack,CopyOnWriteArrayList。AbstractList提供了List接口的骨干实现,以减少实现List的工作量。

    java list,java list examples,java list tutorial,java list interface,java list class diagram

    Java列表方法

    一些有用的Java List方法是;

    1. int size():获取列表中元素的数量。
    2. boolean isEmpty():检查列表是否为空。
    3. boolean contains(Object o):如果此列表包含指定的元素,则返回true。
    4. Iterator <E> iterator():以适当的顺序返回此列表中元素的迭代器。
    5. Object [] toArray():以适当的顺序返回包含此列表中所有元素的数组
    6. boolean add(E e):将指定的元素追加到此列表的末尾。
    7. boolean remove(Object o):从此列表中删除指定元素的第一个匹配项。
    8. boolean retainAll(Collection <?> c):仅保留此列表中包含在指定集合中的元素。
    9. void clear():从列表中删除所有元素。
    10. E get(int index):返回列表中指定位置的元素。
    11. E set(int index,E element):用指定的元素替换列表中指定位置的元素。
    12. ListIterator <E> listIterator():返回列表中元素的列表迭代器。
    13. List <E> subList(int fromIndex,int toIndex):返回指定fromIndex(包含)和toIndex(不包括)之间的此列表部分的视图。返回的列表由此列表支持,因此返回列表中的非结构更改将反映在此列表中,反之亦然。

    在Java 8中添加到List的一些默认方法是;

     

    1. default void replaceAll(UnaryOperator <E>运算符):将此列表的每个元素替换为将运算符应用于该元素的结果。
    2. default void sort(Comparator <super E> c):根据指定的Comparator引发的顺序对此列表进行排序。
    3. default Spliterator <E> spliterator():在此列表中的元素上创建Spliterator。

    要列出的Java数组

    我们可以使用Arrays类将数组视图作为列表。但是我们将无法对列表进行任何结构修改,它将抛出java.lang.UnsupportedOperationException。所以最好的方法是使用for循环来迭代数组来创建列表。下面是一个简单的例子,展示了如何正确地将java数组转换为列表。

    
    package com.journaldev.examples;
    
    import java.util.ArrayList;
    import java.util.Arrays;
    import java.util.List;
    
    public class ArrayToList {
    
    	public static void main(String[] args) {
    		
    		String[] vowels = {"a","e","i","o","u"};
    		
    		List<String> vowelsList = Arrays.asList(vowels);
    		System.out.println(vowelsList);
    		
    		/**
    		 * List is backed by array, we can't do structural modification
    		 * Both of the below statements will throw java.lang.UnsupportedOperationException
    		 */
    		//vowelsList.remove("e");
    		//vowelsList.clear();
    				
    		//using for loop to copy elements from array to list, safe for modification of list
    		List<String> myList = new ArrayList<>();
    		for(String s : vowels){
    			myList.add(s);
    		}
    		System.out.println(myList);
    		myList.clear();
    	}
    
    }
    

    根据您的项目要求选择上述任何一种方法。

     

    Java List to Array

    一个简单的示例,显示将列表转换为数组的正确方法。

    
    package com.journaldev.examples;
    
    import java.util.ArrayList;
    import java.util.Arrays;
    import java.util.List;
    
    public class ListToArray {
    
    	public static void main(String[] args) {
    
    		List<String> letters = new ArrayList<String>();
    
    		// add example
    		letters.add("A");
    		letters.add("B");
    		letters.add("C");
    		
    		//convert list to array
    		String[] strArray = new String[letters.size()];
    		strArray = letters.toArray(strArray);
    		System.out.println(Arrays.toString(strArray)); //will print "[A, B, C]"
    	}
    
    }
    

    Java列表排序

    有两种方法可以对列表进行排序。我们可以使用Collections类进行自然排序,或者我们可以使用List sort()方法并使用我们自己的Comparator进行排序。下面是java列表排序的一个简单示例。

    
    package com.journaldev.examples;
    
    import java.util.ArrayList;
    import java.util.Collections;
    import java.util.List;
    import java.util.Random;
    
    public class ListSortExample {
    
    	public static void main(String[] args) {
    		
    		List<Integer> ints = new ArrayList<>();
    		Random random = new Random();
    		for (int i = 0; i < 10; i++) ints.add(random.nextInt(1000));
    		
    		//natural sorting using Collections class
    		Collections.sort(ints);
    		System.out.println("Natural Sorting: "+ints);
    		
    		//My custom sorting, reverse order
    		ints.sort((o1,o2) -> {return (o2-o1);});
    		System.out.println("Reverse Sorting: "+ints);
    	}
    }
    

    下面给出了一个示例输出。由于我使用Random生成列表元素,因此每次都会有所不同。

    
    Natural Sorting: [119, 273, 388, 450, 519, 672, 687, 801, 812, 939]
    Reverse Sorting: [939, 812, 801, 687, 672, 519, 450, 388, 273, 119]
    

    Java列表常见操作

    在java列表上执行的最常见操作是添加,删除,设置,清除,大小等。下面是一个简单的java列表示例,显示了常用的方法用法。

    
    package com.journaldev.examples;
    
    import java.util.ArrayList;
    import java.util.Arrays;
    import java.util.List;
    
    public class ListExample {
    
    	public static void main(String args[]) {
    		List<String> vowels= new ArrayList<String>();
    		
    		//add example
    		vowels.add("A");
    		vowels.add("I");
    		
    		//let's insert E between A and I
    		vowels.add(1,"E");
    		System.out.println(vowels);
    		
    		List<String> list = new ArrayList<String>();
    		list.add("O");list.add("U");
    		
    		//appending list elements to letters
    		vowels.addAll(list);
    		System.out.println(vowels);
    		
    		//clear example to empty the list
    		list.clear();
    		
    		//size example
    		System.out.println("letters list size = "+vowels.size());
    		
    		//set example
    		vowels.set(2, "E");
    		System.out.println(vowels);
    		
    		//subList example
    		vowels.clear();vowels.add("E"); vowels.add("E");vowels.add("I"); vowels.add("O");
    		list = vowels.subList(0, 2);
    		System.out.println("letters = "+vowels+", list = "+list);
    		vowels.set(0, "A");
    		System.out.println("letters = "+vowels+", list = "+list);
    		list.add("U");
    		System.out.println("letters = "+vowels+", list = "+list);
    		
    		
    	}
    
    }
    

    以上java列表示例程序的输出是;

    
    [A, E, I]
    [A, E, I, O, U]
    letters list size = 5
    [A, E, E, O, U]
    letters = [E, E, I, O], list = [E, E]
    letters = [A, E, I, O], list = [A, E]
    letters = [A, E, U, I, O], list = [A, E, U]
    

    Java List迭代器

    下面是一个简单的例子,展示了如何在java中迭代列表。

    
    package com.journaldev.examples;
    
    import java.util.ArrayList;
    import java.util.Iterator;
    import java.util.List;
    
    public class ListIteratorExample {
    
    	public static void main(String[] args) {
    
    		List<Integer> list = new ArrayList<>();
    		for(int i=0; i<5; i++) list.add(i);
    		
    		Iterator<Integer> iterator = list.iterator();
    		
    		//simple iteration
    		while(iterator.hasNext()){
    			int i = (int) iterator.next();
    			System.out.print(i + ", ");
    		}
    		System.out.println("\n"+list);
    		
    		//modification of list using iterator
    		iterator = list.iterator();
    		while(iterator.hasNext()){
    			int x = (int) iterator.next();
    			if(x%2 ==0) iterator.remove();
    		}
    		System.out.println(list);
    		
    		//changing list structure while iterating
    		iterator = list.iterator();
    		while(iterator.hasNext()){
    			int x = (int) iterator.next(); //ConcurrentModificationException here
    			if(x==1) list.add(10);
    		}
    	}
    
    }
    

    以上java列表迭代器程序的输出是;

    
    0, 1, 2, 3, 4, 
    [0, 1, 2, 3, 4]
    [1, 3]
    Exception in thread "main" java.util.ConcurrentModificationException
    	at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:901)
    	at java.util.ArrayList$Itr.next(ArrayList.java:851)
    	at com.journaldev.examples.ListIteratorExample.main(ListIteratorExample.java:34)
    

    这就是Java中List的快速综述。我希望这些Java List示例可以帮助您开始使用List集合编程。

     

    展开全文
  • java list 转换为json数据

    热门讨论 2010-12-12 12:08:59
    java list 转换为json数据java list 转换为json数据java list 转换为json数据java list 转换为json数据java list 转换为json数据java list 转换为json数据java list 转换为json数据java list 转换为json数据java ...
  • java List集合截取

    千次阅读 2020-09-18 11:59:09
    List<String> list = new ArrayList<>(); list.add("111"); list.add("222"); list.add("333"); list.add("444"); //要截取的长度,先判断是否大于指定的长度,大于再截取,不然会报错 //比如截取...

    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基本操作

    万次阅读 多人点赞 2019-06-03 17:15:42
    Java List中的常用操作: list中添加,获取,删除元素; list中是否包含某个元素; list中根据索引将元素数值改变(替换); list中查看(判断)元素的索引; 根据元素索引位置进行的判断; 利用list中索引位置...

    Java List中的常用操作:

    1. list中添加,获取,删除元素;
    2. list中是否包含某个元素;
    3. list中根据索引将元素数值改变(替换);
    4. list中查看(判断)元素的索引;
    5. 根据元素索引位置进行的判断;
    6. 利用list中索引位置重新生成一个新的list(截取集合);
    7. 判断list是否为空;
    8. 返回Iterator集合对象;
    9. 将集合转换为字符串;
    10. 将集合转换为数组;
    11. 去重复;

    1: list中添加, 获取, 删除元素.

    public class TestList {
        public staic void main(String[] args) {
            List<String> list = new ArrayList<String>();
            
            //添加元素.
            list.add("Tom");
            list.add("Jam");
            list.add("Alix");
            
            //获取元素.
            String str = list.get(0);
            
            //删除元素.
            list.remove(1);
            list.remove("Alix");
    
            //遍历元素.
            for (String s: list) {
                Systtem.out.peintln(s);
            }
        }
    
    }

    2: list中是否包含某一个元素.

    public class TestList {
        public static void main(String[] args) {
            List<String> list = new ArrayList<String>();
            list.add("Tom");
            list.add("Alix");
            
            for (int i = 0; i < list.size(); i++) {
                System.out.println(list.get(i));
            }
    
            //判断某一个元素是否在list中.
            String name = "Tom";
            if (list.contains(name)) {
                System.out.println("Tom in list.");
            } else {
                System.out.println("Tom not in list");
            }
        }
    }

    3: list中根据索引改变元素的值.

    public class TestList{
        public static void main(String[] args) {
            List<String> list = new ArrayList<String>();
            String[] name = {"zhangsan", "Lisi", "wanger"};
            for (int i = 0; i < name.length; i++) {
                list.add(name[i]);
            }
            
            //根据索引改变list中某一个值.
            list.set(0, "Tom");
    
            for (int i = 0; i < list.size(); i++) {
                System.out.println(list.get(i));
            }
        }
    }

    4: list中根据元素的值查看索引的值.

    public class TestListIndexOf{
        piblic static void main(String[] args) {
            List<Integer> num = new ArrayList<Integer>();
    
            num.add(1);
            num.add(2);
            num.add(3);
            num.add(2);
    
            //返回元素值等于2的索引.
            System.out.println(num.indexOf(2));
            //返回元素值等于2的最后的索引.
            System.out.println(num.lastIndexOf(2));
        }
    }

    5: 根据元素索引位置进行的判断.

    public class TestList{
        public static void main(String[] args) {
            List<Integer> num = new ArrayList<Integer>();
        
            num.add(1);
            num.add(2);
            num.add(3);
            num.add(2);
    
            if (num.indexOf(3) == 2) {
                System.out.println("元素3在这个位置.");
            }
            if (num.lastIndexOf(2) == 3) {
                System.out.println("最后的元素2在这个位置.");
            }
        }
    }

    6: 利用list中索引位置重新生成一个新的list(截取集合).

    public class TestList{
        public static void main(String[] args) {
            List<Integer> num = new ArrayList<Integer>();
            num.add(2);
            num.add(3);
            num.add(6);
            num.add(7);
    
            for (Integer i: num) {
                System.out.println(i);
            }
    
            //利用subList()截取, 然后给num.
            num = num.subList(1, 4);
            for (int i = 0; i < num.size(); i++) {
                System.out.println(num.get(i));
            }
        }
    }

    7: 判断list是否为空.

    public class TestList{
        public static void main(String[] args) {
            List<String> arrayList = new ArrayList<>();
    
            arrayList.add("Tom");
    
            //判断list是否为空.
            if (arrayList.isEmpty()) {
                System.out.println("空的.");
            } else {
                System.out.println("不为空.");
            }
        }
    }

    8:返回iterator集合对象.

    public class TestList{
        public static void main(String[] args) {
            List<String> arrayList = new ArrayList<>();
            arrayList.add("Tom");
            arrayList.add("Alix");
        
            //转化成iterator对象.
            Iterator it = arrayList.iterator();
            while(it.hasNext) {
                Object obj = it.next();
                System.out.println(obj);
            }
        }
    }

    9: 将集合转为string.

    String str = "";
    str = list.toString();
    System.out.println(str);

    10: 将集合转为数组.

    String[] str = list.toArray();
    for (String s: str) {
        System.out.println(str);
    }

    11: 去重复.

    List<String> lst1=new ArrayList<>();
                lst1.add("aa");
                lst1.add("dd");
                lst1.add("ss");
                lst1.add("aa");
                lst1.add("ss");
     
                //第一种方法通过循环做, 根据remove方法去重复.
                for (int i = 0; i <lst1.size()-1; i++) {
                    for (int j = lst1.size()-1; j >i; j--) {
                        if (lst1.get(j).equals(lst1.get(i))) {
                            lst1.remove(j);
                        }
                    }
                }
                System.out.println(lst1);
                 
                //第二种方法通过frequency方法.
                List<String> lst2=new ArrayList<>();
                for (String s:lst1) {
                    if (Collections.frequency(lst2, s)<1) {
                        lst2.add(s);
                    }
                }
                System.out.println(lst2);

     

    展开全文
  • Java List的remove()方法陷阱以及性能优化

    万次阅读 多人点赞 2019-05-25 17:55:02
    Java List在进行remove()方法是通常容易踩坑,主要有一下几点 循环时:问题在于,删除某个元素后,因为删除元素后,后面的元素都往前移动了一位,而你的索引+1,所以实际访问的元素相对于删除的元素中间间隔了一位...


    Java List在进行remove()方法是通常容易踩坑,主要有一下几点

    循环时:问题在于,删除某个元素后,因为删除元素后,后面的元素都往前移动了一位,而你的索引+1,所以实际访问的元素相对于删除的元素中间间隔了一位。

    几种常见方法

    1. 使用for循环不进行额外处理时(错误
    //错误的方法
    for(int i=0;i<list.size();i++) {
    	if(list.get(i)%2==0) {
    		list.remove(i);
    	}
    }
    

    2.使用foreach循环(错误

    for(Integer i:list) {
        if(i%2==0) {
         	list.remove(i);
        }
    }
    

    抛出异常:java.util.ConcurrentModificationException;
    foreach的本质是使用迭代器实现,每次进入for (Integer i:list) 时,会调用ListItr.next()方法;
    继而调用checkForComodification()方法, checkForComodification()方法对操作集合的次数进行了判断,如果当前对集合的操作次数与生成迭代器时不同,抛出异常

    public E next() {
    	checkForComodification();
    	if (!hasNext()) {
    		 throw new NoSuchElementException();
    	}
    	 lastReturned = next;
    	next = next.next;
    	nextIndex++;
    	return lastReturned.item;
     }
     // checkForComodification()方法对集合遍历前被修改的次数与现在被修改的次数做出对比
    final void checkForComodification() {
    	  if (modCount != expectedModCount) {
    	  		 throw new ConcurrentModificationException();
    	  }
                 
      }
    
    • 使用for循环,并且同时改变索引;(正确
    //正确
    for(int i=0;i<list.size();i++) {
    	if(list.get(i)%2==0) {
    		list.remove(i);
    		i--;//在元素被移除掉后,进行索引后移
    	}
    }
    
    • 使用for循环,倒序进行;(正确
    //正确
    for(int i=list.size()-1;i>=0;i--) {
    	if(list.get(i)%2==0) {
    		list.remove(i);
    	}
    }
    
    • 使用while循环,删除了元素,索引便不+1,在没删除元素时索引+1(正确
    //正确
    int i=0;
    while(i<list.size()) {
    	if(list.get(i)%2==0) {
    		list.remove(i);
    	}else {
    		i++;
    	}
    }
    

    4.使用迭代器方法(正确,推荐
    只能使用迭代器的remove()方法,使用列表的remove()方法是错误的

    //正确,并且推荐的方法
    Iterator<Integer> itr = list.iterator();
    while(itr.hasNext()) {
    	if(itr.next()%2 ==0)
    		itr.remove();
    }
    

    性能分析

    下面来谈谈当数据量过大时候,需要删除的元素较多时,如何用迭代器进行性能的优化,对于ArrayList这几乎是致命的,从一个ArrayList中删除批量元素都是昂贵的时间复杂度为O(n²),那么接下来看看LinkeedList是否可行。LinkedList暴露了两个问题,一个:是每次的Get请求效率不高,而且,对于remove的调用同样低效,因为达到位置I的代价是昂贵的。

    • 是每次的Get请求效率不高
      需要先get元素,然后过滤元素。比较元素是否满足删除条件。
    • remove的调用同样低效
      LinkedList的remove(index),方法是需要先遍历链表,先找到该index下的节点,再处理节点的前驱后继。

    以上两个问题当遇到批量级别需要处理时时间复杂度直接上升到O(n²)

    使用迭代器的方法删除元素

    对于LinkedList,对该迭代器的remove()方法的调用只花费常数时间,因为在循环时该迭代器位于需要被删除的节点,因此是常数操作。对于一个ArrayList,即使该迭代器位于需要被删除的节点,其remove()方法依然是昂贵的,因为数组项必须移动。下面贴出示例代码以及运行结果
    在这里插入图片描述

    public class RemoveByIterator {
    
    	public static void main(String[] args) {
    		
    		List<Integer> arrList1 = new ArrayList<>();
    		for(int i=0;i<100000;i++) {
    			arrList1.add(i);
    		}
    		
    		List<Integer> linList1 = new LinkedList<>();
    		for(int i=0;i<100000;i++) {
    			linList1.add(i);
    		}
    
    		List<Integer> arrList2 = new ArrayList<>();
    		for(int i=0;i<100000;i++) {
    			arrList2.add(i);
    		}
    		
    		List<Integer> linList2 = new LinkedList<>();
    		for(int i=0;i<100000;i++) {
    			linList2.add(i);
    		}
    		
    		removeEvens(arrList1,"ArrayList");
    		removeEvens(linList1,"LinkedList");
    		removeEvensByIterator(arrList2,"ArrayList");
    		removeEvensByIterator(linList2,"LinkedList");
    		
    	}
    	public static void removeEvensByIterator(List<Integer> lst ,String name) {//利用迭代器remove偶数
    		long sTime = new Date().getTime();
    		Iterator<Integer> itr = lst.iterator();
    		while(itr.hasNext()) {
    			
    			if(itr.next()%2 ==0)
    				itr.remove();
    		}
    		
    		System.out.println(name+"使用迭代器时间:"+(new Date().getTime()-sTime)+"毫秒");
    	}
    	
    	public static void removeEvens(List<Integer> list , String name) {//不使用迭代器remove偶数
    		long sTime = new Date().getTime();
    		int i=0;
    		while(i<list.size()) {
    			
    			if(list.get(i)%2==0) {
    				list.remove(i);
    			}else {
    				i++;
    			}
    		}
    	
    		System.out.println(name+"不使用迭代器的时间"+(new Date().getTime()-sTime)+"毫秒");
    	}
    }
    

    原理 重点看一下LinkedList的迭代器

    另一篇博客 Iterator简介 LinkedList使用迭代器优化移除批量元素原理
    调用方法:list.iterator();
    在这里插入图片描述
    重点看下remove方法

    private class ListItr implements ListIterator<E> {
            //返回的节点
            private Node<E> lastReturned;
            //下一个节点
            private Node<E> next;
            //下一个节点索引
            private int nextIndex;
            //修改次数
            private int expectedModCount = modCount;
    
            ListItr(int index) {
                //根据传进来的数字设置next等属性,默认传0
                next = (index == size) ? null : node(index);
                nextIndex = index;
            }
            //直接调用节点的后继指针
            public E next() {
                checkForComodification();
                if (!hasNext())
                    throw new NoSuchElementException();
                lastReturned = next;
                next = next.next;
                nextIndex++;
                return lastReturned.item;
            }
            //返回节点的前驱
            public E previous() {
                checkForComodification();
                if (!hasPrevious())
                    throw new NoSuchElementException();
    
                lastReturned = next = (next == null) ? last : next.prev;
                nextIndex--;
                return lastReturned.item;
            }
            /**
            * 最重要的方法,在LinkedList中按一定规则移除大量元素时用这个方法
            * 为什么会比list.remove效率高呢;
            */
            public void remove() {
                checkForComodification();
                if (lastReturned == null)
                    throw new IllegalStateException();
    
                Node<E> lastNext = lastReturned.next;
                unlink(lastReturned);
                if (next == lastReturned)
                    next = lastNext;
                else
                    nextIndex--;
                lastReturned = null;
                expectedModCount++;
            }
    
            public void set(E e) {
                if (lastReturned == null)
                    throw new IllegalStateException();
                checkForComodification();
                lastReturned.item = e;
            }
    
            public void add(E e) {
                checkForComodification();
                lastReturned = null;
                if (next == null)
                    linkLast(e);
                else
                    linkBefore(e, next);
                nextIndex++;
                expectedModCount++;
            }
        }
    

    LinkedList 源码的remove(int index)的过程是
    先逐一移动指针,再找到要移除的Node,最后再修改这个Node前驱后继等移除Node。如果有批量元素要按规则移除的话这么做时间复杂度O(n²)。但是使用迭代器是O(n)。

    先看看list.remove(idnex)是怎么处理的

    LinkedList是双向链表,这里示意图简单画个单链表
    比如要移除链表中偶数元素,先循环调用get方法,指针逐渐后移获得元素,比如获得index = 1;指针后移两次才能获得元素。
    当发现元素值为偶数是。使用idnex移除元素,如list.remove(1);链表先Node node(int index)返回该index下的元素,与get方法一样。然后再做前驱后继的修改。所以在remove之前相当于做了两次get请求。导致时间复杂度是O(n)。在这里插入图片描述
    在这里插入图片描述
    继续移除下一个元素需要重新再走一遍链表(步骤忽略当index大于半数,链表倒序查找)
    在这里插入图片描述
    以上如果移除偶数指针做了6次移动。

    • 删除2节点
      get请求移动1次,remove(1)移动1次。
    • 删除4节点
      get请求移动2次,remove(2)移动2次。

    迭代器的处理

    迭代器的next指针执行一次一直向后移动的操作。一共只需要移动4次。当元素越多时这个差距会越明显。整体上移除批量元素是O(n),而使用list.remove(index)移除批量元素是O(n²)
    在这里插入图片描述

    展开全文
  • java List复制:浅拷贝与深拷贝

    千次阅读 2019-06-13 17:11:22
    List浅拷贝 众所周知,list本质上是...如上图将list A浅拷贝给list B,由于进行的是浅拷贝,所以直接将A的内容复制给了B,java中相同内容的数组指向同一地址,即进行浅拷贝后A与B指向同一地址。造成的后果就是,...
  • Java List添加list的用法及总结

    千次阅读 2020-03-30 10:17:32
    类型,并将每次在数据库中查询的数据存到结果集为List类型的集合里,然后根据本主题下的投票记录遍历存放list。现总结一下 1、如果这样存放 则会出现以上的问题,每次按照定义的循环add完之后才能添加(会导致重复...
  • Java List 更换指定位置的元素

    千次阅读 2020-11-28 18:31:57
    Java List 更换指定位置的元素 使用的方法是list.set() 方法 下面写一个list 说下具体的使用 List<String> list = new ArrayList<>(); list.add("1"); list.add("2"); list.add("3"); Log.e("--...
  • Java List对象转List Map

    千次阅读 2019-05-16 16:27:58
    例  public class Student{  private Integer sex;  private String name;   }  转:  [{name="XXX",sex=0}] public static <T extends IdEntity>... List<Map<Object,Object>> E...
  • java list 查找元素

    千次阅读 2020-06-22 11:21:03
    list中查找符合条件的元素是一个很常见的需求,有很多办法可以做到,详见参考链接。本文讨论的点是如何把这个过程封装成一个方法,这样做的好处如下: 1.简化调用 2.容易替换成不同的实现 3.可以做一些统一的...
  • Java List.addAll()方法:添加所有元素到列表中 Java 集合类的 List.addAll() 方法用于将指定 collection 中的所有元素添加到列表。 语法1 用于将指定 collection 中的所有元素添加到列表的尾部。如果 List 集合对象...
  • Java List的remove()方法陷阱

    千次阅读 2019-07-04 16:35:08
    JavaList在删除元素时,一般会用list.remove(o)/remove(i)方法。在使用时,容易触碰陷阱,得到意想不到的结果。总结以往经验,记录下来与大家分享。 首先初始化List,代码如下: package com.cicc.am.test; ...
  • java List转json

    万次阅读 2019-05-25 19:14:30
    哎,现在网上的博客质量是越来越差了,有时候很简单的一个问题回答的都很不全面,无语。 一、首先引入依赖: <dependency> <groupId>com.fasterxml.jackson.core</groupId>.../artif...
  • **List 集合转Set 集合 ** List 集合和Set 集合的区别 在说如何List集合转Set 集合之前我们先回顾一下List 集合和Set 集合的区别。 他们之间比较细致的区别有蛮多的,不过比较粗糙地来说List 和Set 之间的区别有...
  • java list转tree实现树状菜单

    千次阅读 2019-02-21 09:37:57
    比如存储的是中国的省市县的ID、名称与父节点ID,读出来的数据并不是前台想要的(当然现在好多tree库可以使用,不要拆台,最起码不好看是吧==),这个时候我们要想法处理一下都出来的list,将它变为一个树。...
  • Java List的安全删除

    千次阅读 2018-11-12 10:57:29
    List调用remove(index)方法后,会移除index位置上的元素,index之后的元素就全部依次左移,即索引依次-1要保证能操作所有的数据,需要把index-1,否则原来索引为index+1的元素就无法遍历到(因为原来索引为index+1的...
  • Java list求差集问题

    千次阅读 2018-11-27 09:40:38
    API方法: public boolean removeAll(Collection&amp;amp;lt;?&...移除此 collection 中那些也包含在指定 collection 中的所有元素(可选操作)。...java.util.Collections.copy(): Collections的copy(L...
  • Scala List 转换成 Java List

    千次阅读 2018-12-12 17:09:02
    JavaList 。因此, scalaList 需要 .asJava 转换成 JavaList 。 先 import scala.collection.JavaConverters._ 才有 .asJava 方法。 会有: val settings: MongoClientSettings = MongoClientSettings.builder...
  • list数组中的某个参数,比如:一个证书,多个管理...1.第一种方法采用java8 String.join 字符串拼接 // 我比较喜欢这种方法 public static void main(String[] args) { List<String> list = Lists.newArrayL...
  • ArrayList数组、LinkedList如何在最前面加一个元素? list.add(0, object); 使用了List.add(int index, E element)方法,当第一个参数为0的时候,代表往List最前面增加一个元素。
  • Java List 5 种迭代方式

    千次阅读 2018-08-31 16:13:17
    代码实例 package tech.zhuyuan.demo.designpattern.iterator.concurrent; import java.util.ArrayList; import java.util.Arrays;...import java.util.List; /** * 5种迭代方式 */ public cla...
  • Java List<T> 获取最小值

    千次阅读 2019-10-21 17:57:02
    获取List中的最大最小值,可以直接使用以下代码 Collections.min(); Collections.max() 不过这个方法的参数值却是类似List< Integer > 或者 List< double > 对于实体类的List来说就不太管用了,那么...
  • JAVA List泛型限制

    千次阅读 2018-08-21 21:28:57
    相信有很多朋友已经发现在JAVA中下面的代码会报错,但却不知道为什么,百度搜来搜去也都没有一个完全能够让人信服的解释。 public class Tester{ public static void main(String[] args) { List&lt;? ...
  • Java List 用法

    万次阅读 2018-10-15 19:53:03
    list中可以添加任何对象,我可以给你举个例子: class Person{ … } 上面定义了一个Person类,下面看好如何使用List Person p1=new Person(); Person p2=new Person(); List list=new ArrayList(); list.add...
  • Java List随机取值

    万次阅读 2018-04-24 16:43:40
    方法1 public static void main... List&lt;String&gt; list = Arrays.asList("a","b","c"); int index = (int) (Math.random()* list.size()); System.out.println(...
  • java list toString()的坑

    万次阅读 2019-06-17 10:20:54
    今天发现Java list直接调用toString()方法是有坑的,比如: List<String> list = Arrays.asList("123", "456", "789"); 打印System.out.print(list.toString())发现结果为[123, 456, 789]发现问题了没?在123...
  • JavaList集合递归树状结构

    千次阅读 2019-04-08 16:07:27
    从数据库查出一堆集合数据之后,数据是按照一二三级这种规律,在这里做一个树状排序,为了方便大家... *parentId为当前List最上层父id *idKey为实体类对象中id键名 *parentKey为实体类对象中id的键名 *childNa...
  • java list倒序输出及复制list集合

    千次阅读 2018-05-14 10:22:19
    有时我们需要把java list集合倒序输入,java list倒序输出其实很简单,就一行代码就可以把原有的list倒序过来了如原来有一个集合listlist里面是有数据的,现在如果把list
  • 关于java List 添加数据的方法的使用

    千次阅读 2020-06-05 09:53:58
    List 添加元素的方法通常有① boolean add(E e);② void add(int index, E element); ① boolean add(E e);每次添加的元素被放置在list的尾部; ② void add(int index, E element);在插入操作过程中指定插入的...
  • java list 分组求和 java8

    千次阅读 2019-06-22 12:10:28
    //list 分组求和 java8 Map<String, LongSummaryStatistics> newLog = stockLogs.stream().collect( Collectors.groupingBy( S...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,268,329
精华内容 907,331
关键字:

javalist

java 订阅