java基础之List

List排序

1、new ArrayList().stream().sorted().collect()：返回新的有序集合，原集合顺序不变。
2、new ArrayList().sort()：返回void，原集合顺序变为有序。

public class Subject {
    String name;
    Double grade;
}

List<Subject> subjectList = new ArrayList<>();
List<Subject> subjectListNew = new ArrayList<>();

//原集合变化（升序排列）
subjectList.sort((s1, s2) -> s1.getGrade().compareTo(s2.getGrade()));

//---------------------------------------------------------------------

//原集合没变（升序排列）
subjectListNew = subjectList.stream().sorted((s1, s2) -> s1.getGrade().compareTo(s2.getGrade())).collect(Collectors.toList());

//分数升序排列
subjectListNew = subjectList.stream().sorted((s1, s2) -> {
	return s1.getGrade().compareTo(s2.getGrade());
}).collect(Collectors.toList());

//分数降序排列
subjectListNew = subjectList.stream().sorted(Comparator.comparingDouble(Subject::getGrade).reversed()).collect(Collectors.toList());

//分数升序排列
subjectListNew = subjectList.stream().sorted(Comparator.comparingDouble(Subject::getGrade)).collect(Collectors.toList());

 参考：List两种排序方法，sort，stream_liststream排序_二十六画生的博客的博客-CSDN博客

List删除List

/**
  * 从listA里删除listB里有的数据
  * @param listA
  * @param listB
  * @return
  */
  public static List<String> listrem(List<String> listA,List<String> listB){
      HashSet hs1 = new HashSet(listA);
      HashSet hs2 = new HashSet(listB);
      hs1.removeAll(hs2);
      List<String> listC = new ArrayList<String>();
      listC.addAll(hs1);
      return listC;
  }

数组和List互换

数组转List

Arrays.asList(strArray)

// 数组转List
String[] strArray = { "a", "b" };
List<String> strList = Arrays.asList(strArray);

注意：该方法的返回值是java.util.Arrays类中一个私有静态内部类java.util.Arrays.ArrayList，它并非java.util.ArrayList类。
java.util.Arrays.ArrayList类具有set()，get()，contains()等方法，但是不支持添加add()或删除remove()方法,调用这些方法会报错。

解决方法:新建一个List对象，并且加入返回的strList，然后再add新元素

List<String> strListNew = new ArrayList<>(strList);
strListNew.add("new data");

3种基本类型数组转为List

int, long, double可以通过Java8提供的新特性stream转换：

list = Arrays.stream(arrays).boxed().collect(Collectors.toList());

// 3种基本类型数组转为List
new int[]  i = { 1, 2,  3};
List<Integer> intList= Arrays.stream(i).boxed().collect(Collectors.toList());
new long[] l = { 1, 2, 3 };
List<Long> longList= Arrays.stream(l).boxed().collect(Collectors.toList());
new double[] d = { 1, 2, 3 };
List<Double> doubleList= Arrays.stream(d).boxed().collect(Collectors.toList());

String数组

String[] arrays = {"tom", "jack", "kate"};
List<String> stringList= Stream.of(arrays).collect(Collectors.toList());

Collections.addAll(arrayList, strArray)

ArrayList< String> arrayList = new ArrayList<String>(strArray.length);
Collections.addAll(arrayList, strArray);

List转数组

toArray()：无参数toArray方法，这里注意不能强转,可能会出现报错。

toArray(T[] a)：泛型的toArray方法要注意类型必须是包装类型,基本类型是不行的。

List<Integer> list = new ArrayList();
Integer[] array = new Integer[list.size()];
list.toArray(array);

List转String

String s = StringUtils.join(list,",");

注意：需要引入org.apache.commons.lang.StringUtils 包

List<Object>强制转换为List<String>

转换方法：List<String> strs = (List<String>)(List)object

Map所有的value转化为List

Map<String, T> map;
List<T> list = map.values().stream().collect(Collectors.toList());

一个元素转换成集合

// 1、通过Collections.singletonList
List<T> list = Collections.singletonList(T);
// 2、通过Stream
List<K> authcChannels = Stream.of(K).collect(Collectors.toList());

判断不为空

CollectionUtils.isNotEmpty(list);

翻转List

String str = "as/df/gh/jkl";
String[] str1 = str.split("/");
Collections.reverse(Arrays.asList(str1));

java8的lambda表达式

1、map-用于映射每个元素到对应的结果
2、filter-用于通过设置的条件过滤出元素
3、forEach-用来迭代流中的每个数据
4、limit-用于获取指定数量的流
5、sorted-用于对流进行排序
6、Collectors-实现了很多归约操作，例如将流转换成集合和聚合元素
7、统计-主要用于int、double、long等基本类型上，产生统计结果

List<Integer> numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5);
IntSummaryStatistics stats = numbers.stream().mapToInt((x) -> x).summaryStatistics();
System.out.println("列表中最大的数 : " + stats.getMax());
System.out.println("列表中最小的数 : " + stats.getMin());
System.out.println("所有数之和 : " + stats.getSum());
System.out.println("平均数 : " + stats.getAverage());

分组

//分组
Map<String, List<User>> groupBySex = list.stream().collect(Collectors.groupingBy(User::getSex));

//分组求数量
Map<Integer, Long> map = list.stream().collect(Collectors.groupingBy(User::getAge, Collectors.counting()));

// 分组求BigDecimal的和
Map<Long, BigDecimal> map = list.stream().collect(Collectors.groupingBy(Model::getProjectId
        , Collectors.collectingAndThen(Collectors.toList(), m ->
                m.stream().map(Model::getCost).reduce(BigDecimal.ZERO, BigDecimalUtil::sum))));

public class BigDecimalUtil {
    public static BigDecimal sum(BigDecimal... in) {
        BigDecimal result = BigDecimal.ZERO;
        for (int i = 0; i < in.length; i++) {
            result = result.add(ifNullSet0(in[i]));
        }
        return result;
    }
}

//多个值求和
Map<String, Model> collect =
        list.parallelStream().collect(Collectors.groupingBy(Model::getMobile
                , Collectors.collectingAndThen(Collectors.toList(), m -> {
                    BigDecimal amount = m.parallelStream().map(Model::getAmount).reduce(BigDecimal.ZERO, BigDecimal::add);
                    BigDecimal winAmount = m.parallelStream().map(Model::getWinAmount).reduce(BigDecimal.ZERO, BigDecimal::add);
                    Integer winCount = m.parallelStream().mapToInt(Model::getWinCount).sum();
                    return new Model(amount, winAmount, winCount);
                })));

分组根据key值排序

private static Map<String, List<Map<String,Object>>> ListMapSort( Map<String, List<Map<String,Object>>> list){
    Map<String, List<Map<String, Object>>> result = new LinkedHashMap<>();
    list.entrySet().stream().sorted(Map.Entry.comparingByKey()).forEachOrdered(x ->   result.put(x.getKey(), x.getValue()));
    return result;
}

过滤

//过滤：排除掉工号为111的用户
List<User> userCommonList = list.stream().filter(a -> !a.getJobNumber().equals("111")).collect(Collectors.toList());

// 过滤对象不为空
list.stream().filter(x -> x!=null).collect(Collectors.toList());
list.stream().filter(Objects::nonNull).collect(Collectors.toList());
// 过滤某个特定属性的对象
Optional<Cart> cartOptional = cartlist.stream().filter(item -> item.getProductId().equals(1L)).findFirst();
// 或：
Cart cart = cartlist.stream().filter(item -> item.getProductId().equals(1L)).findFirst().get();

求和

//求和
//基本类型
int sumAge = list.stream().mapToInt(User::getAge).sum();
//BigDecimal求和
BigDecimal totalQuantity = list.stream().map(User::getFamilyMemberQuantity).reduce(BigDecimal.ZERO, BigDecimal::add);

 BigDecimal对象为null的时，报空指针的情况

/**
* 重写BigDecimal的求和方法，避免BigDecimal对象为null的时，报空指针的情况
*/
public class BigDecimalUtils {
	public static BigDecimal ifNullSetZero(BigDecimal value) {
		if (value != null) {
			return value;
		} else {
			return BigDecimal.ZERO;
		}
	}
	public static BigDecimal sum(BigDecimal ...value){
		BigDecimal result = BigDecimal.ZERO;
		for (int i = 0; i < value.length; i++){
			result = result.add(ifNullSetZero(value[i]));
		}
		return result;
	}
}


BigDecimal totalGrade2 = studentList.stream().map(Student::getGrade).reduce(BigDecimal.ZERO, BigDecimalUtils::sum);

//当求和的字段bigDecimal对象为null的情况，可能会报空指针。需要加过滤
BigDecimal totalGrade = studentList.stream().map(i -> {
                 if (i.getGrade()==null){
                        return BigDecimal.ZERO;
                    }else {
                        return i.getGrade();
                    }
                }).reduce(BigDecimal.ZERO, BigDecimal::add);

 最值

//最小
Date minEntryDate = list.stream().map(User::getEntryDate).min(Date::compareTo).get();
//最大
Date maxEntryDate = list.stream().map(User::getEntryDate).max(Date::compareTo).get();

List转map

/**
 * List -> Map
 * 需要注意的是：
 * toMap 如果集合对象有重复的key，会报错Duplicate key ....
 *  user1,user2的id都为1。
 *  可以用 (k1,k2)->k1 来设置，如果有重复的key,则保留key1,舍弃key2
 */
Map<Long, User> userMap = list.stream().collect(Collectors.toMap(User::getId, a -> a,(k1, k2)->k1));
// 只获取对象的某个属性
Map<Long, String> categoryMap = list.stream().collect(Collectors.toMap(User::getId,User::getName,(entity1,entity2) -> entity1));

排序

//排序
//单字段正序排序，根据id排序
list.stream().sorted(Comparator.comparing(User::getId));
//单字段倒序排序，根据id排序
list.stream().sorted(Comparator.comparing(User::getId).reversed());
//多字段排序，根据id，年龄排序
list.stream().sorted(Comparator.comparing(User::getId).thenComparing(User::getAge));

去重

//去重
List<Long> distinctIdList = list.stream().distinct().collect(Collectors.toList());

获取list的字段为新list

//获取list对象的某个字段组装成新list
List<Long> userIdList = list.stream().map(a -> a.getId()).collect(Collectors.toList());

批量设置list列表字段

list.stream().forEach(a -> a.setDelFlag("0"));

比较

//是否所有人的年龄大于50
boolean b = list.stream().allMatch(a -> a.getAge() > 50);
//是否有一个人的年龄大于50
boolean b = list.stream().anyMatch(a -> a.getAge() > 50);
//是否所有人的年龄都不大于50
boolean b = list.stream().noneMatch(a -> a.getAge() > 50);

截取List

// skip跳过list中的几个元素，
// limit截取list中的几个元素
//两个可以配合使用,先跳过,然后截取,也可以先截取然后跳过
List<User> users = list.stream().skip(5)limit(2);

获取List对象中子List对象

@Data
public class Student{
    private String name;
    private int age;
}
@Data
public class Grades {
    private String name;
    private List<Student> students;
}

List<Student> studentList = new ArrayList<>();
List<Grades> gradeList = new ArrayList<>();
List<Student> students = gradeList.stream().map(Grades::getStudents).reduce((v1, v2) -> {
v1.addAll(v2);
return v1;
}).get();
List<String> name = gradeList.stream().map(Grades::getStudents).reduce((v1, v2) -> {
v1.addAll(v2);
return v1;
}).get().stream().map(Student::getName).collect(Collectors.toList());

参考

java 8 lambda表达式list操作分组、排序、去重、过滤、求和、最值_java lambda根据某个字段分组-CSDN博客