JAVA8新特性汇总，后续不断更新

1.Java8中Map的遍历方式总结

public class LambdaMap {
     

    private Map<String, Object> map = new HashMap<>();

    @Before
    public void initData() {
     
        map.put("key1", "value1");
        map.put("key2", "value2");
        map.put("key3", "value3");
        map.put("key4", "value4");
        map.put("key5", "value5");
        map.put("key5", "value6");
    }

    /**
     * 遍历Map的方式一
     * 通过Map.keySet遍历key和value
     */
    @Test
    public void testErgodicWayOne() {
     
        System.out.println("---------------------Before JAVA8 ------------------------------");
        for (String key : map.keySet()) {
     
            System.out.println("map.get(" + key + ") = " + map.get(key));
        }
        System.out.println("---------------------JAVA8 ------------------------------");
        map.keySet().forEach(key -> System.out.println("map.get(" + key + ") = " + map.get(key)));
    }

    /**
     * 遍历Map第二种
     * 通过Map.entrySet使用Iterator遍历key和value
     */
    @Test
    public void testErgodicWayTwo() {
     
        System.out.println("---------------------Before JAVA8 ------------------------------");
        Iterator<Map.Entry<String, Object>> iterator = map.entrySet().iterator();
        while (iterator.hasNext()) {
     
            Map.Entry<String, Object> entry = iterator.next();
            System.out.println("key:value = " + entry.getKey() + ":" + entry.getValue());
        }
        System.out.println("---------------------JAVA8 ------------------------------");
        map.entrySet().iterator().forEachRemaining(item -> System.out.println("key:value=" + item.getKey() + ":" + item.getValue()));
    }

    /**
     * 遍历Map第三种
     * 通过Map.entrySet遍历key和value，在大容量时推荐使用
     */
    @Test
    public void testErgodicWayThree() {
     
        System.out.println("---------------------Before JAVA8 ------------------------------");
        for (Map.Entry<String, Object> entry : map.entrySet()) {
     
            System.out.println("key:value = " + entry.getKey() + ":" + entry.getValue());
        }
        System.out.println("---------------------JAVA8 ------------------------------");
        map.entrySet().forEach(entry -> System.out.println("key:value = " + entry.getKey() + ":" + entry.getValue()));
    }

    /**
     * 遍历Map第四种
     * 通过Map.values()遍历所有的value，但不能遍历key
     */
    @Test
    public void testErgodicWayFour() {
     
        System.out.println("---------------------Before JAVA8 ------------------------------");
        for (Object value : map.values()) {
     
            System.out.println("map.value = " + value);
        }
        System.out.println("---------------------JAVA8 ------------------------------");
        map.values().forEach(System.out::println); // 等价于map.values().forEach(value -> System.out.println(value));
    }

    /**
     * 遍历Map第五种
     * 通过k,v遍历，Java8独有的
     */
    @Test
    public void testErgodicWayFive() {
     
        System.out.println("---------------------Only JAVA8 ------------------------------");
        map.forEach((k, v) -> System.out.println("key:value = " + k + ":" + v));
    }
}

2.JAVA8对List对象集合按对象属性分组、分组汇总、过滤等操作示例

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

public class Test {
     
    public static void main(String[] args){
     
        List<PersonData> list = new ArrayList<PersonData>();
        PersonData p1 = new PersonData();
        p1.setId("1");
        p1.setName("张三");
        p1.setType("管理员");
        p1.setAge(20);
        list.add(p1);

        PersonData p2 = new PersonData();
        p2.setId("2");
        p2.setName("李四");
        p2.setType("管理员");
        p2.setAge(30);
        list.add(p2);

        PersonData p3 = new PersonData();
        p3.setId("3");
        p3.setName("王五");
        p3.setType("用户");
        p3.setAge(40);
        list.add(p3);

        PersonData p4 = new PersonData();
        p4.setId("4");
        p4.setName("马六");
        p4.setType("访客");
        p4.setAge(50);
        list.add(p4);

        //跟据某个属性分组
        Map<String, List<PersonData>> collect = list.stream().collect(Collectors.groupingBy(PersonData::getType));
        System.out.println(collect);
        
        //根据某个属性分组，汇总某个属性
        Map<String, Integer> collect2 = list.stream().collect(Collectors.groupingBy(PersonData::getType,Collectors.summingInt(PersonData::getAge)));
        System.out.println(collect2);
        
        //根据某个属性添加条件过滤数据，
        list = list.stream().filter(u -> !u.getType().equals("访客")).collect(Collectors.toList());
        System.out.println(list);
        
        //判断一组对象里面有没有属性值是某个值
        boolean add = list.stream().anyMatch(m -> "王五".equals(m.getName()));
        System.out.println(add);
        
        //取出一组对象的某个属性组成一个新集合
        List<String> names=list.stream().map(PersonData::getName).collect(Collectors.toList());
        System.out.println(names);

		//将List集合转为map
		Map<String, String> result = list.stream().collect(Collectors.toMap(PersonData::getId, PersonData::getName));
    
    	//从List中过滤出一个元素
 		PersonData match = list.stream().filter((user) -> user.getId() == 1).findAny().get();

		//将List对象转换为其他List对象(注意:1.新对象需要根据需求自己创建一个构造器 2.如果不需要过滤"张三"可以直接去掉'equals' 3.新对象中最后一个参数 "1000"为我给这个新对象每个都赋值一个1000的属性,可以去掉,也可以赋值其他相同的属性)
 		List<Employee> employees = list.stream().filter(p -> p.getName().equals("张三")).map(p -> new Employee(p.getName(), p.getType(), p.getAge(),1000)).collect(Collectors.toList());                    
                
    }
}

打印

{
     用户=[com.test4.PersonData@19a45b3], 访客=[com.test4.PersonData@99a589], 管理员=[com.test4.PersonData@372a00, com.test4.PersonData@dd8dc3]}
{
     用户=40, 访客=50, 管理员=50}
[com.test4.PersonData@372a00, com.test4.PersonData@dd8dc3, com.test4.PersonData@19a45b3]
true
[张三, 李四, 王五]

3.java8 lambda 统计list中对象的重复次数

List<Integer> list = new ArrayList() {
     
            {
     
                add(12);
                add(20);
                add(12);
                add(22);
                add(22);
                add(23);
                add(159);
                add(12);
            }
        };
 //利用java8的lambda表达式统计list集合中各个数字出现的次数(数字,次数)
Map<Integer, Long> map = list.stream().collect(Collectors.groupingBy(p -> p,Collectors.counting()));
//java8遍历打印map
map.forEach((k, v) -> System.out.println(k + ":" + v));

4.java8 map根据key或者value进行排序

将map根据key或者value进行排序

Map<String,BigDecimal> map =new HashMap<>();
map.put("one", 0.08);
map.put("two", 0.1);
map.put("three", 0.2);
map.put("four", 0.91);
//对这个map根据value值倒序排序，下面给出工具类：
public <K, V extends Comparable<? super V>> Map<K, V> sortByValueDesc(Map<K, V> map) {
     
	Map<K, V> result = new LinkedHashMap<>();
	map.entrySet().stream().sorted(Map.Entry.<K, V>comparingByValue().reversed()).forEachOrdered(e -> result.put(e.getKey(), e.getValue()));     
	return result;
}
//根据map的key进行排序，需要对上面的工具类进行小小的修改，代码如下：
public <K extends Comparable<? super K>, V > Map<K, V> sortByKeyDesc(Map<K, V> map) {
     
	Map<K, V> result = new LinkedHashMap<>();
	map.entrySet().stream().sorted(Map.Entry.<K, V>comparingByKey().reversed()).forEachOrdered(e -> result.put(e.getKey(), e.getValue()));     
	return result;
}
//如果我们需要根据key排序，就需要让key 继承 Comparable ，也就说我们需要对待排序的字段继承 Comparable接口。另一个问题就是，上面的这种写法排序效果是 降序排序，如果我们需要升序排序的话，只需要将上面的.reversed(）关键字限制去掉即可:
public <K, V extends Comparable<? super V>> Map<K, V> sortByValueAsn(Map<K, V> map) {
     
	Map<K, V> result = new LinkedHashMap<>();
	map.entrySet().stream().sorted(Map.Entry.<K, V>comparingByValue()).forEachOrdered(e -> result.put(e.getKey(), e.getValue()));      
	return result;
}

附通用的map的key排序：

public static <K extends String, V> Map sortMapKey(Map<K, V> map) {
     
	List<Map.Entry<K, V>> list = new ArrayList(map.entrySet());
	list.sort((o1, o2) -> o2.getKey().length() - o1.getKey().length());
	Map<K, V> linkedMap = new LinkedHashMap<>();
	for (Map.Entry<K, V> entry : list) {
     
	  linkedMap.put(entry.getKey(), entry.getValue());
	}
	return linkedMap;
}

5.java8的lambda表达式获取map中value最大值的五种方法：

        Map<String,Integer> map = new HashMap<>();
        map.put("张三", 1);
        map.put("李四", 2);
        map.put("王五", 3);
        //第一种方法
        Optional<Map.Entry<String, Integer>> max1 = map.entrySet().stream().max(Map.Entry.comparingByValue());              
        //第二种方法
        Optional<Map.Entry<String, Integer>> max2 = map.entrySet().stream().max((x1, x2) -> Integer.compare(x1.getValue(), x2.getValue()));
        //第三种方法
        Optional<Map.Entry<String, Integer>> max3 = map.entrySet().stream().collect(Collectors.maxBy(Map.Entry.comparingByValue()));              
        //第四种方法
        Optional<Map.Entry<String, Integer>> max4 = map.entrySet().stream().max(Comparator.comparingInt(Map.Entry::getValue));    
        //第五种方法
        IntSummaryStatistics max5 = map.entrySet().stream().collect(Collectors.summarizingInt(Map.Entry::getValue));

6.将Map数据转换为自定义对象的List，例如把map的key,value分别对应Person对象两个属性

//方式一
List<Person> list = map.entrySet().stream().sorted(Comparator.comparing(e -> e.getKey()))
		.map(e -> new Person(e.getKey(), e.getValue())).collect(Collectors.toList());
//方式二
List<Person> list = map.entrySet().stream().sorted(Comparator.comparing(Map.Entry::getValue))
		.map(e -> new Person(e.getKey(), e.getValue())).collect(Collectors.toList());
//方式三
List<Person> list = map.entrySet().stream().sorted(Map.Entry.comparingByKey())
	.map(e -> new Person(e.getKey(), e.getValue())).collect(Collectors.toList());

7.附：普通方式将map的key和value转list， 或者list转set， 并取出List集合中的前N个数据

Map<String,Object> map = new HashMap<String,Object>(){
     {
     
			put("name","Tom");
			put("age",28);
}};
//将Map中的value提取到list集合中
List<Object> values = new ArrayList<Object>(map.values());
//将Map中的key提取到list集合中
List<String> keys = new ArrayList<String>(map.keySet());
//将List转换为Set
Set<Object> set = new HashSet<Object>(list);

//在java.util.List中有一个subList()方法，作用是返回一个List集合的其中一部分视图
List<E>(对象的集合).subList(int fromIndex, int toIndex);
/**
1.因为返回的是List中一部分对象的集合，返回的结果集合也是List的子集合，并是以下标索引取值。

2.父集合List以fromIndex开始（包含），到toIndex结束（不包含）的部分为返回的子集合。

3.因为是通过下标索引取值，可用此方法分页。

4.此方法返回的是父集合的一部分视图，无论改变那个集合，另一个都会随动。而解决方法很简单，只要开辟一个新的集合对象去接受就OK了。

举个例子需要取List集合的前1000条数据，那么可以这样写：
*/

list.subList(0, 1000);
//注意，结束的索引是不包含的，因此不是999，而是1000。

8.java8中根据判断删除列表list中的元素

List<String> lists = new ArrayList<>();
lists.add("a");
lists.add("b");
lists.add("c");
 
//使用removeIf方法，->里的是判断条件，如果符合这个条件就删除。这里会删除带有c的元素
lists.removeIf(s -> s.contains("c"));

9.Java8中时间LocalDateTime或LocalDate实用补充

前端请求参数，后端使用日期接收：
import org.springframework.format.annotation.DateTimeFormat; //格式化接收时间参数
@DateTimeFormat(pattern = "yyyy-MM-dd")
private LocalDate startTime;
@DateTimeFormat(pattern = "yyyy-MM-dd")
private LocalDate endTime;

前端请求参数，后端使用日期及时间接收：
import org.springframework.format.annotation.DateTimeFormat; //格式化接收时间参数
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private LocalDateTime startTime;
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private LocalDateTime endTime;

后端返回日期时间参数给前端：
import com.fasterxml.jackson.annotation.JsonFormat; //格式化时间参数
import com.fasterxml.jackson.annotation.JsonProperty; //定义返回json名称
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
@JsonProperty(value = "addedTime")
private LocalDateTime addedTime;
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
@JsonProperty(value = "shelfTime")
private LocalDateTime shelfTime;

获取当前时间：
LocalDateTime now = LocalDateTime.now();

获取今天凌晨0~24时时间：
LocalDateTime nowBeginTime = LocalDateTime.of(now.toLocalDate(), LocalTime.MIN);
LocalDateTime nowEndTime = LocalDateTime.of(now.toLocalDate(), LocalTime.MAX);

获取昨日当前时间：
now.minusDays(1);

获取昨日凌晨0~24时时间：
LocalDateTime yesBeginTime = LocalDateTime.of(now.minusDays(1).toLocalDate(), LocalTime.MIN);
LocalDateTime yesEndTime = LocalDateTime.of(now.minusDays(1).toLocalDate(), LocalTime.MAX);

获取当月第一天0时和最后一天24时时间：
LocalDateTime monthBeginTime = LocalDateTime.of(LocalDate.from(now.with(TemporalAdjusters.firstDayOfMonth())), LocalTime.MIN);
LocalDateTime monthEndTime = LocalDateTime.of(LocalDate.from(now.with(TemporalAdjusters.lastDayOfMonth())), LocalTime.MAX));