Collections对List集合中的数据进行排序


有时候需要对集合中的元素按照一定的规则进行排序，这就需要用到

 

Java中提供的对集合进行操作的工具类Collections，其中的sort方法

 

先看一个简单的例子：

 

public static void main(String[] args) {
	List<Integer> nums = new ArrayList<Integer>();
		nums.add(3);
		nums.add(5);
		nums.add(1);
		nums.add(0);
		System.out.println(nums);
		Collections.sort(nums);
		System.out.println(nums);
}

输出结果：

[3, 5, 1, 0]

[0, 1, 3, 5]

 

稍微复杂的List里面放一个复杂的对象

 

package core.java.collection.collections;

public class User implements Comparable<User>{
	
	private int score;
	
	private int age;
	
	public User(int score, int age){
		super();
		this.score = score;
		this.age = age;
	}

	public int getScore() {
		return score;
	}

	public void setScore(int score) {
		this.score = score;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	@Override
	public int compareTo(User o) {
		int i = this.getAge() - o.getAge();//先按照年龄排序
		if(i == 0){
			return this.score - o.getScore();//如果年龄相等了再用分数进行排序
		}
		return i;
	}
	
}

public static void main(String[] args) {
		List<User> users = new ArrayList<User>();
		users.add(new User(78, 26));
		users.add(new User(67, 23));
		users.add(new User(34, 56));
		users.add(new User(55, 23));
		Collections.sort(users);
		for(User user : users){
			System.out.println(user.getScore() + "," + user.getAge());
		}
}

输出结果：

55,23

67,23

78,26

34,56

我们会发现sort(List<T>)方法中List中的T必须实现Comparable<T>接口，然后实现

compareTo（）方法，该方法的返回值0代表相等，1表示大于，-1表示小于；为什么

在简单例子中没有看到实现Comparable接口呢？是因为Integer类其实自己已经实现

了Comparable接口，Java已经给我们做好了。


Collections提供的第二种排序方法sort(List<T> list, Comparator<? super T> c)

先看例子：

package core.java.collection.collections;

public class Students {
	
	private int age;
	private int score;
	
	public Students(int age, int score){
		super();
		this.age = age;
		this.score = score;
	}
	
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public int getScore() {
		return score;
	}
	public void setScore(int score) {
		this.score = score;
	}
}
public static void main(String[] args) {
		List<Students> students = new ArrayList<Students>();
		students.add(new Students(23, 100));
		students.add(new Students(27, 98));
		students.add(new Students(29, 99));
		students.add(new Students(29, 98));
		students.add(new Students(22, 89));
		Collections.sort(students, new Comparator<Students>() {

			@Override
			public int compare(Students o1, Students o2) {
				int i = o1.getScore() - o2.getScore();
				if(i == 0){
					return o1.getAge() - o2.getAge();
				}
				return i;
			}
		});
		for(Students stu : students){
			System.out.println("score:" + stu.getScore() + ":age" + stu.getAge());
		}
}

输出结果：

score:89:age22

score:98:age27

score:98:age29

score:99:age29

score:100:age23


从上面的例子我们可以看出Students类没有实现Comparable<T>接口，只是在sort()方法

中多传入一个参数，只不过该参数是一个接口我们需要实现其compare方法。


以上就是是Java中Colelctions工具类为我们提供的两种集合排序方法。

 

 

list去重，根据对象某个属性、某几个属性去重
去除List中重复的String

List unique = list.stream().distinct().collect(Collectors.toList());

去除List中重复的对象
// Person 对象
public class Person {
    private String id;
    
    private String name;
    
    private String sex;

    <!--省略 get set-->
}

// 根据name去重
List<Person> unique = persons.stream().collect(
            Collectors.collectingAndThen(
                    Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(Person::getName))), ArrayList::new)
);


// 根据name,sex两个属性去重
List<Person> unique = persons.stream().collect(
           Collectors. collectingAndThen(
                    Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(o -> o.getName() + ";" + o.getSex()))), ArrayList::new)
);


filter()过滤列表
List<Person> filterList = persons.stream().filter(p -> p.getSex().equals(1)).collect(Collectors.toList());


List转Map
从一个Person对象的List集合，取出id和name组成一个map集合
Map<String, String> collect = list.stream().collect(Collectors.toMap(p -> p.getId(), p -> p.getName()));

从 List 中取出某个属性的组成 list 集合
//1.提取出list对象中的一个属性
List<String> stIdList1 = stuList.stream().map(Person::getId).collect(Collectors.toList());

//2.提取出list对象中的一个属性并去重
List<String> stIdList2 = stuList.stream().map(Person::getId).distinct().collect(Collectors.toList());

List去重方案
方案一:借助Set的特性进行去重
方案二 : 利用set集合特性保持顺序一致去重
方案三 : 使用list自身方法remove()-->不推荐
方案四 : 遍历List集合,将元素添加到另一个List集合中
方案5 : 使用Java8特性去重

方案一:借助Set的特性进行去重
 	/**
     * 去除重复数据
     * 由于Set的无序性，不会保持原来顺序
     * @param list
     */
    public static List<String> list distinct(List<String> list) {
        final boolean sta = null != list && list.size() > 0;
        List doubleList= new ArrayList();
        if (sta) {
            Set set = new HashSet();
            set.addAll(list);
            doubleList.addAll(set);
        }
        return doubleList;
    }

方案二 : 利用set集合特性保持顺序一致去重
// Set去重并保持原先顺序的两种方法
   public static void delRepeat(List<String> list) {
   	   //方法一
       List<String> listNew = new ArrayList<String>(new TreeSet<String>(list));
       //方法二
       List<String> listNew2 = new ArrayList<String>(new LinkedHashSet<String>(list));
   }

方案三 : 使用list自身方法remove()–>不推荐
    /**
     * 去除重复数据(一般不推荐)
     * 类似于冒泡排序思想
     * @param list
     */
  public static List<Map<String, Object>> distinct(List<Map<String, Object>> list) {
        if (null != list && list.size() > 0) {
        //循环list集合
            for  ( int  i  =   0 ; i  <  list.size()  -   1 ; i ++ )  {
                for  ( int  j  =  list.size()  -   1 ; j  >  i; j -- )  {
                	// 这里是对象的比较，如果去重条件不一样，在这里修改即可
                    if  (list.get(j).equals(list.get(i)))  {
                        list.remove(j);
                    }
                }
            }
        }
        //得到最新移除重复元素的list
        return list;
    }

方案四 : 遍历List集合,将元素添加到另一个List集合中
// 遍历后判断赋给另一个list集合，保持原来顺序
public static List<String> delRepeat(List<String> list) {
	  List<String> listNew = new ArrayList<String>();
	  for (String str : list) {
	       if (!listNew.contains(str)) {
	           listNew.add(str);
	       }
	   }
	  return listNew ;
}


方案5 : 使用Java8特性去重
public static List<String> delRepeat(List<String> list) {
     List<String> myList = list.stream().distinct().collect(Collectors.toList());
	 return myList ;
}

项目github地址：bitcarmanlee easy-algorithm-interview-and-practice

经常有同学私信或留言询问相关问题，V号bitcarmanlee。github上star的同学，在我能力与时间允许范围内，尽可能帮大家解答相关问题，一起进步。
在python中，数组可以用list来表示。如果有两个数组，分别要求交集，并集与差集，怎么实现比较方便呢？

当然最容易想到的是对两个数组做循环，即写两个for循环来实现。这种写法大部分同学应该都会，而且也没有太多的技术含量，本博主就不解释了。这里给大家使用更为装bility的一些方法。
老规矩，talk is cheap,show me the code
#!/usr/bin/env python
#coding:utf-8

'''
Created on 2016年6月9日

@author: lei.wang
'''

def diff(listA,listB):
    #求交集的两种方式
    retA = [i for i in listA if i in listB]
    retB = list(set(listA).intersection(set(listB)))
    
    print "retA is: ",retA
    print "retB is: ",retB
    
    #求并集
    retC = list(set(listA).union(set(listB)))
    print "retC1 is: ",retC
    
    #求差集，在B中但不在A中
    retD = list(set(listB).difference(set(listA)))
    print "retD is: ",retD
    
    retE = [i for i in listB if i not in listA]
    print "retE is: ",retE
    
def main():
    listA = [1,2,3,4,5]
    listB = [3,4,5,6,7]
    diff(listA,listB)
    
if __name__ == '__main__':
    main()

让code run起来
retA is:  [3, 4, 5]
retB is:  [3, 4, 5]
retC1 is:  [1, 2, 3, 4, 5, 6, 7]
retD is:  [6, 7]
retE is:  [6, 7]

结合代码来看，大体上是两种思路：

1.使用列表解析式。列表解析式一般来说比循环更快，而且更pythonic显得更牛逼。

2.将list转成set以后，使用set的各种方法去处理。