精华内容
下载资源
问答
  • List集合

    千次阅读 2018-03-16 20:39:07
    List集合 1.List接口继承Collection接口,实现了List接口的类称为List集合。 2.在List集合中允许出现重复的元素,所有元素以线性方式进行存储,可以通过索引来访问集合中指定的元素。List集合的元素的存储顺序和...

    List集合

    1.List接口继承Collection接口,实现了List接口的类称为List集合。

    2.List集合中允许出现重复的元素,所有元素以线性方式进行存储,可以通过索引来访问集合中指定的元素。List集合的元素的存储顺序和取出顺序一致。

    3.List不但继承了Collection接口中的全部方法,还增加了一些根据元素位置索引来操作集合的特有方法。

    注意:集合不能定义为基本数据类型(int、char、float……),应该定义为包装类数据类型(Integer、String……)。

    ArrayList集合和LinkedList集合的区别:

    1、ArrayList集合底层是数组,而且是Object [] 类型;而LinkedList集合底层是链表。

    2、ArrayList集合查询数据很快,但是增删数据很慢;LinkedList集合增删数据很快。但是查询数据很慢。

    List集合中常用方法:

    add(Object object):向集合中添加数据

    get(int index):获取集合中指定的索引位置的元素数值

    size():获取集合的长度

    isEmpty():判断集合是否为空

    contains(Object object);//判断结合中是否含有指定的这个元素

    set(int index, Object object):更改集合中指定索引位置的元素数值

    toArray():将集合转换为数组

    remove(int index):删除集合中指定索引位置的元素数值

    clear():清空集合元素数值,谨慎使用

    ArrayList集合

    1.ArrayListList接口的一个实现类,它是程序中最常见的一种集合类;

    2.在ArrayList内部封装了一个数组对象,初始长度缺省为10,当存入的元素超过数组长度时,ArrayList会在内存中分配一个更大的数组来重新容纳这些元素,因此可以将ArrayList集合看作一个长度可变的数组;

    3.ArrayList集合类的大部分方法都是从父类CollectionList继承过来的,其中add()方法和get()方法用于实现元素的添加和读取。

    4.ArrayList集合的内部使用一个数组来保存元素。在删除元素时,会将被删除元素之后的元素都向前移一个位置以填补空位;而在用add(intindex, Object element)方法添加元素时,是把元素插入index指向的位置,先把该位置的元素以及后续元素都向后移一个位置,如果超出数组的容量,会创建更大的新数组。因为增删元素会导致大量的内存操作,所以效率低,但ArrayList集合允许通过索引随机的访问元素,查询效率高。

    5.集合和数组一样,索引的取值范围是从0开始,到size-1为止(size是集合的长度),不能超出此范围,否则会引发异常。add(Objecto)方法是把元素添加到集合的尾部,而add(intindex, Object o)是把元素添加到由索引index指定的位置。

    package com.test;
    
    import java.util.ArrayList;
    import java.util.Arrays;
    
    public class Test1 {
    	
    	
    	@SuppressWarnings({ "unchecked", "rawtypes" })
    	public static void main(String[] args) {
    		
    		ArrayList alist = new ArrayList();
    		
    		//向集合alist中添加数据
    		alist.add(1);
    		alist.add(2);
    		alist.add(3);
    		alist.add(4);
    		alist.add(5.00);
    		alist.add(6.00);
    		alist.add("字符串1");
    		alist.add("字符串2");
    		alist.add('A');
    		alist.add('B');
    		
    		int length = alist.size();//获取集合的长度
    		System.out.println("集合长度是:"+length);//集合长度是:10
    		
    		boolean flag =  alist.isEmpty();//判断集合是否为空
    		boolean flag2 =  alist.contains(4);//判断结合中是否还有4这个数据
    		System.out.println("集合是否为空:"+flag);//集合是否为空:false
    		System.out.println("集合中是否含有数字4:"+flag2);//集合中是否含有数字4:true
    		
    		Object obj = alist.get(7);//获取集合下标为7的元素值
    		System.out.println("集合下标为7的元素值:"+obj);//集合下标为7的元素值:字符串2
    		
    		alist.set(4, "我是Hern");//更改集合下标为4的元素的值,将其修改为:我是Hern
    		
    		Object[] obj2 = alist.toArray();
    		System.out.println("数组obj2的数值是:");
    		for (Object object : obj2) {
    			System.out.println(object);
    		}//输出结果是:1  2  3  4  我是Hern  6.0  字符串1  字符串2  A  B
    		
    		
    		alist.remove(3);//删除集合下标为3的元素数值
    		
    		// alist.clear();//清空集合,谨慎使用
    		System.out.println("alist集合的数值是:");
    		for (Object object : alist) {
    			System.out.println(object);
    		}//输出结果是:1  2  3  我是Hern  6.0  字符串1  字符串2  A  B
    		
    	}
    
    }
    

    给ArrayList集合指定类型:

    package com.test;
    
    import java.lang.reflect.Array;
    import java.util.ArrayList;
    import java.util.Arrays;
    import java.util.LinkedList;
    
    public class Test1 {
    	
    	@SuppressWarnings({ "unchecked", "rawtypes" })
    	public static void main(String[] args) {
    		
    		ArrayList<String> alist = new ArrayList<>();
    		
    		//向集合alist中添加数据
    		alist.add("字符串1");
    		alist.add("字符串2");
    		alist.add("字符串3");
    		alist.add("字符串4");
    		alist.add("字符串5");
    		alist.add("字符串6");
    		
    		int length = alist.size();//获取集合的长度
    		System.out.println("集合长度是:"+length);//集合长度是:6
    		
    		boolean flag =  alist.isEmpty();//判断集合是否为空
    		boolean flag2 =  alist.contains(4);//判断结合中是否还有4这个数据
    		System.out.println("集合是否为空:"+flag);//集合是否为空:false
    		System.out.println("集合中是否含有数字4:"+flag2);//集合中是否含有数字4:false
    		
    		Object obj = alist.get(4);//获取集合下标为7的元素值
    		System.out.println("集合下标为4的元素值:"+obj);//集合下标为4的元素值:字符串5
    		
    		Object[] obj2 = alist.toArray();
    		
    		for(Object object : obj2) {
    			System.out.println(object);
    		}
    		
    		alist.remove(2);
    		alist.set(3, "我是Hern");
    		
    		System.out.println("alist集合的数值是:");
    		for (Object object : alist) {
    			System.out.println(object);
    		}//输出结果是:1  2  3  我是Hern  6.0  字符串1  字符串2  A  B
    		
    	}
    
    }
    

     

     LinkedList集合

    1.List接口的另一个实现类LinkedList,克服了ArrayList集合在增删元素时效率较低的局限性。但是LinkedList集合的查询效率低(不支持随机访问),要查询第n个元素,必须从第一个元素开始,逐一的向后遍历,直到第n个元素。

    2.该集合内部维护了一个双向链表,链表中的每个元素都通过对象引用来记住它的前一个元素和后一个元素,从而将所有的元素彼此连接起来。

    3.当插入一个新元素时,只需要修改元素之间的引用关系即可,删除一个节点也是如此。LinkedList集合添加元素和删除元素的过程如下图所示:

    ArrayList集合 和 LinkedList集合在进行插入的时候必须参照已有的顺序进行插入,如果插入到已存在的顺序中,将会把原有该位置的集合元素覆盖,如果插入的是在已有顺序之后的不连续位置则会运行的时候抛出异常。(例如已有的顺序为5,则不能向7中插入,可以向6中插入)。

    import java.util.*;
    import java.io.*;
    import java.math.*;
    
    public class Main{ 
        
    	public static void main(String[] args) {
    		LinkedList link = new LinkedList();   //创建LinkedList集合,初始为空列表
            link.add("stu1");
            link.add("stu2");
            link.add("stu3");
            link.add("stu4");
            
            System.out.println(link.get(2));	//获取下标位置为2的元素
            System.out.println(link.toString());  //打印集合中的元素
            
            link.add(3, "Student");   //向集合指定位置插入元素,会把原来3的位置元素替换掉
            link.addFirst("First");    //向集合第一个位置插入元素
            
            System.out.println(link);    //另一种方式打印集合中的元素
            
            System.out.println(link.getFirst());  //打印第一个元素
            
            link.remove(3);   //删除索引值为3的元素
            link.removeFirst();   //删除第一个元素
           
            System.out.println(link);  
    		/*运行结果是:
    		 stu3
    		 [stu1, stu2, stu3, stu4]
    		 [First, stu1, stu2, stu3, Student, stu4]
    		 First
    		 [stu1, stu2, Student, stu4]
    		*/
    	
    	}
    }

     

    展开全文
  • list 集合

    千次阅读 2011-08-09 17:10:32
    3、List集合 List集合为列表类型,列表的主要特征是存放其中的对象以线性方式存储,没有特定的顺序,只有一个开头和结尾,当然,它与根本没有顺序的集类型时不同的。 (1)List集合的用法 List集合包括List接口...
    3、List集合 
    List集合为列表类型,列表的主要特征是存放其中的对象以线性方式存储,没有特定的顺序,只有一个开头和结尾,当然,它与根本没有顺序的集类型时不同的。
    (1)List集合的用法
    List集合包括List接口以及List接口的所有实现类。因为List接口继承了Collection接口,所以List接口拥有Collection接口提供的所有常用方法,又因为List是列表类型,所以List接口还提供了一些适合于自身的常用方法,如下表2所示:



    从上表可以看出,List接口提供的适合于自身的常用方法均与索引有关,这是因为List集合为列表类型,以线性方式存储对象,可以通过对象的索引操作对象。
    List接口的常用实现类有ArrayList和LinkedList,在使用List集合时,通常情况下声明为List类型,实例化时根据实际情况的需要,实例化为ArrayList或LinkedList,例如:
    List<String> l1 = new ArrayList<String>();//利用ArrayList类实例化List集合
    List<String> l2 = new LinkedList<String>();//利用LinkedList类实例化List集合
    (1.1)add(int index,Object obj)方法和set(int index,Object obj)方法的区别
    在使用List集合时需要注意区分add(int index,Object obj)方法和set(int index,Object obj)方法,前者是向指定的索引位置添加对象,而后者是修改指定的索引位置的对象。
    例如:

    import java.util.*;
    public class TestList{
    	public static void main(String args[]){
    		String a = "A" , b = "B" , c =  "C" , d = "D" , e = "E";
    		List<String> list = new LinkedList<String>();
    		list.add(a);
    		list.add(e);
    		list.add(d);
    		list.set(1,b);//将索引位置为1的对象e修改为对象b
    		list.add(2,c);//将对象c添加到索引位置为2的位置
    		Iterator<String> it = list.iterator();
    		while(it.hasNext()){
    			System.out.println(it.next());
    		}
    	}
    }

    程序的运行结果如下:
    A
    B
    C
    D

    因为List集合可以通过索引位置访问对象,所以还可以通过for循环遍历List集合,例如遍历上面代码中的List集合的代码如下:

    for(int i=0;i<list.size();i++){
    	System.out.println(list.get(i));//利用get(int index)方法获得指定索引位置的对象
    }

    (1.2)indexOf(Object obj)方法和lastIndexOf(Object obj)方法的区别
    在使用List集合时需要注意区分index(Object obj)方法和lastIndexOf(Object obj)方法,前者是获得指定对象的最小的索引位置,而后者是获得指定对象的最大的索引位置。前提条件是指定的对象在List集合中具有重复的对象,如果在List集合中有且仅有一个指定的对象,则通过这两个方法获得的索引位置是相同的。
    例如:

    String a = "A" , b = "B" , c = "C" , d = "D" , repeat = "Repeat";
    List<String> list = new ArrayList<String>();
    list.add(a);      //索引位置为0
    list.add(repeat); //索引位置为1
    list.add(b);      //索引位置为2
    list.add(repeat); //索引位置为3
    list.add(c);      //索引位置为4
    list.add(repeat); //索引位置为5
    list.add(d);      //索引位置为6
    System.out.println(list.indexOf(repeat));
    System.out.println(list.lastIndexOf(repeat));
    System.out.println(list.indexOf(b));
    System.out.println(list.lastIndexOf(b));

    程序的运行结果如下:
    1
    5
    2
    2

    (1.3)subList(int fromIndex,int toIndex)方法
    在使用subList(int fromIndex,int toIndex)方法截取现有List集合中的部分对象生成新的List集合时,需要注意的是,新生成的集合中包含起始索引位置代表的对象,但是不包含终止索引位置代表的对象。
    例如:

    String a = "A" , b = "B" , c = "C" , d = "D" , e = "E";
    List<String> list = new ArrayList<String>();
    list.add(a);
    list.add(b);
    list.add(c);
    list.add(d);
    list.add(e);
    list = list.subList(1,3);
    for(int i=0;i<list.size();i++){
    	System.out.println(list.get(i));
    }
    

    程序的运行结果如下:
    B
    C


    (2)使用ArrayList类
    ArrayList类实现了List接口,由ArrayList类实现的List集合采用数组结构保存对象。数组结构的优点是便于对集合进行快速的随机访问,如果经常需要根据索引位置访问集合中的对象,使用由ArrayList类实现的List集合的效率较好。数组结构的缺点是向指定索引位置插入对象和删除指定索引位置对象的的速度较慢,如果经常需要向List集合的指定索引位置插入对象,或者是删除List集合的指定索引位置的对象,使用由ArrayList类实现的List集合的效率则较低,并且插入或删除对象的索引位置越小效率越低,原因是当向指定的索引位置插入对象时,会同时将指定索引位置及之后的所有对象相应的向后移动一位,如图2所示。当删除指定索引位置的对象时,会同时将指定索引位置之后的所有对象相应的向前移动一位,如图3所示。如果在指定的索引位置之后有大量的对象,将严重影响对集合操作效率。





    下面看一个模仿经常需要随机访问集合中对象的例子:
    例如:

    String a = "A" , b = "B" , c = "C" , d = "D" , e = "E";
    List<String> list = new ArrayList<String>();
    list.add(a);
    list.add(b);
    list.add(c);
    list.add(d);
    list.add(e);
    System.out.println(list.get((int)(Math.random()*5)));

    程序运行结果是随机的。

    (3)使用LinkedList类
    LinkedList类实现了List接口,用LinkedList类实现的List集合采用链表结构保存对象。链表结构的优点是便于向集合中插入和删除对象,如果经常需要向集合中插入对象,或者是从集合中删除对象,使用由LinkedList类实现的List集合的效率较好。链表结构的缺点是随机访问对象的速度较慢,如果经常需要随机访问集合中的对象,使用LinkedList类实现的List集合的效率较低。用LinkedList类实现的List集合便于插入或删除对象的原因是当插入或删除对象时,只需要简单的修改链接位置,分别如图4和图5所示,省去了移动对象的操作。





    LinkedList类还根据采用链表结构保留对象的特点,提供了几个专有的操作集合的方法,如下表3所示:



    例如:

    String a = "A" , b = "B" , c = "C" , test = "Test";
    LinkedList<String> list = new LinkedList<String>();
    list.add(a);//索引位置为0
    list.add(b);//索引位置为1
    list.add(c);//索引位置为2
    System.out.println(list.getFirst());//获得并输出链表开头的对象
    list.addFirst(test);//向链表的开头添加一个对象
    System.out.println(list.getFirst());//获得并输出链表开头的对象
    list.removeFirst();//移除链表开头的对象
    System.out.println(list.getFirst());//获得并输出链表开头的对象

    程序的运行结果如下:
    A
    Test
    A


    (4)客户化排序List集合
    在使用List集合时,通常情况下希望从集合中得到的对象是按照一定顺序排列的,但是List集合的默认排序方式为按照对象的插入顺序,可以通过java.util.Collections类的静态方法sort(List<T> list)、sort(List<T> list,Comparator<? super T> c)或reverse(List<?> list)对集合中的对象进行客户化排序,其中方法sort(List<T> list)和reverse(List<?> list)要求集合中的对象必须实现java.lang.Comparable接口,即实现方法compareTo(),该方法的具体定义如下:
    public int compareTo(T o);
    方法sort(List<T> list)是将集合中的所有对象按正序排列,方法reverse(List<?> list)是将集合中的所有对象按倒序排列;方法sort(List<T> list,Comparator<? super T> c)不要求集合中的对象必须实现Comparable接口,但是在使用该方法时需要显式设置比较器,即该方法的第2个入口参数,比较器必须实现java.util.Comparator接口,即实现方法compare(),该方法的就具体定义如下:
    int compare(T o1,T o2);
    比较器的功能是实现对集合中所有对象的排序策略。
    注意:List集合进行客户化排序的前提条件是List集合中的元素为同一类型。
    1、通过实现java.lang.Comparable接口实现客户化排序
    例如:
    源文件:CnToSpell.java(源文件见下载处CnToSpell.rar压缩文件)
    源文件:Person.java

    public class Person implements Comparable{
    	private String name;
    	private long id_card;
    	public String getName(){
    		return name;
    	}
    	public void setName(String name){
    		this.name = name;
    	}
    	public long getId_card(){
    		return id_card;
    	}
    	public void setId_card(long id_card){
    		this.id_card = id_card;
    	}
    	public int compareTo(Object o){//实现Comparable接口的方法
    		Person p = (Person)o;
    		String s1 = CnToSpell.getFullSpell(this.name);//获得汉字的全拼
    		String s2 = CnToSpell.getFullSpell(p.getName());
    		return s1.compareTo(s2);//比较两个字符串的大小
    	}
    }
    

    源文件:TestList.java

    import java.util.*;
    public class TestList{
    	public static void main(String args[]){
    		List<Person> list = new ArrayList<Person>();
    		String names[] = {"马先生","王小姐","李先生"};
    		long id_cards[] ={22015,22020,22018};
    		for(int i=0;i<names.length;i++){//初始化List集合
    			Person person = new Person();
    			person.setName(names[i]);
    			person.setId_card(id_cards[i]);
    			list.add(person);
    		}
    		System.out.println("排序前:");
    		for(int i=0;i<list.size();i++){//遍历List集合
    			Person person = list.get(i);
    			System.out.println("-----"+person.getName()+"	"+person.getId_card());
    		}
    		//利用java.util.Collections类的sort(List list)或reverse(List list)方法对List集合排序
    		Collections.sort(list);//按升序排序
    		System.out.println("升序排列后:");
    		for(int i=0;i<list.size();i++){//遍历List集合
    			Person person = list.get(i);
    			System.out.println("-----"+person.getName()+"	"+person.getId_card());
    		}
    		Collections.reverse(list);//按降序排列
    		System.out.println("降序排列后:");
    		for(int i=0;i<list.size();i++){//遍历List集合
    			Person person = list.get(i);
    			System.out.println("-----"+person.getName()+"	"+person.getId_card());
    		}
    	}
    }
    

    程序的运行结果如下:
    排序前:
    -----马先生     22015
    -----王小姐     22020
    -----李先生     22018
    升序排列后:
    -----李先生     22018
    -----马先生     22015
    -----王小姐     22020
    降序排列后:
    -----王小姐     22020
    -----马先生     22015
    -----李先生     22018

    利用这种方式实现对List集合进行客户化排序,缺点是对于每个类只能采用一种排序方式,对于排序方式需求单一的对象,可采用该种方式。
    2、通过实现java.util.Comparator接口实现客户化排序
    例如:
    源文件:CnToSpell.java(源文件见下载处CnToSpell.rar压缩文件)
    源文件:Person.java

    public class Person{
    	private String name;
    	private long id_card;
    	public long getId_card(){
    		return id_card;
    	}
    	public void setId_card(long id_card){
    		this.id_card = id_card;
    	}
    	public String getName(){
    		return name;
    	}
    	public void setName(String name){
    		this.name = name;
    	}
    }
    

    源文件:PersonComparator.java

    import java.util.Comparator;
    public class PersonComparator implements Comparator{
    	//为可能参与排序的属性定义同名的静态常量值
    	public static final int NAME = 1;
    	public static final int ID_CARD = 2;
    	private int orderByColumn = 1;//默认排序为按姓名排序
    	public int compare(Object o1,Object o2){//实现Comparator接口的方法
    		Person p1 = (Person)o1;
    		Person p2 = (Person)o2;
    		int result = 0;//默认的判断结果为两个对象相等
    		switch(orderByColumn){//判断排序条件
    			case 1://按姓名排序
    				String s1 = CnToSpell.getFullSpell(p1.getName());//获得汉字的全拼
    				String s2 = CnToSpell.getFullSpell(p2.getName());
    				result = s1.compareTo(s2);//比较两个字符串的大小
    				break;
    			case 2:
    				result = (int)(p1.getId_card()-p2.getId_card());//比较两个整数的大小
    				break;
    		}
    		return result;
    	}
    	public void orderByColumn(int orderByColumn){//用来设置排序条件
    		this.orderByColumn = orderByColumn;
    	}
    }
    

    源文件:TestList.java

    public class TestList{
    	public static void main(String args[]){
    		List<Person> list = new ArrayList<Person>();
    		String names[] ={"马先生","王小姐","李先生"};
    		long id_cards[] = {22015,22020,22018};
    		for(int i= 0;i<names.length;i++){
    			Person person = new Person();
    			person.setName(names[i]);
    			person.setId_card(id_cards[i]);
    			list.add(person);
    		}
    		System.out.println("排序前:");
    		for(int i=0;i<list.size();i++){
    			Person person = list.get(i);
    			System.out.println("-----"+person.getName()+"	"+person.getId_card());
    		}
    		PersonComparator personComparator = new PersonComparator();//创建比较器对象
    		System.out.println("按姓名排序:");
    		Collections.sort(list,personComparator);//默认为按姓名排序,排序List集合
    		for(int i=0;i<list.size();i++){
    			Person person = list.get(i);
    			System.out.println("-----"+person.getName()+"	"+person.getId_card());
    		}
    		System.out.println("按编号排序:");
    		personComparator.orderByColumn(PersonComparator.ID_CARD);//设置为按编号排序
    		Collections.sort(list,personComparator);
    		for(int i=0;i<list.size();i++){
    			Person person = list.get(i);
    			System.out.println("-----"+person.getId_card()+"	"+ person.getName());
    		}
    	}
    }
    

    程序的运行结果如下:
    排序前:
    -----马先生     22015
    -----王小姐     22020
    -----李先生     22018
    按姓名排序:
    -----李先生     22018
    -----马先生     22015
    -----王小姐     22020
    按编号排序:
    -----22015      马先生
    -----22018      李先生
    -----22020      王小姐

    利用这种方式实现对List集合进行客户化排序,排除了每个类只能采用一种排序方式的弊端,可以根据实际需要,将List集合按照不同的方式排序。这里是按姓名的全称升序排列,如果想改为降序排列,只需将例子中的的如下代码:

    result = s1.compareTo(s2);

    修改改为:

    result = s2.compareTo(s2);

    编号也是按升序排列的,如果也想改为降序排列,只需将例子中的如下代码:

    result = (int)(p1.getId_card()-p2.getId_card());

    修改为:

    result = (int)(p2.getId_card()-p1.getId_card());

     

     

     

      转载请标明出处 http://blog.csdn.net/shimiso 

    技术交流群:361579846


    展开全文
  • List集合的各种排序

    万次阅读 多人点赞 2019-02-15 17:56:39
    在Java编程中,经常要对List集合进行排序,因此对List排序的各种情况进行总结,希望对各位读者有所帮助。 1.单属性变量List排序 1.1按照变量属性升序,降序排序 /** * 单属性变量list 自身属性升序, 降序排序 ...

    在Java编程中,经常要对List集合进行排序,因此对List排序的各种情况进行总结,希望对各位读者有所帮助。

    1.单属性变量List排序

              1.1按照变量属性升序,降序排序

    /**
     * 单属性变量list 自身属性升序, 降序排序
     */
    private void singleVariableSort1(){
    
        List<Integer> list = Arrays.asList(10,1,6,4,8,7,9,3,2,5);
    
        System.out.println("原始数据:");
        list.forEach(n ->{System.out.print(n+", ");});
    
        System.out.println("");
        System.out.println("升序排列:");
        Collections.sort(list); // 升序排列
        list.forEach(n ->{System.out.print(n+", ");});
    
        System.out.println("");
        System.out.println("降序排列:");
        Collections.reverse(list); // 倒序排列
        list.forEach(n ->{System.out.print(n+", ");});
    }

              1.2按照自定义的顺序排序

    /**
     * 单属性变量list 自定义顺序排序
     */
    private void singleVariableSort2(){
    
        List<String> list = Arrays.asList("北京","上海","北京","广州","广州","上海","北京","上海");
    
        List<String> sortRule = Arrays.asList("北京","上海","广州");
    
        System.out.println("原始数据:");
        list.forEach(n ->{System.out.print(n+", ");});
    
        System.out.println("");
        System.out.println("排序规则:");
        sortRule.forEach(n ->{System.out.print(n+", ");});
    
        System.out.println("");
        System.out.println("正序排列:");
        Collections.sort(list, new Comparator<String>()
        {
            public int compare(String a1, String a2)
            {
                    int io1 = sortRule.indexOf(a1);
                    int io2 = sortRule.indexOf(a2);
                    return io1 - io2;
            }
        });
    
        list.forEach(n ->{System.out.print(n+", ");});
    
        System.out.println("");
        System.out.println("倒序排列:");
        Collections.sort(list, new Comparator<String>()
        {
            public int compare(String a1, String a2)
            {
                int io1 = sortRule.indexOf(a1);
                int io2 = sortRule.indexOf(a2);
                return io2 - io1;
            }
        });
    
        list.forEach(n ->{System.out.print(n+", ");});
    }

    2.对象List排序

              2.1按照对象单属性升序,降序排序

    /**
     * 对象单属性升序,降序排序
     */
    private void entitySort1(){
    
        //Student 的 list 集合
        List<Student> students = new ArrayList<>();
        students.add(new Student("张三",90,180,"电气学院","北京"));
        students.add(new Student("李四",80,165,"计算机学院","上海"));
        students.add(new Student("王五",91,170,"财经学院","上海"));
        students.add(new Student("赵明",80,182,"计算机学院","北京"));
        students.add(new Student("钱海",75,181,"计算机学院","广州"));
        students.add(new Student("孙理",82,172,"财经学院","上海"));
        students.add(new Student("周伟",90,168,"电气学院","广州"));
        students.add(new Student("郑亮",80,178,"财经学院","广州"));
    
        System.out.println("原始数据:");
        students.forEach(s ->{
          System.out.println(s.getName()+" "+ s.getScore()+" "+s.getHeight()+" "+ s.getCollege()+""+s.getAddress());});
    
        System.out.println("按照分数升序排序:");
        students.sort(comparing(Student::getScore));
        students.forEach(s ->{ 
         System.out.println(s.getName()+" "+ s.getScore()+" "+s.getHeight()+" "+ s.getCollege()+""+s.getAddress());}); 
    
        System.out.println("按照分数降序排序:");
        students.sort(comparing(Student::getScore).reversed());
        students.forEach(s ->{
          System.out.println(s.getName()+" "+ s.getScore()+" "+s.getHeight()+" "+s.getCollege()+""+s.getAddress());});
    }

              2.2按照对象多属性升序,降序排序

    /**
     * 对象多属性升序,降序排序
     */
    private void entitySort2(){
    
        //Student 的 list 集合
        List<Student> students = new ArrayList<>();
        students.add(new Student("张三",90,180,"电气学院","北京"));
        students.add(new Student("李四",80,165,"计算机学院","上海"));
        students.add(new Student("王五",91,170,"财经学院","上海"));
        students.add(new Student("赵明",80,182,"计算机学院","北京"));
        students.add(new Student("钱海",75,181,"计算机学院","广州"));
        students.add(new Student("孙理",82,172,"财经学院","上海"));
        students.add(new Student("周伟",90,168,"电气学院","广州"));
        students.add(new Student("郑亮",80,178,"财经学院","广州"));
    
        System.out.println("原始数据:");
        students.forEach(s ->{
          System.out.println(s.getName()+" "+ s.getScore()+" "+s.getHeight()+" "+s.getCollege()+""+s.getAddress());});
    
        System.out.println("按照分数降序排序,当分数相同时, 按照身高升序排序");
        students.sort(comparing(Student::getScore).reversed().thenComparing(Student::getHeight));
        students.forEach(s ->{
          System.out.println(s.getName()+" "+ s.getScore()+" "+s.getHeight()+" "+s.getCollege()+""+s.getAddress());});
    
        System.out.println("按照分数降序排序,当分数相同时, 按照身高降序排序");
        Collections.sort(students, new Comparator<Student>()
        {
            public int compare(Student student1, Student student2)
            {
                if(student1.getScore().equals(student2.getScore())){
                    return student2.getHeight() - student1.getHeight();
                }else{
                    return student2.getScore() - student1.getScore();
                }
            }
        });
    
        students.forEach(s ->{
          System.out.println(s.getName()+" "+ s.getScore()+" "+s.getHeight()+" "+s.getCollege()+""+s.getAddress());});
    }

              2.3按照对象自定义单属性的顺序排序

    /**
     * 对象自定义单属性的顺序排序
     */
    private void entitySort3(){
    
        //Student 的 list 集合
        List<Student> students = new ArrayList<>();
        students.add(new Student("张三",90,180,"电气学院","北京"));
        students.add(new Student("李四",80,165,"计算机学院","上海"));
        students.add(new Student("王五",91,170,"财经学院","上海"));
        students.add(new Student("赵明",80,182,"计算机学院","北京"));
        students.add(new Student("钱海",75,181,"计算机学院","广州"));
        students.add(new Student("孙理",82,172,"财经学院","上海"));
        students.add(new Student("周伟",90,168,"电气学院","广州"));
        students.add(new Student("郑亮",80,178,"财经学院","广州"));
    
        System.out.println("原始数据:");
        students.forEach(s ->{
          System.out.println(s.getName()+" "+ s.getScore()+" "+s.getHeight()+" "+s.getCollege()+""+s.getAddress());});
    
        System.out.println("自定义按照地区(北京,上海,广州)排序:");
        List<String> addressOrder = Arrays.asList("北京","上海","广州");
        Collections.sort(students, new Comparator<Student>()
        {
            public int compare(Student student1, Student student2)
            {
                    int io1 = addressOrder.indexOf(student1.getAddress());
                    int io2 = addressOrder.indexOf(student2.getAddress());
                    return io1 - io2;
            }
        });
    
        students.forEach( s ->{
           System.out.println(s.getName()+" "+ s.getScore()+" "+s.getHeight()+" "+s.getCollege()+""+s.getAddress());});
    }

              2.4按照对象自定义多属性的顺序排序

     

    /**
     * 对象自定义多属性的顺序排序
     */
    private void entitySort4(){
    
        //Student 的 list 集合
        List<Student> students = new ArrayList<>();
        students.add(new Student("张三",90,180,"电气学院","北京"));
        students.add(new Student("李四",80,165,"计算机学院","上海"));
        students.add(new Student("王五",91,170,"财经学院","上海"));
        students.add(new Student("赵明",80,182,"计算机学院","北京"));
        students.add(new Student("钱海",75,181,"计算机学院","广州"));
        students.add(new Student("孙理",82,172,"财经学院","上海"));
        students.add(new Student("周伟",90,168,"电气学院","广州"));
        students.add(new Student("郑亮",80,178,"财经学院","广州"));
    
        System.out.println("原始数据:");
        students.forEach(s ->{
           System.out.println(s.getName()+" "+ s.getScore()+" "+s.getHeight()+" "+s.getCollege()+""+s.getAddress());});
    
        System.out.println("先按照学院(电气学院,计算机学院,财经学院)排序, 当学院相同时,按照地区(北京,上海,广州)排序");
        List<String> collegeOrder = Arrays.asList("电气学院","计算机学院","财经学院");
        List<String> addressOrder = Arrays.asList("北京","上海","广州");
        Collections.sort(students, new Comparator<Student>()
        {
            public int compare(Student student1, Student student2)
            {
                if(student1.getCollege().equals(student2.getCollege())){
                    int io1 = addressOrder.indexOf(student1.getAddress());
                    int io2 = addressOrder.indexOf(student2.getAddress());
                    return io1 - io2;
                }else{
                    int io1 = collegeOrder.indexOf(student1.getCollege());
                    int io2 = collegeOrder.indexOf(student2.getCollege());
                    return io1 - io2;
                }
            }
        });
    
        students.forEach( s ->{
           System.out.println(s.getName()+" "+ s.getScore()+" "+s.getHeight()+" "+s.getCollege()+""+s.getAddress());});
    }
    

              2.5按照对象属性自定义混合排序

    /**
     * 对象属性自定义混合排序
     */
    private void entitySort5(){
    
        //Student 的 list 集合
        List<Student> students = new ArrayList<>();
        students.add(new Student("张三",90,180,"电气学院","北京"));
        students.add(new Student("李四",80,165,"计算机学院","上海"));
        students.add(new Student("王五",91,170,"财经学院","上海"));
        students.add(new Student("赵明",80,182,"计算机学院","北京"));
        students.add(new Student("钱海",75,181,"计算机学院","广州"));
        students.add(new Student("孙理",82,172,"财经学院","上海"));
        students.add(new Student("周伟",90,168,"电气学院","广州"));
        students.add(new Student("郑亮",80,178,"财经学院","广州"));
    
        System.out.println("原始数据:");
        students.forEach(s ->{
          System.out.println(s.getName()+" "+ s.getScore()+" "+s.getHeight()+" "+s.getCollege()+""+s.getAddress());});
    
        //先按照分数从高到低排序,当分数相同时,然后按照地区(北京,上海,广州)排序
        List<String> addressOrder = Arrays.asList("北京","上海","广州");
        Collections.sort(students, new Comparator<Student>()
        {
            public int compare(Student student1, Student student2)
            {
                if(student1.getScore().equals(student2.getScore())){
                    int io1 = addressOrder.indexOf(student1.getAddress());
                    int io2 = addressOrder.indexOf(student2.getAddress());
                    return io1 - io2;
                }else{
                    return student2.getScore() - student1.getScore();
                }
            }
        });
    
        System.out.println("");
        System.out.println("先按照分数从高到低排序,当分数相同时,然后按照地区(北京,上海,广州)排序:");
        students.forEach( s ->{
          System.out.println(s.getName()+" "+ s.getScore()+" "+s.getHeight()+" "+s.getCollege()+""+s.getAddress());}); 
    }

              2.6按照对象单属性升序,降序排序(float类型)

    /**
     * 对象单属性升序,降序排序(float类型)
     */
    private void entitySort6(){
    
       //Shop 的 list 集合
       List<Shop> shops = new ArrayList<>();
       shops.add(new Shop("华润万家", 20200921, (float) 10000.25));
       shops.add(new Shop("华润万家", 20200922, (float) 20000.26));
       shops.add(new Shop("华润万家", 20200923, (float) 9999.37));
       shops.add(new Shop("华润万家", 20200924, (float) 12587.86));
       shops.add(new Shop("华润万家", 20200925, (float) 15798.65));
    
       System.out.println("原始数据:");
       shops.forEach(s ->{
          System.out.println(s.getName() + " " + s.getDate() + " " + s.getIncome() );
       });
    
       System.out.println("按照收入升序排序:");
       shops.sort(comparing(Shop::getIncome));
       shops.forEach(s ->{
          System.out.println(s.getName() + " " + s.getDate() + " " + s.getIncome());
       });
    
       System.out.println("按照收入降序排序:");
       shops.sort(comparing(Shop::getIncome).reversed());
       shops.forEach(s ->{
          System.out.println(s.getName() + " " + s.getDate() + " " + s.getIncome());
       });
    
    
    }

     

    展开全文
  • List集合复制

    千次阅读 多人点赞 2021-01-13 15:00:24
    List集合复制 User类 class User{ private String a; private String b; } 1. 通过循环遍历复制List集合 List<User> userList = new ArrayList<>(); User user0 = new User("a0", "b0"); userList...

    List集合复制

    User类

    class User{
        private String a;
        private String b;
    }
    

    1. 通过循环遍历复制List集合

            List<User> userList = new ArrayList<>();
            User user0 = new User("a0", "b0");
            userList.add(user0);
            userList.add(new User("a1", "b1"));
            userList.add(new User("a2", "b2"));
            //创建临时集合,通过循环遍历赋值
            List<User> temp = new ArrayList<>();
            for(User user: userList){
                temp.add(user);
            }
    		//或者通过new 来赋值
    		/*
    		for(User user: userList){
                User u = new User();
                u.setA(user.getA());
                u.setB(user.getB());
                temp.add(user);
            }
            */
            //修改其中任意集合中的对象属性(修改userList或者temp中的对象)
            userList.get(0).setA("修改AAA000");
            userList.get(0).setB("修改BBB000");
            userList.get(1).setA("修改AAA111");
            userList.get(1).setB("修改BBB111");
    
            System.out.println("userList : " + userList);
            System.out.println("temp : " + temp);	
    

    运行结果:

    userList : [User{a=‘修改AAA000’, b=‘修改BBB000’}, User{a=‘修改AAA111’, b=‘修改BBB111’}, User{a=‘a2’, b=‘b2’}]
    temp : [User{a=‘修改AAA000’, b=‘修改BBB000’}, User{a=‘修改AAA111’, b=‘修改BBB111’}, User{a=‘a2’, b=‘b2’}]

    发现:修改列表中的对象的属性值,另一个列表的值也发生了改变。

    原因:对象之间的值是复制的引用地址,对User的属性A,B修改都是修改的同一常量池的值。

    解决办法:通过new对象,开辟新的内存空间,来修改值。

    		List<User> userList = new ArrayList<>();
            User user0 = new User("a0", "b0");
            userList.add(user0);
            userList.add(new User("a1", "b1"));
            userList.add(new User("a2", "b2"));
            //创建临时集合,通过循环遍历赋值
            List<User> temp = new ArrayList<>();
            for(User user: userList){
                temp.add(user);
            }
            //通过new对象,开辟新的内存空间,来修改值
            userList.set(0, new User("AAA000", "BBB000"));
            System.out.println("userList : " + userList);
            System.out.println("temp : " + temp);
    

    运行结果:

    userList : [User{a=‘AAA000’, b=‘BBB000’}, User{a=‘a1’, b=‘b1’}, User{a=‘a2’, b=‘b2’}]
    temp : [User{a=‘a0’, b=‘b0’}, User{a=‘a1’, b=‘b1’}, User{a=‘a2’, b=‘b2’}]

    发现:对userList列表的修改,对temp的值没有发生变化

    原因:因为new对象,开辟了新的内存空间,所以两个指向的内存是不同的。

    同理:new一个对象,增加到列表中去,对另一个列表也是没有影响的

     		List<User> userList = new ArrayList<>();
            User user0 = new User("a0", "b0");
            userList.add(user0);
            userList.add(new User("a1", "b1"));
            userList.add(new User("a2", "b2"));
            //创建临时集合,通过循环遍历赋值
            List<User> temp = new ArrayList<>();
            for(User user: userList){
                temp.add(user);
            }
            ///通过new对象,然后新增到列表中
            User userAdd = new User("addA", "addB");
            userList.add(userAdd);
            System.out.println("userList : " + userList);
            System.out.println("temp : " + temp);
    

    运行结果:

    userList : [User{a=‘a0’, b=‘b0’}, User{a=‘a1’, b=‘b1’}, User{a=‘a2’, b=‘b2’}, User{a=‘addA’, b=‘addB’}]

    temp : [User{a=‘a0’, b=‘b0’}, User{a=‘a1’, b=‘b1’}, User{a=‘a2’, b=‘b2’}]

    发现:新增是不会对复制的列表有什么影响的。

    2. 可以采用ArrayList的addAll()方法来进行复制集合

    addAll()方法:传入参数List,将List中所有的元素加入到新的List集合去,前List会增加的元素个数等于传入的List的大小。

    		List<User> userList = new ArrayList<>();
            User user0 = new User("a0", "b0");
            userList.add(user0);
            userList.add(new User("a1", "b1"));
            userList.add(new User("a2", "b2"));
            
            //创建临时集合,通过addAll方法复制userList集合
            List<User> temp = new ArrayList<>();
            temp.addAll(userList);
            
            userList.get(0).setA("修改AAA000");
            userList.get(0).setB("修改BBB000");
            System.out.println("userList : " + userList);
            System.out.println("temp : " + temp);
    

    运行结果:

    userList : [User{a=‘修改AAA000’, b=‘修改BBB000’}, User{a=‘a1’, b=‘b1’}, User{a=‘a2’, b=‘b2’}]

    temp : [User{a=‘修改AAA000’, b=‘修改BBB000’}, User{a=‘a1’, b=‘b1’}, User{a=‘a2’, b=‘b2’}]

    3. 其他方式

    //创建临时变量(toArray返回Object)
    List<Object> temp =  Arrays.asList(userList.toArray());
    //直接使用 = 
    //	这种方式只是定义一个引用,指向源集合userList的内容,对其修改新增,两个集合内容变化相同
    List<User> temp = userList;	
    //这种方式,修改两个集合变化相同,新增,另一个无变化
    List<User> temp = new ArrayList<>(userList);
    

    上述方式其实都是浅层复制,当修改原list时,新list也会改变(增加不会),不能达到生成一个完全新的互不影响的list的效果。

    4. 通过Stream复制List生成两个互不影响的集合

            List<User> userList = new ArrayList<>();
            User user0 = new User("a0", "b0");
            userList.add(user0);
            userList.add(new User("a1", "b1"));
            userList.add(new User("a2", "b2"));
    
    		//stream流复制(深度复制)
            List<User> temp = userList.stream().map(user -> {
                //new对象,开辟空间
                User u = new User();
                u.setA(user.getA());
                u.setB(user.getB());
                return u;
            }).collect(Collectors.toList());
            //修改
            userList.get(0).setA("修改AAA000");
            userList.get(0).setB("修改BBB000");
            System.out.println("userList : " + userList);
            System.out.println("temp : " + temp);	
    

    运行结果:

    userList : [User{a=‘修改AAA000’, b=‘修改BBB000’}, User{a=‘a1’, b=‘b1’}, User{a=‘a2’, b=‘b2’}]
    temp : [User{a=‘a0’, b=‘b0’}, User{a=‘a1’, b=‘b1’}, User{a=‘a2’, b=‘b2’}]

    发现:通过Stream对List进行复制之后,对其中一个list进行修改,不会影响另一个list的值。

    展开全文
  • 数组转换成List集合

    万次阅读 2019-07-08 13:57:21
    问题描述:对于给定的如下数组,如何转换成List集合? String[] array = {"a","b","c"}; 参考stackoverflow总结如下几种写法: 1.使用原生方式,拆分数组,添加到List List<String> resultList = new ...
  • String转换成list集合

    万次阅读 2019-06-03 17:33:38
    数组转换成集合:Arrays.asList(数组变量名) 集合转换成数组:集合变量名.toArray();
  • Java8 Stream分割list集合

    万次阅读 2020-03-04 22:43:37
    使用Java8 Stream分割list集合,写好的工具类,可以直接用 package com.example.java8; import com.example.excel.Student; import org.apache.commons.collections4.CollectionUtils; import java.util.ArrayList...
  • Map集合和List集合总结

    千次阅读 2019-05-27 17:32:15
    Map集合和List集合哪个效率更高 List接口 List集合是一个元素有序(存储有序)、可重复的集合,集合中的每个元素都有对应的索引,以便于查询和修改,List集合是允许存储null值的。 List集合可重复原因,请看源码: ...
  • 在项目开发的过程中,我们经常会对List集合进行按条件的过滤,筛选出我们想要的结果或者是符合项目需求的数据。比如:我们有一批学生对象,每个学生都有自己的年龄属性,但是我们想要筛选出这一批学生中年龄为21和22...
  • 使用Set集合对List集合进行去重

    万次阅读 2018-03-22 23:00:21
    使用Set集合对List集合进行去重前段时间正好遇到这样一个需求:我们的支付系统从对方系统得到存储明细对象的List集合,存储的明细对象对象的明细类简化为如下TradeDetail类,需求是这样的,我要对称List集合进行去重...
  • JavaList集合add与set方法原理简介 add方法 add方法用于向集合列表中添加对象。 语法1 用于在列表的尾部插入指定元素。如果List集合对象由于调用add方法而发生更改,则返回true;否则返回false。add(Ee)e:要添加到...
  • list集合与queue集合

    千次阅读 2017-08-13 20:42:00
    1、List集合的特点 元素是有序的,元素可以重复,因为该集合体系有索引 List体系下ListIterator()具有向前迭代的功能。在迭代时不能通过集合对象的方法操作集合中的元素,因为会发生异常。 2、实现类 ArrayList和...
  • Java中List集合与Set集合

    千次阅读 2019-07-02 00:23:42
    一、List 集合 1、List 接口特点 2、List 接口中常用的方法 3、List 集合存储数据结构 4、ArrayList 集合ArrayList 集合是最常用的集合,是用存储数据结构,元素增删慢,查找快。 5、LinkedList 集合 6、...
  • 用子类list集合存储父类list集合中的元素,子类继承父类
  • List集合序列排序的两种方法

    万次阅读 多人点赞 2018-06-24 00:37:20
    首先讲一下Comparable接口和Comparator接口,以及他们之间的差异。有助于Collections.sort()方法的使用。请参考1.Comparable自然规则排序 ...//Collections.sort(集合); 先看一个简单的例子: public st...
  • List集合之ArrayList

    万次阅读 多人点赞 2018-06-24 11:43:19
    List集合之ArrayList深度解析 List集合之ArrayList深度解析 一、ArrayList解析 1.1、概览 1.1.1、java.io.Serializable接口的作用 1.1.2、讨论 RandomAccess 的作用。 1.1.3、 Cloneable接口的作用: 1.1.4、数组...
  • list集合中抽取getId转为新的集合: List<NatCustomers> natCustomersList = natCustomersService.queryListByPage(0,1000); List<Integer> customerIds = natCustomersList.stream().map...
  • 在写代码时,经常会遇到各转类型之间互相转换,比如json转换为Map,jsonArray转List集合,List集合转json,现在整理一个工具类,方便日后查阅。 import java.util.HashMap; import java.util.Iterator; import java....
  • List集合和Set集合的区别

    千次阅读 2019-06-09 22:06:51
    开发工具与关键技术:MyEclipse 10、list集合和Set集合的区别 作者: 撰写时间:2019年06月08日   List集合的详细特点:https://blog.csdn.net/weixin_43741599/article/details/91357999   Set集合类似于一个...
  • List集合累加

    千次阅读 2017-09-21 16:11:19
    比如说有两个list集合list1和list2,list1有1、2两个元素;list2有3、4两个元素;我们想把这两个集合累加在一起,那么我们可以采用下面的方法,so easy! package action; import java.util.ArrayList; import java....
  • MyBatis 传入List集合查询数据

    万次阅读 2018-08-15 15:58:33
    使用的是SSM框架,数据库是MySQL,做查询的时候传入List集合,使用SQL语句的in方式查询数据 主要有两点问题:我的List集合是利用的另外一个语句查询出来的,传入参数是int类型,返回值是int类型的List集合: ...
  • Mybatis 查询返回List集合

    万次阅读 2019-04-20 16:25:54
    Mybatis 查询返回List集合
  • Java8 List集合过滤出符合条件的List元素集合 新增实体类 public class Student { private Integer stuNum; // 学号 private String name; // 姓名 private Integer age; // 年龄 省略set get 或加 @Data...
  • JAVA集合之List集合遍历

    千次阅读 2019-01-25 22:59:20
    List集合的遍历 第一种根据集合的长度用for循环进行遍历 public static void main(String[] args) { List&amp;amp;lt;String&amp;amp;gt; arrayList = new ArrayList&amp;amp;lt;&amp;amp;...
  • ajax传递list集合

    万次阅读 2018-02-07 11:08:48
    ajax传递list集合参数
  • List集合底层原理

    千次阅读 2019-05-21 20:59:28
    List集合代表一个有序集合,集合中每个元素都有其对应的顺序索引。List集合允许使用重复元素,可以通过索引来访问指定位置的集合元素。 List接口继承于Collection接口,它可以定义一个允许重复的有序集合。因为List...
  • 保存的基本思路是将List数据转换成json格式数据,再保存 //首先引入gson库 ...保存List集合 ListString> list = new ArrayListString>(); Gson gson = new Gson(); String data = gson.toJson(list);
  • JDK8 List 集合转 Map 集合

    千次阅读 2018-12-21 14:16:35
    JDK8 List 集合转 Map 集合 方式一: List&lt;ServiceConfig&gt; list = serviceConfigService.list(null); Map&lt;Long, ServiceConfig&gt; mapAll = list.stream().collect(Collectors.toMap...
  • 比如一个List集合中List<对象1>,该对象1包含A、B和C列 另外一个List集合中List<对象2>,该对象2包含A、D列 问题:需要将两个List合成List<对象3>返回,该对象3包含A、B、C、D列 解决:1.需要...
  • 分割List集合

    千次阅读 2017-07-13 10:10:53
    工作中需要批量插入数据库,但是可能数据量太大,一次性插入会出现问题,故将原有的List集合按照一定的尺寸进行分割,然后将分割后的单个小集合做批量插入。分割的实现如下: import java.util.ArrayList; import ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 103,637
精华内容 41,454
关键字:

list集合