java开发工具类

前言:使用大众的语言，交流才会有默契。写代码亦如此！不要乱造轮子，积累轮子，搞懂轮子，最终站在巨人的肩上，才是正途。

String字符的工具类:

org.apache.commons.lang3.StringUtils

对字符的很多判断非空或者校验操作;

List,Map,Set 集合的工具类:

cn.hutool.core.collection.CollectionUtil

个人比较喜欢hutool的这个工具类,也是判断集合校验集合最常用的一个工具类; 

list.set();是List 接口的一个方法,跟add 的接收一样,但是是替换操作;

Map类型的一个工具类:

 Map<String,Object> map = new HashMap<>();
 map.put("id","1111");
 map.put("num", 1);
 map.put("num2", null);
 String id = MapUtils.getString(map, "id");
 Integer num = MapUtils.getInteger(map, "num");
 Integer num = MapUtils.getInteger(map, "num2",0);

//out: "1111" , 1 , 0

List 根据其中一个字段的最大或最小值获取对象

//获取最小值得对象
LabelSortDTO labelSortDTO = haveSortList.stream().min(Comparator.comparing(LabelSortDTO -> LabelSortDTO.getSort())).get();

//获取最大值的对象
LabelSortDTO labelSortDTO = haveSortList.stream().max(Comparator.comparing(LabelSortDTO -> LabelSortDTO.getSort())).get();

 java 8 List<map> 排序

List<map>正序:

mapDataList.stream().sorted((a, b) ->a.get("age") - b.get("age")).collect(Collectors.toList());

List<map>倒序:

mapDataList.stream().sorted((a, b) ->b.get("age") - a.get("age")).collect(Collectors.toList());

集合取最大最小值:

//通过stream获取
Integer min = integerList.stream().min(Integer::compare).get();
//通过javaApi获取
Integer min = Collections.min(integerList);

 stream 对集合的操作已经很成熟了,已经能满足几乎所有能想到的我们对集合的操作,这里不做赘述,

stream参考:Java基础系列-Stream - Java 技术驿站

判断是否是数组:

//判断是否是数组
Boolean is = JSON.isValidArray(jsonString);

 if (JSON.isValidArray(jsonString)) {
            return JSON.parseArray(jsonString, String.class).stream().filter(StringUtils::isNotEmpty).collect(Collectors.toList());
        }

Optional.ofNullable:

//层层判断
if(DTO!= null){

    if(DTO.getCount() != null){

       int count = DTO.getCount();

    }

}

//三目预算符,可读性不高,嵌套太多

int count = DTO!= null ? (DTO.getCount() != null ? DTO.getCount() : 1) : 1;

//optional判断,比较精简

int count = Optional.ofNullable(DTO).map(a-> a.getCount()).orElse(1);

 开发中的两个对象的转换,比如 Entity转换对应的DTO对象,

Label label = new Label();
Label label = new Label();
label.setId(1L);

LabelSortDTO sortDTO = new LabelSortDTO();

BeanUtils.copyProperties(label,sortDTO);

java8 List<BigDecimal> 求最大、最小、交集、差集/乘集

        List<BigDecimal> bigDecimalList = new ArrayList<BigDecimal>() {{
            this.add(new BigDecimal("1"));
            this.add(new BigDecimal("2"));
            this.add(new BigDecimal("3"));
            this.add(new BigDecimal("4"));
        }};
        // 最大值
        final Optional<BigDecimal> bigDecimalMax = bigDecimalList.stream().max(BigDecimal::compareTo);
        //最小值
        final Optional<BigDecimal> bigDecimalMin = bigDecimalList.stream().min(BigDecimal::compareTo);
        // 求和
        final Optional<BigDecimal> bigDecimalSum = bigDecimalList.stream().reduce(BigDecimal::add);
        // 求差
        final Optional<BigDecimal> bigDecimalSubTract = bigDecimalList.stream().reduce(BigDecimal::subtract);
        // 求乘
        final Optional<BigDecimal> bigDecimalMultply = bigDecimalList.stream().reduce(BigDecimal::multiply);


        System.out.println("BigDecimal Max : " + bigDecimalMax.orElse(new BigDecimal("0")));
        System.out.println("BigDecimal Min : " + bigDecimalMin.orElse(new BigDecimal("0")));
        System.out.println("BigDecimal Sum : " + bigDecimalSum.orElse(new BigDecimal("0")));
        System.out.println("BigDecimal subTract : " + bigDecimalSubTract.orElse(new BigDecimal("0")));
        System.out.println("BigDecimal multply : " + bigDecimalMultply.orElse(new BigDecimal("0")));

BigDecimal比较大小

BigDecimal a = new BigDecimal (101);
BigDecimal b = new BigDecimal (111);
 
//使用compareTo方法比较
//注意：a、b均不能为null，否则会报空指针
if(a.compareTo(b) == -1){
    System.out.println("a小于b");
}
 
if(a.compareTo(b) == 0){
    System.out.println("a等于b");
}
 
if(a.compareTo(b) == 1){
    System.out.println("a大于b");
}
 
if(a.compareTo(b) > -1){
    System.out.println("a大于等于b");
}
 
if(a.compareTo(b) < 1){
    System.out.println("a小于等于b");
}

List元素去重的6种方法(包括性能分析):

 1:contains判断去重:不做赘述,遍历,不包含就添加到新集合,性能最差,消耗内存

public class ListController {

    public static void main(String[] args) {
        List<Integer> list = new ArrayList<Integer>() {{
            add(1);
            add(2);
            add(5);
            add(4);
            add(5);
            add(3);
            add(7);
            add(8);
            add(9);
            add(8);
            add(5);
            add(4);
            add(5);
            add(6);
        }};
        System.out.println("原集合:" + list);
        ListMethod(list);
    }

    /**
     * 使用迭代器去重
     *
     * @param list
     */
    public static void ListMethod(List<Integer> list) {
        // 新集合
        List<Integer> newList = new ArrayList<>(list.size());
        list.forEach(i -> {
            if (!newList.contains(i)) {
                // 如果新集合中不存在则插入
                newList.add(i);
            }
        });
        System.out.println("去重集合:" + newList);
    }
}

2:HashSet去重

HashSet底层维护的是一个HashMap,map的key不可重复,HashSet是无序的，因为HashMap的key是无序的；

    /**
     * 使用 HashSet 去重
     * @param list
     */
    public static void ListToSet(List<Integer> list) {
        Set<Integer> set = new HashSet<>(list);
        System.out.println("去重集合:" + set);
    }

3:LinkedHashSet去重

LinkedHashSet的底层使用LinkedHashMap存储元素。LinkedHashSet是有序的，它是按照插入的顺序排序的。

    /**
     * 使用 LinkedHashSet 去重
     * @param list
     */
    public static void ListToSet(List<Integer> list) {
        LinkedHashSet<Integer> set = new LinkedHashSet<>(list);
        System.out.println("去重集合:" + set);
    }

 4:TreeSet去重

TreeSet底层是采用TreeMap实现的一种Set，所以它是有序的，同样也是非线程安全的。TreeSet实现了NavigableSet接口，而NavigableSet继承自SortedSet接口；TreeSet实现了SortedSet接口

   /**
     * 使用 TreeSet 去重(无序)
     * @param list
     */
    public static void ListMethod(List<Integer> list) {
        TreeSet<Integer> set = new TreeSet<>(list);
        System.out.println("去重集合:" + set);
    }

5:Stream去重(有序)

distinct()返回由该流的不同元素组成的流。distinct()是Stream接口的方法。distinct()使用hashCode() 和equals()方法来获取不同的元素。因此，我们的类必须实现hashCode()和equals()方法。

   /**
     * 使用 Stream 去重
     * @param list
     */
    public static void ListMethod(List<Integer> list) {
        list = list.stream().distinct().collect(Collectors.toList());
        System.out.println("去重集合:" + list);
    }

6:filter筛选

distinct()不提供按照属性对对象列表进行去重的直接实现。它是基于hashCode()和equals()工作的。如果我们想要按照对象的属性，对对象列表进行去重，我们可以通过其它方法来实现。

 public static <T> Predicate<T> distinctByKey(Function<? super T, ?> keyExtractor){
        Map<Object,Boolean> seen = new ConcurrentHashMap<>();
        return t -> seen.putIfAbsent(keyExtractor.apply(t), Boolean.TRUE) == null;
    }


 /**
     * 使用 Stream 去重
     * @param list
     */
    public static void ListMethod(List<Integer> list) {
        // 单属性去重 按照age去重
        list.stream().filter(distinctByKey(Student::getAge)).forEach(System.out::println);

        // 多属性去重 按照name+age+type去重
        students.stream().filter(distinctByKey(Student::getName)).filter(distinctByKey(Student::getAge))
                .filter(distinctByKey(Student::getType)).forEach(System.out::println);
    }

List数组中删除指定元素

        //方法一:
        list = list.stream().filter(a -> a.equals(5)).collect(Collectors.toList());
        //方法二:
        list.removeIf(a -> a.equals(5));

JDK1.8 部分新特性:Consumer

Java Consumer接口来自Java 8中引入的 java.util.function包。
Consumer是一个功能接口，用来作为lambda表达式或方法引用的任务目标(传递一个参数执行指定的方法)。

Consumer的功能接口是一个接受单一参数并且不返回任何结果的操作。

Consumer的功能方法是accept(T t)。

Consumer具有以下方法。

1. accept : 这是Consumer功能接口的功能方法。accept 方法对给定的参数进行这一操作。用于接收参数,对这个参数进行处理

2. andThen : 此方法返回一个组合的Consumer，该Consumer先执行原始的Consumer操作，然后按照从左到右的顺序执行给定的andThen操作。
 

功能方法：accept
功能方法accept在功能接口Consumer中的定义

void accept(T t) 

使用示例

ConsumerAccept.java

import java.util.function.Consumer;

public class ConsumerAccept {
  public static void main(String[] args) {
    Consumer<String> nameConsumer = s -> System.out.println(s); 
    
    nameConsumer.accept("Mahesh");
    nameConsumer.accept("Krishna");
  }
} 

输出

Mahesh
Krishna 

使用Lambda表达式创建Consumer
可以使用lambda表达式创建Consumer。

例1 基础类型操作

在我们的示例中，我们将使用lambda表达式在此处创建两个Consumer。

一个用于将数字添加到列表的方法，如果数字为奇数，则将添加到具有奇数的列表中；如果数字为偶数，则将其添加到具有偶数的另一个列表中。

ConsumerLambda1.java
 

import java.util.ArrayList;
import java.util.List;
import java.util.function.Consumer;

public class ConsumerLambda1 {
  public static void main(String[] args) {
	List<Integer> oddList = new ArrayList<>();
	List<Integer> evenList = new ArrayList<>();
	
	Consumer<Integer> storeNumber = n -> {
	   if (n % 2 == 0) {
		 evenList.add(n);
	   } else {
		 oddList.add(n);
	   }
	};
	
	Consumer<List<Integer>> printList = list -> list.forEach(n -> System.out.println(n));
	
	storeNumber.accept(10);
	storeNumber.accept(15);
	storeNumber.accept(25);
	storeNumber.accept(30);
	
	System.out.println("--- Odd number ---");
	
	printList.accept(oddList);
	
	System.out.println("--- Even number ---");
	
	printList.accept(evenList);
  }
} 

输出结果

--- Odd number ---
15
25
--- Even number ---
10
30 

例2 对象类型操作

我们将使用lambda表达式创建一个Consumer，它将决定并显示一个公民在选举中是否可以投票的数据。

ConsumerLambda2.java

import java.util.function.Consumer;

public class ConsumerLambda2 {
  public static void main(String[] args) {
     Consumer<Citizen> electionConsumer = c -> {
       if (c.getAge() < 18) {
    	 System.out.println(c.getName() + " is not eligible to vote.");
       } else {
    	 System.out.println(c.getName() + " can vote.");
       }
     };
     
     electionConsumer.accept(new Citizen("Ritesh", 15));
     
     electionConsumer.accept(new Citizen("Shreya", 20));
  }
}

class Citizen {
  private String name;
  private int age;

  public Citizen(String name, int age) {
	this.name = name;
	this.age = age;
  }

  public String getName() {
	return name;
  }

  public int getAge() {
	return age;
  }
} 
输出结果

Ritesh is not eligible to vote.
Shreya can vote. 

使用方法引用创建Consumer
Consumer可以使用方法引用来创建。

在我们的例子中，我们有一个有两个方法的实用类Utility，其中一个方法将替换Map中的值，第二个方法显示Map中的数据。我们将使用方法引用来创建Consumer。

ConsumerMethodRef.java

import java.util.HashMap;
import java.util.Map;
import java.util.function.Consumer;

public class ConsumerMethodRef {
  public static void main(String[] args) {
	Map<Integer, String> persons = new HashMap<Integer, String>();
	persons.put(101, "Mahesh");
	persons.put(102, "Krishna");

	Consumer<Map<Integer, String>> updatePersons = Utility::updateData;

	Consumer<Map<Integer, String>> displayPersons = Utility::displayData;

	updatePersons.accept(persons);

	displayPersons.accept(persons);
  }
}

class Utility {
  static void updateData(Map<Integer, String> persons) {
	persons.replaceAll((k, v) -> "Shree ".concat(v));
  }

  static void displayData(Map<Integer, String> persons) {
	for (Map.Entry<Integer, String> entry : persons.entrySet()) {
	  System.out.println(entry.getKey() + " - " + entry.getValue());
	}
  }
} 
输出结果

101 - Shree Mahesh
102 - Shree Krishna 

使用andThen方法

在Java文档中andThen方法声明。

default Consumer<T> andThen(Consumer<? super T> after) 
1
这个方法返回一个组合的Consumer，先执行当前Consumer操作，然后再执行after的Consumer操作。
如果在此操作或操作之后有异常，则将其中继到当前组合操作。
如果这个操作出现异常，那么后面的操作将不会被执行。
例1 简单拼接Consumer
我们的示例中有两个Consumer。

首先将执行squareConsumer，然后将执行printConsumer。

ConsumerAndThen1.java

import java.util.Arrays;
import java.util.List;
import java.util.function.Consumer;

public class ConsumerAndThen1 {
  public static void main(String[] args) {
	List<Integer> numList = Arrays.asList(3, 4, 5, 6);

	Consumer<List<Integer>> squareConsumer = list -> {
	  for (int i = 0; i < list.size(); i++) {
		list.set(i, list.get(i) * list.get(i));
	  }
	};

	Consumer<List<Integer>> printConsumer = list -> list.forEach(n -> System.out.println(n));

	squareConsumer.andThen(printConsumer).accept(numList);
  }
} 

输出

9
16
25
36 

例2 多个拼接Consumer

我们多次使用andThen。首先将执行oddNumConsumer，然后将执行evenNumConsumer，然后将执行taskFinishConsumer。

ConsumerAndThen2.java
 

import java.util.Arrays;
import java.util.List;
import java.util.function.Consumer;

public class ConsumerAndThen2 {
  public static void main(String[] args) {
	List<Integer> list = Arrays.asList(12, 13, 14, 15, 16, 17);

	Consumer<List<Integer>> oddNumConsumer = MyNumber::printOddNum;

	Consumer<List<Integer>> evenNumConsumer = MyNumber::printEvenNum;

	Consumer<List<Integer>> taskFinishConsumer = MyNumber::taskFinishMsg;

	oddNumConsumer.andThen(evenNumConsumer).andThen(taskFinishConsumer).accept(list);
  }
}

class MyNumber {
  static void printOddNum(List<Integer> myNumbers) {
	System.out.println("--- odd numbers ---");
	myNumbers.forEach(n -> {
	  if (n % 2 == 1) {
		System.out.print(n + " ");
	  }
	});
  }

  static void printEvenNum(List<Integer> myNumbers) {
	System.out.println("\n--- even numbers ---");
	myNumbers.forEach(n -> {
	  if (n % 2 == 0) {
		System.out.print(n + " ");
	  }
	});
  }

  static void taskFinishMsg(List<Integer> myNumbers) {
	System.out.println("\nTotal " + myNumbers.size() + " number processed.");
  }
} 

输出结果

--- odd numbers ---
13 15 17 
--- even numbers ---
12 14 16 
Total 6 number processed.