Java8新特性

最新推荐文章于 2022-12-04 18:03:19 发布
最新推荐文章于 2022-12-04 18:03:19 发布
阅读量277 收藏
点赞数 1
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/A54324/article/details/127125383
版权

推荐文档

菜鸟教程https://www.runoob.com/java/java8-streams.html

Java8新特性https://www.runoob.com/java/java8-new-features.html

lamda表达式https://www.runoob.com/java/java8-lambda-expressions.html

base64 https://www.runoob.com/java/java8-base64.html

日期时间Api https://www.runoob.com/java/java8-datetime-api.html

stream https://www.runoob.com/java/java8-streams.html

日期时间APi

输出当前日期(年-月-日)

LocalDate today = LocalDate.now();
System.out.println("今天的日期:"+today);

一些LocalData.now()一些api

getYear()    int    获取当前日期的年份
getMonth()    Month    获取当前日期的月份对象
getMonthValue()    int    获取当前日期是第几月
getDayOfWeek()    DayOfWeek    表示该对象表示的日期是星期几
getDayOfMonth()    int    表示该对象表示的日期是这个月第几天
getDayOfYear()    int    表示该对象表示的日期是今年第几天
withYear(int year)    LocalDate    修改当前对象的年份
withMonth(int month)    LocalDate    修改当前对象的月份
withDayOfMonth(int dayOfMonth)    LocalDate    修改当前对象在当月的日期
isLeapYear()    boolean    是否是闰年
lengthOfMonth()    int    这个月有多少天
lengthOfYear()    int    该对象表示的年份有多少天（365或者366）
plusYears(long yearsToAdd)    LocalDate    当前对象增加指定的年份数
plusMonths(long monthsToAdd)    LocalDate    当前对象增加指定的月份数
plusWeeks(long weeksToAdd)    LocalDate    当前对象增加指定的周数
plusDays(long daysToAdd)    LocalDate    当前对象增加指定的天数
minusYears(long yearsToSubtract)    LocalDate    当前对象减去指定的年数
minusMonths(long monthsToSubtract)    LocalDate    当前对象减去注定的月数
minusWeeks(long weeksToSubtract)    LocalDate    当前对象减去指定的周数
minusDays(long daysToSubtract)    LocalDate    当前对象减去指定的天数
compareTo(ChronoLocalDate other)    int    比较当前对象和other对象在时间上的大小，返回值如果为正，则当前对象时间较晚，
isBefore(ChronoLocalDate other)    boolean    比较当前对象日期是否在other对象日期之前
isAfter(ChronoLocalDate other)    boolean    比较当前对象日期是否在other对象日期之后
isEqual(ChronoLocalDate other)    boolean    比较两个日期对象是否相等

TemporalAdjusters类中预定义实现

下面列举部分方法及其定义描述：

dayOfWeekInMonth() – 一周中的某一天，例如，三月中第二个星期二
firstDayOfMonth() – 当前月的第一天
firstDayOfNextMonth() – 下一个月的第一天
firstDayOfNextYear() – 下一年的第一天
firstDayOfYear() – 当年的第一天
lastDayOfMonth() – 当月的最后一天
nextOrSame() – 下一次或当天发生的一周中的某天

获取当月日期

LocalDate localDateStart = LocalDate.now()

localDateStart.getMonthValue() 获取当月

获取指定日期的上一个月

LocalDate localBeforeDate = localDateStart.minusMonths(1);

获取当月第一天

LocalDate localDateStart = LocalDate.now().with(TemporalAdjusters.firstDayOfMonth());

获取上月第一天

//当前月第一天
LocalDate localDateStart = LocalDate.now().with(TemporalAdjusters.firstDayOfMonth());
LocalDate localBeforeDate = localDateStart.minusMonths(1);

获取上月最后一天

//当月第一天
LocalDate localDateStart = LocalDate.now().with(TemporalAdjusters.firstDayOfMonth());
//上月第一天
LocalDate localBeforeDate = localDateStart.minusMonths(1);
//上月最后一天
LocalDate localDateEnd = localBeforeDate.with(TemporalAdjusters.lastDayOfMonth());

获取日期相差总天数

//相差总天数
//System.out.println("总相差的天数"+localStartDate.until(localEndDate, ChronoUnit.DAYS));

比较localStartDate和localEndDate相差的天数

LocalDateAPI

获取LocalDate

1.获取当前的日期 LocalDate
LocalDate now = LocalDate.now();

2.根据年月日的值获取 LocalDate
LocalDate.of(2016, 11, 30);

3.根据某年的第n天获取 LocalDate
LocalDate.ofYearDay(2016, 300)

4.从时间纪元（1970年1月1日）开始第n天（负数表示在时间纪元前n天）获取 LocalDate
LocalDate.ofEpochDay(365); 操作LocalDate

操作LocalDate

LocalDate.now().getYear(); // 年份  
LocalDate.now().getMonthValue(); // 月份（数值表示， 从1开始）  
LocalDate.now().getMonth(); // 月份（英文[enum]表示）  
LocalDate.now().getDayOfMonth(); // 日期（从1开始）  
LocalDate.now().getDayOfYear(): // 当天所在这一年的第几天（从1开始）  
LocalDate.now().getDayOfWeek(); // 星期几  
LocalDate.now().lengthOfYear(); // 当年的天数  
LocalDate.now().lengthOfMonth(); //当月的天数  
LocalDate.now().toEpochDay(); // 与时间纪元（1970年1月1日）相差的天数，负数表示在时间纪元之前多少天

LocalDate运算

加
System.out.println("加法运算");  
System.out.println("当前：" + LocalDate.now());  
System.out.println("加1天：" + LocalDate.now().plusDays(1));  
System.out.println("加1周：" + LocalDate.now().plusWeeks(1));  
System.out.println("加1月：" + LocalDate.now().plusMonths(1));  
System.out.println("加1年：" + LocalDate.now().plusYears(1));
减
System.out.println("减法运算");  
System.out.println("当前：" + LocalDate.now());  
System.out.println("减1天：" + LocalDate.now().minusDays(1));  
System.out.println("减1周：" + LocalDate.now().minusWeeks(1));  
System.out.println("减1月：" + LocalDate.now().minusMonths(1));  
System.out.println("减1年：" + LocalDate.now().minusYears(1));
替换
    @Test
    public void test9(){
//        所有的数值必须合法；
//        如果当月当天是闰年2月29日，替换年份为非闰年，则会变成2月28日；
        System.out.println("当前：" + LocalDate.now()); 
        //替换日子为1日,以此类推(例今天为2022/9/30)替换后为(2022/9/1)
        System.out.println("替换日期为：" + LocalDate.now().withDayOfMonth(1));
        System.out.println("替换天数为：" + LocalDate.now().withDayOfYear(1));
        System.out.println("替换月份为：" + LocalDate.now().withMonth(1));
        System.out.println("替换年份为：" + LocalDate.now().withYear(1));
    }

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tkXfZKXZ-1664525506322)(G:/typora/assets/image-20220704153111401-16645246694711.png)]

LocalDate比较

可以对两个 LocalDate 进行比较，可以判断一个日期是否在另一个日期之前或之后，或者判断两个日期是否是同年同月同日。

@Test
public void test10(){
        System.out.println("当天：" + LocalDate.now());
        System.out.println("是否在当天之前：" + LocalDate.now().minusDays(1).isBefore(LocalDate.now()));
        System.out.println("是否在当天之后：" + LocalDate.now().plusDays(1).isAfter(LocalDate.now()));
        System.out.println("是否在当天：" + LocalDate.now().isEqual(LocalDate.now()));
        System.out.println("今年是否是闰年：" + LocalDate.now().isLeapYear());
    }

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sBb676Ml-1664525506322)(G:/typora/assets/image-20220704153216610-16645246694713.png)]

Lambda

lambda 表达式的语法格式如下：

(parameters) -> expression
或
(parameters) ->{ statements; }

以下是lambda表达式的重要特征:

  • **可选类型声明：**不需要声明参数类型，编译器可以统一识别参数值。
  • **可选的参数圆括号：**一个参数无需定义圆括号，但多个参数需要定义圆括号。
  • **可选的大括号：**如果主体包含了一个语句，就不需要使用大括号。
  • **可选的返回关键字：**如果主体只有一个表达式返回值则编译器会自动返回值，大括号需要指定表达式返回了一个数值。

Lambda 表达式的简单例子:

// 1. 不需要参数,返回值为 5  
() -> 5  
  
// 2. 接收一个参数(数字类型),返回其2倍的值  
x -> 2 * x  
  
// 3. 接受2个参数(数字),并返回他们的差值  
(x, y) -> x – y  
  
// 4. 接收2个int型整数,返回他们的和  
(int x, int y) -> x + y  
  
// 5. 接受一个 string 对象,并在控制台打印,不返回任何值(看起来像是返回void)  
(String s) -> System.out.print(s)

在 Lambda 表达式当中不允许声明一个与局部变量同名的参数或者局部变量。

String first = "";
Comparator<String> comparator = (first, second) -> Integer.compare(first.length(), second.length());  //编译会出错

Stream

stream概述

Stream 是在 Java8 新增的特性，普遍称其为流；它不是数据结构也不存放任何数据，其主要用于集合的逻辑处理

Stream将要处理的元素集合看作一种流，在流的过程中，借助Stream API对流中的元素进行操作，比如：筛选、排序、聚合等。

stream特点

1.java 8 API添加了一个新的抽象称为流Stream，可以让你以一种声明的方式处理数据。
2.Stream 使用一种类似用 SQL 语句从数据库查询数据的直观方式来提供一种对 Java 集合运算  和    表达的高阶抽象。
3.Stream API可以极大提高Java程序员的生产力，让程序员写出高效率、干净、简洁的代码。
4.这种风格将要处理的元素集合看作一种流， 流在管道中传输， 并且可以在管道的节点上进行处   理， 比如筛选， 排序，聚合等。
5.元素流在管道中经过中间操作（intermediate operation）的处理，最后由最终操作(terminal   operation)得到前面处理的结果

Stream图

image-20220708101446469

java8中的箭头表达式

java8中新增了一个操作符，“->”箭头表达式，也叫Lambda操作符。

stream的创建

1:通过 java.util.Collection.stream() 方法用集合创建流

List<String> list = Arrays.asList("x", "z", "y");
// 创建一个顺序流
Stream<String> stream = list.stream();
// 创建一个并行流
Stream<String> parallelStream = list.parallelStream();

2:使用java.util.Arrays.stream(T[] array)方法用数组创建流

int[] array={1,3,5,6,8};
IntStream stream = Arrays.stream(array);

3:Stream.of用于为给定元素**创建顺序流**。我们可以传递单个元素或多个元素。

      Stream<Integer> mystream = Stream.of(10, 12, 14, 16);
      mystream.forEach(e-> System.out.println(e));

Collectors toMap

//实体类 & 一个list集合
class Book {
    private int id;
    private String name;
    private int year;
//get set
}

List<Book> bookList = new ArrayList<>();
bookList.add(new Book(1,"Eyes blue", 1954));
bookList.add(new Book(1,"Eyes blue", 1999));
bookList.add(new Book(2,"Revenge", 2000));
bookList.add(new Book(3,"History", 1955));

可以使用toMap的重载方法

toMap的重载方法有4个

image-20220923214229856

----指定key为Id  Function.identity()为Book对象本身
Map<Integer,Book> collect =books.stream().collect(Collectors.toMap(Book::getId, Function.identity()));
  • 当map的key存在重复的时候，直接映射会导致IllegalStateException异常
  • 需要在重复key的情况下，配置value的规则
----表示我们在key重复的时候,选择保留新的value还是旧的value
Map<Integer,Book> collect2 = as.stream().collect(Collectors.toMap(Book::getId, Function.identity(),(oldValue,newValue)-> newValue));

添加一个mapSupplier函数来返回一个ConcurrentHashMap:

ConcurrentHashMap<Integer,Book> collect55 = bookList.stream().collect(Collectors.toMap(Book::getId, Function.identity(),(oldValue,newValue)-> newValue,ConcurrentHashMap::new));

Collectors.groupingBy分组

System.out.println(bookList.stream().collect(Collectors.groupingBy(Book::getName)));

拼接流( Stream.concat(stream1,stream2))

        HashMap<String,String> nameMap = new HashMap<>();
        nameMap.put("xzy","徐子昀");
        nameMap.put("zcj","周成杰");
        nameMap.put("shihao","施浩");

        HashMap<String,Object> catMap = new HashMap<>();
        catMap.put("cat1","布偶猫");
        catMap.put("cat2","田园猫");
        catMap.put("cat3","英短");
        catMap.put("cat4","美短");


        //concat拼接流
        List<Map.Entry<String, ?>> collect = Stream.concat(nameMap.entrySet().stream(), 			   catMap.entrySet().stream()).collect(Collectors.toList());	
        System.out.println(collect);

stream和parallelStream的区别

  • stream() − 为集合创建串行流。

  •     List<String> str = new ArrayList<>();
    str.add("1");
    str.add("2");
    str.add("3");
    
    /*单个线程执行任务*/
    str.stream().filter(e -> {
        System.out.println(Thread.currentThread().getName() + "\t过滤" + e);
        return Integer.parseInt(e) % 2 == 0 ? true : false;
    }).collect(Collectors.toList());

    image-20220708113057331

  • parallelStream() − 为集合创建并行流。

           str.parallelStream().filter(e -> {
            System.out.println(Thread.currentThread().getName() + "\t过滤" + e);
            return Integer.parseInt(e) % 2 == 0 ? true : false;
        }).collect(Collectors.toList());

    image-20220708113438605

image-20220708103303493

串行: 再在可能存在共享资源、线程安全等问题的时候使用

并行: 在无线程安全问题的前提下，并且单纯的数据处理的时候使用

遍历/匹配（foreach/find/match）

Stream也是支持类似集合的遍历和匹配元素的，只是Stream中的元素是以Optional类型存在的。Stream的遍历、匹配非常简单

// import已省略，请自行添加，后面代码亦是

public class StreamTest {
	public static void main(String[] args) {
        //数组转List的静态方法
        List<Integer> list = Arrays.asList(7, 6, 9, 3, 8, 2, 1);

        // 遍历输出符合条件的元素
        list.stream().filter(x -> x > 6).forEach(System.out::println);
        // 匹配第一个
        Optional<Integer> findFirst = list.stream().filter(x -> x > 6).findFirst();
        // 匹配任意（适用于并行流）
        Optional<Integer> findAny = list.parallelStream().filter(x -> x > 6).findAny();
        // 是否包含符合特定条件的元素
        boolean anyMatch = list.stream().anyMatch(x -> x > 6);
        System.out.println("匹配第一个值：" + findFirst.get());
        System.out.println("匹配任意一个值：" + findAny.get());
        System.out.println("是否存在大于6的值：" + anyMatch);
    }
}

筛选（filter）

filter() 筛选，是按照一定的规则校验流中的元素，将符合条件的元素筛选出来

.collect()将流再转换成list返回,便于输出

image-20220708103522024

/
** filter()
* 把符合要求的元素筛选出来
*/
List<Person> collect = list.stream().filter(item -> item.getAge() > 20).collect(Collectors.toList());
#这里我们筛选对象年龄大于20的并输出
System.out.println(collect);

去重(distinct)

/** distinct()
* 去除重复元素,重写了equals和hashcode方法可以去除对象
*/
List<Person> distinct = list.stream().distinct().collect(Collectors.toList());
 System.out.println(distinct);

获取流前N个元素(limit)

/** limit()
 * limit获取流前n个元素
 */
List<Person> limit = list.stream().limit(3).collect(Collectors.toList());
System.out.println(limit);

获取除了流前N个元素(skip)

/** skip()
 * skip获取流除了前n个元素,相当于limit()取反
 */
List<Person> skip = list.stream().skip(3).collect(Collectors.toList());
System.out.println(skip);

映射(map/flatMap)

映射，可以将一个流的元素按照一定的映射规则映射到另一个流中。分为map和flatMap：

  • map：接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素。

  • flatMap：接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流。

  • // 解析：flatMap
    // (1) [a,b,c],[b,c],…,[e,f]
    // (2) [a,b,c,…,e,f] 扁平化操作

  • // 解析：map
// [a,b,c],[b,c],...,[e,f]

    案例一：英文字符串数组的元素全部改为大写

    List<String> string = Arrays.asList("abc","bzovo");
List<String> collect2 = string.stream().map(str -> str.toUpperCase()).collect(Collectors.toList());
System.out.println(collect2);

    案例二：将员工的薪资全部增加1000。

    List<Double> collect1 = list.stream().map(person -> person.getSalary() + 400).collect(Collectors.toList());
System.out.println("第一位的薪水为"+collect1.get(0));
System.out.println("第二位的薪水为"+collect1.get(1));
System.out.println("第三位的薪水为"+collect1.get(2));

    image-20220708110133873

    image-20220708110107173

聚合（max/min/count)

max、min、count这些字眼你一定不陌生，没错，在mysql中我们常用它们进行数据统计。Java stream中也引入了这些概念和用法，极大地方便了我们对集合、数组的数据统计工作。

案例一：获取String集合中最长的元素。

List<String> list2 = Arrays.asList("adnm", "admmt", "pot", "xbangd", "weoujgsd");
Optional<String> max = list2.stream().max(Comparator.comparing(String::length));
System.out.println("最长的字符串：" + max.get());

案例二：获取Integer集合中的最大值。

		List<Integer> list = Arrays.asList(7, 6, 9, 4, 11, 6);

		// 自然排序
		Optional<Integer> max = list.stream().max(Integer::compareTo);
		// 自定义排序
		Optional<Integer> max2 = list.stream().max(new Comparator<Integer>() {
			@Override
			public int compare(Integer o1, Integer o2) {
				return o1.compareTo(o2);
			}
		});
		System.out.println("自然排序的最大值：" + max.get());
		System.out.println("自定义排序的最大值：" + max2.get());

归约(reduce)

归约，也称缩减，顾名思义，是把一个流缩减成一个值，能实现对集合求和、求乘积和求最值操作

public class StreamTest {
	public static void main(String[] args) {
		List<Integer> list = Arrays.asList(1, 3, 2, 8, 11, 4);
		// 求和方式1
		Optional<Integer> sum = list.stream().reduce((x, y) -> x + y);
		// 求和方式2
		Optional<Integer> sum2 = list.stream().reduce(Integer::sum);
		// 求和方式3
		Integer sum3 = list.stream().reduce(0, Integer::sum);
		
		// 求乘积
		Optional<Integer> product = list.stream().reduce((x, y) -> x * y);

		// 求最大值方式1
		Optional<Integer> max = list.stream().reduce((x, y) -> x > y ? x : y);
		// 求最大值写法2
		Integer max2 = list.stream().reduce(1, Integer::max);

		System.out.println("list求和：" + sum.get() + "," + sum2.get() + "," + sum3);
		System.out.println("list求积：" + product.get());
		System.out.println("list求和：" + max.get() + "," + max2);
	}
}

收集(collect)

collect，收集，可以说是内容最繁多、功能最丰富的部分了。从字面上去理解，就是把一个流收集起来，最终可以是收集成一个值也可以收集成一个新的集合。

collect主要依赖java.util.stream.Collectors类内置的静态方法。

List<String> string = Arrays.asList("abc","bzovo");
List<String> collect2 = string.stream().map(str -> str.toUpperCase()).collect(Collectors.toList());

统计(count/averaging)

Collectors提供了一系列用于数据统计的静态方法：

计数：count
平均值：averagingInt、averagingLong、averagingDouble
最值：maxBy、minBy
求和：summingInt、summingLong、summingDouble
统计以上所有：summarizingInt、summarizingLong、summarizingDouble

public class StreamTest {
	public static void main(String[] args) {
		List<Person> personList = new ArrayList<Person>();
		personList.add(new Person("Tom", 8900, 23, "male", "New York"));
		personList.add(new Person("Jack", 7000, 25, "male", "Washington"));
		personList.add(new Person("Lily", 7800, 21, "female", "Washington"));

		// 求总数
		Long count = personList.stream().collect(Collectors.counting());
		// 求平均工资
		Double average = personList.stream().collect(Collectors.averagingDouble(Person::getSalary));
		// 求最高工资
		Optional<Integer> max = personList.stream().map(Person::getSalary).collect(Collectors.maxBy(Integer::compare));
		// 求工资之和
		Integer sum = personList.stream().collect(Collectors.summingInt(Person::getSalary));
		// 一次性统计所有信息
		DoubleSummaryStatistics collect = personList.stream().collect(Collectors.summarizingDouble(Person::getSalary));

		System.out.println("员工总数：" + count);
		System.out.println("员工平均工资：" + average);
		System.out.println("员工工资总和：" + sum);
		System.out.println("员工工资所有统计：" + collect);
	}
}

排序(sorted)

sorted，中间操作。有两种排序：

  • sorted()：自然排序，流中元素需实现Comparable接口
  • sorted(Comparator com)：Comparator排序器自定义排序
//按照id升序
bookList.stream().sorted((o1,o2)->o1.getId()-o2.getId()).collect(Collectors.toList()).forEach(System.out::println);
//按照id降序
bookList.stream().sorted((o1,o2)->o2.getId()-o1.getId()).collect(Collectors.toList()).forEach(System.out::println);

public class StreamTest {
	public static void main(String[] args) {
		List<Person> personList = new ArrayList<Person>();

		personList.add(new Person("Sherry", 9000, 24, "female", "New York"));
		personList.add(new Person("Tom", 8900, 22, "male", "Washington"));
		personList.add(new Person("Jack", 9000, 25, "male", "Washington"));
		personList.add(new Person("Lily", 8800, 26, "male", "New York"));
		personList.add(new Person("Alisa", 9000, 26, "female", "New York"));

		// 按工资升序排序（自然排序）
		List<String> newList = personList.stream().sorted(Comparator.comparing(Person::getSalary)).map(Person::getName)
				.collect(Collectors.toList());
		// 按工资倒序排序
		List<String> newList2 = personList.stream().sorted(Comparator.comparing(Person::getSalary).reversed())
				.map(Person::getName).collect(Collectors.toList());
		// 先按工资再按年龄升序排序
		List<String> newList3 = personList.stream()
				.sorted(Comparator.comparing(Person::getSalary).thenComparing(Person::getAge)).map(Person::getName)
				.collect(Collectors.toList());
		// 先按工资再按年龄自定义排序（降序）
		List<String> newList4 = personList.stream().sorted((p1, p2) -> {
			if (p1.getSalary() == p2.getSalary()) {
				return p2.getAge() - p1.getAge();
			} else {
				return p2.getSalary() - p1.getSalary();
			}
		}).map(Person::getName).collect(Collectors.toList());

		System.out.println("按工资升序排序：" + newList);
		System.out.println("按工资降序排序：" + newList2);
		System.out.println("先按工资再按年龄升序排序：" + newList3);
		System.out.println("先按工资再按年龄自定义降序排序：" + newList4);
	}
}

Optional 类

Optional 类是一个可以为null的容器对象。如果值存在则isPresent()方法会返回true，调用get()方法会返回该对象。

Optional 是个容器：它可以保存类型T的值，或者仅仅保存null。Optional提供很多有用的方法，这样我们就不用显式进行空值检测。

Optional 类的引入很好的解决空指针异常。

日期时间Api

火星包18163112
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
java8新特性
11-08
本视频为java8新特性，百度云链接和密码，永久有效，失效联系我
Java 8中 Date 获取时间所在 周一，月第一天，季度第一天，年第一天的方式
极客编程的专栏
05-29 2593
Java 8 中 日期，时间API 完全重构。抛弃了原来非常复杂的 calendar. 还加入了线程安全的等更加友好的API。本文主要是记录分享 常用的 时间所在周，月，季度，年的 第一天获取方式。
箭头函数 lambda表达式-(java8新特性)
qq_49074573的博客
12-04 2239
箭头函数lambda表达式
java8 箭头_JDK8新特性详细介绍
weixin_34261759的博客
02-16 655
函数式编程面向对象强调“一切皆对象”，如果想要做事情，必须要找到对象来做。函数式编程思想强调“做什么”，而不是“怎么做”。普通的开启线程// 匿名内部类对象Runnable task = new Runnable() {@Overridepublic void run() {System.out.println("乌鸦坐飞机");}};new Thread(task).start();更多java...
Java8之Lambda 表达式(箭头函数)
John的博客
04-14 3221
函数式编程思想 在数学中 函数就是有输入量和输出量的一套计算方案 也就是“拿什么东西做什么事情” 相对而言 面向对象过分强调必须通过对象的形式来做事情 而函数式思想则尽量忽略面向对象的复杂语法——强调做什么 而不是以什么形式做 面向对象的思想： 做一件事情 找一个能解决这个事情的对象 调用对象的方法 完成事情 函数式编程思想： 只要能获取到结果 谁去做的 怎么做的都不重要,重视的是结果 不重视过程 可能不太好理解 我们举个简单的栗子： 代码冗余 public static void main(Stri
Java中的箭头——Lambda表达式
沉默的大多数
12-09 7428
转自：Java 8 Lambda 表达式——菜鸟教程 Lambda 表达式，也可称为闭包，它是推动 Java 8 发布的最重要新特性。 Lambda 允许把函数作为一个方法的参数（函数作为参数传递进方法中）。 使用 Lambda 表达式可以使代码变的更加简洁紧凑。 语法格式： (parameters) -> expression 或 (parameters) ->...
jdk8新特性-亮瞎眼的lambda表达式
若鱼的专栏
04-01 1万+
jdk8之前，尤其是在写GUI程序的事件监听的时候，各种的匿名内部类，大把大把拖沓的代码，程序毫无美感可言！既然java中一切皆为对象，那么，就类似于某些动态语言一样，函数也可以当成是对象啊！代码块也可以当成是对象啊！随着函数式编程的概念越来越深入人心，java中CODE=OBJECT的这一天终于到来了！如果你认为lambda表达式仅仅是为了从语法上简化匿名内部类，那就太小看jdk8的lambda
Java8的Lambda表达式(箭头函数)
"✧treasure mountain✧"
03-04 1万+
函数式编程思想 在数学中 函数就是有输入量和输出量的一套计算方案 也就是“拿什么东西做什么事情” 相对而言 面向对象过分强调必须通过对象的形式来做事情 而函数式思想则尽量忽略面向对象的复杂语法——强调做什么 而不是以什么形式做 面向对象的思想： 做一件事情 找一个能解决这个事情的对象 调用对象的方法 完成事情 函数式编程思想： 只要能获取到结果 谁去做的 怎么做的都不重要,重视的是结果 不重视过...
java8 箭头_java8新特性——Lambda表达式
weixin_28718769的博客
02-16 726
上文中简单介绍了一下java8得一些新特性，与优点，也是为本次学习java8新特性制定一个学习的方向，后面几篇会根据上文中得新特性一一展开学习。本文就从java8新特性中比较重要的Lambda表达式开始学学习。一、为什么要使用Lambda表达式Lambda是一个匿名函数，我们可以baLambda表达式理解为是一段可以传递的代码(将代码像数据一样进行传递)。可以写出更简洁，更灵活的代码。作为一种更紧...
java8箭头_初识JAVA8
weixin_36340672的博客
02-25 279
原标题：初识JAVA8函数式编程不知不觉JAVA 8已经发布有四年多了，其中的Lambda表达式，函数式接口，Stream流式编程的引入了，带给了我们函数式编程风格，今天让我们一起简单了解下这些特性。在了解JAVA8 之前，让我们先了解下何为函数式编程，以及函数式编程能给我们带来什么。 这里引用阮一峰大神对函数式编程的理解：函数式编程的理解：1. 函数是"第一等公民"函数作为一等公民，指的是函数与...
java8 箭头_java8新特性
weixin_32585497的博客
02-16 320
1、list转ListList openIdList = list.stream().map(o -> o.getOpenId()).collect(Collectors.toList());2、List转mapMap userMap =userList.stream().collect(Collectors.toMap(SearchActivityCustomerResultDto::ge...
JAVA8 十大新特性详解
madison's blog
02-18 890
一、lambda含义 lambda表示数学符号“λ”，计算机领域中λ代表“λ演算”，表达了计算机中最基本的概念：“调用”和“置换”。在很多动态语言和C#中都有相应的lambda语法，这类语法都为了简化代码，提高运行效率。 二、lambda 项目的背景(link ) 无论是面向对象语言还是函数式语言，基本数值都可以被动态的封装入程序动作：面向对象语言通过“方法”，函数式语言通过
java8入门（一） --λ表达式
williamtsang的博客
09-19 4850
java8学习（一） –λ表达式先来看一个简单的接口，通过学生的学号获取姓名，假设接口是这样子的。package help.mygod.java8;public interface IStudent { String getName(String id);}简单吧，现在如果我们要用getName，有几种方法呢，首先想到的应该是写一个类Student实现IStudent，或者用匿名内部类，又或者
Java8新特性Lambda表达式、函数式接口
我不是李大侠
08-02 3117
什么是Lambda表达式，java8为什么使用Lambda表达式？ “Lambda 表达式”(lambda expression)是一个匿名函数，Lambda表达式基于数学中的λ演算得名，直接对应于其中的lambda抽象(lambda abstraction)，是一个匿名函数，即没有函数名的函数。我们可以把 Lambda表达式理解为是 一段可以传递的代码。最直观的是使用Lambda表达式之后不用
java8新特性-Lombda语法
HL_smile90的专栏
08-09 2783
/*  * 一、Lambda 表达式的基础语法：Java8中引入了一个新的操作符 "->" 该操作符称为箭头操作符或 Lambda 操作符  *                          箭头操作符将 Lambda 表达式拆分成两部分：  *  * 左侧：Lambda 表达式的参数列表  * 右侧：Lambda 表达式中所需执行的功能， 即 Lambda 体  *
Java 8的新特性—终极版
热门推荐
飞鸟Blog
03-15 14万+
前言： Java 8 已经发布很久了，很多报道表明Java 8 是一次重大的版本升级。在Java Code Geeks上已经有很多介绍Java 8新特性的文章，例如Playing with Java 8 – Lambdas and Concurrency、Java 8 Date Time API Tutorial : LocalDateTime和Abstract Class Versus
java 8 新特性
最新发布
07-27
Java 8引入了许多令人兴奋的新特性，以下是其中一些： 1. Lambda表达式：Lambda表达式允许以更简洁的方式编写匿名函数，并且可以更方便地使用函数式编程风格。 2. 函数式接口：Java 8引入了函数式接口的概念，这是...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值