JDK1.8新特性学习笔记

最新推荐文章于 2022-11-07 14:17:16 发布
最新推荐文章于 2022-11-07 14:17:16 发布
阅读量200 收藏
点赞数
分类专栏： Java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36903261/article/details/107884308
版权
本文深入探讨Java 8引入的重要特性，包括Lambda表达式、Stream API、Optional类、接口中的默认方法与静态方法、新的时间日期API以及重复注解与类型注解，旨在帮助开发者掌握最新Java编程技巧。
摘要由CSDN通过智能技术生成

文章目录

简介

在这里插入图片描述
在这里插入图片描述

一、Lambda表达式

在这里插入图片描述

语法格式

在这里插入图片描述
Lambda表达式只能用于函数式接口，即接口里只有一个方法，函数式接口上可加上@FunctionalInterface注解。
Lambda表达式的参数列表的数据类型可以省略不写，JVM编译器可以通过上下文推断出数据类型，即“类型推断”。

  1. 无参数，无返回值

    Runnable r1 = new Runnable() {
    @Override
    public void run() {
        System.out.println("Hello Java!");
    }
};
r1.run();

    写为Lambda表达式：

    Runnable r2 = () -> System.out.println("Hello Lambda!");
r2.run();

  2. 有一个参数，无返回值（只有一个参数时，小括号可以不写）

    Consumer<String> con1 = new Consumer<String>() {
    @Override
    public void accept(String s) {
        System.out.println(s);
    }
};
con1.accept("hello");

    写为Lambda表达式：

    Consumer<String> con2 = (s) -> System.out.println(s);
//只有一个参数时，小括号可以不写
//Consumer<String> con2 = s -> System.out.println(s);
con2.accept("lambda");

  3. 有两个以上的参数，有返回值，Lambda体中有多条语句

    Comparator<Integer> com1 = new Comparator<Integer>() {
    @Override
    public int compare(Integer o1, Integer o2) {
        System.out.println("hello");
        return Integer.compare(o1, o2);
    }
};
System.out.println(com1.compare(2, 3));

    写为Lambda表达式：

    Comparator<Integer> com2 = (o1, o2) -> {
        System.out.println("lambda");
        return Integer.compare(o1, o2);
    };
System.out.println(com1.compare(2, 3));

  4. 有两个参数，有返回值（如果只有返回语句，可省略{}和return）

    Comparator<Integer> com1 = new Comparator<Integer>() {
    @Override
    public int compare(Integer o1, Integer o2) {
        return Integer.compare(o1, o2);
    }
};
System.out.println(com1.compare(2, 3));

    写为Lambda表达式：

    Comparator<Integer> com2 = (x, y) -> Integer.compare(x, y);
System.out.println(com2.compare(2, 3));

在这里插入图片描述

函数式接口

在这里插入图片描述
在这里插入图片描述

    public static void main(String[] args) {
        //Consumer<T> 消费型接口：有参数，无返回值
        happy(1000, (m) -> System.out.println("消费" + m + "元"));

        //Supplier<T> 供给型接口：有返回值
        List<Integer> lists = getNumList(10, () -> (int)(Math.random() * 100));
        lists.forEach(System.out::println);

        //Function<T, R> 函数型接口：对传参进行处理后返回结果
        String s = strHandler("\t\t\t aaa  ", (str) -> str.trim());
        System.out.println(s);
        System.out.println(strHandler("ABCD", (str) -> str.toLowerCase()));

        //Predicate<T> 断言型接口：对传参进行判断/过滤
        List<String> list = Arrays.asList("hello lambda aa bbb cccccc www ok".split(" "));
        List<String> strings = filterStr(list, (s) -> s.length() > 3);
        strings.forEach(System.out::println);
    }

    public static void happy(double money, Consumer<Double> con){
        con.accept(money);
    }

    public static List<Integer> getNumList(int num, Supplier<Integer> sup){
        List<Integer> lists = new ArrayList<>();

        for (int i = 0; i < num; i++) {
            lists.add(sup.get());
        }
        return lists;
    }

    public static String strHandler(String str, Function<String, String> fun){
        return fun.apply(str);
    }

    public static List<String> filterStr(List<String> list, Predicate<String> pre){
        List<String> strList = new ArrayList<>();

        for (String s : list) {
            if(pre.test(s)){
                strList.add(s);
            }
        }
        return strList;
    }

在这里插入图片描述

方法引用

在这里插入图片描述

    //对象::实例方法名
    Consumer<String> con = (x) -> System.out.println(x);
    Consumer<String> con2 = System.out::println;

    //类::静态方法名
    Comparator<Integer> com = (x, y) -> Integer.compare(x, y);
    Comparator<Integer> com2 = Integer::compare;

    //类::实例方法名
    BiPredicate<String, String> bp = (x, y) -> x.equals(y);
    BiPredicate<String, String> bp2 = String::equals;

构造器引用

在这里插入图片描述

    //无参构造器
    Supplier<Employee> emp = () -> new Employee();
    Supplier<Employee> emp2 = Employee::new;

    //一个参数的构造器
    Function<Integer, Employee> emp3 = (x) -> new Employee(x);
    Function<Integer, Employee> emp4 = Employee::new;

数组引用

在这里插入图片描述

     Function<Integer, String[]> fun = (x) -> new String[x];
     String[] strs = fun.apply(5);
     System.out.println(strs.length);

     Function<Integer, String[]> fun2 = String[]::new;
     String[] strs2 = fun2.apply(4);
     System.out.println(strs2.length);

二、Stream API

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

创建流

   //创建流
   
   //1. Conllection系列的集合可以通过stream()或parallelStream()获取流
   //stream()为串行
   //parallelStream()为并行
   List<String> list = new ArrayList<>();
   Stream<String> stream1 = list.stream();

   //2. 数组通过Arrays的静态方法stream()获取流
   Employee[] emps = new Employee[10];
   Stream<Employee> stream2 = Arrays.stream(emps);

   //3. 通过Stream的静态方法of()获取流
   Stream<String> stream3 = Stream.of("aa", "bb", "ccc");

   //4. 创建无限流
   //4.1. 迭代
   Stream<Integer> stream4 = Stream.iterate(0, (x) -> x + 2);
   stream4
       //中间操作
       .limit(10)
       //终止操作
       .forEach(System.out::println);
   
   //4.2. 生成
   Stream.generate(() -> Math.random())
       //中间操作
       .limit(5)
       //终止操作
       .forEach(System.out::println);

中间操作

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

筛选与切片

在这里插入图片描述

	List<Employee> employees = Arrays.asList(
         new Employee("张三", 18, 9999.99),
         new Employee("李四", 58, 5555.55),
         new Employee("王五", 26, 3333.33),
         new Employee("赵六", 36, 6666.66),
         new Employee("田七", 12, 8888.88),
         new Employee("田七", 12, 8888.88),
         new Employee("田七", 12, 8888.88)
    );


   //中间操作：不会执行任何操作
   //filter
   Stream<Employee> stream1 = employees.stream()
                               //过滤
                               .filter((e) -> {
                                   //没有终止操作时，中间操作不会执行（惰性求值/延迟加载）
                                   System.out.println("中间操作：过滤");
                                   return e.getAge() > 35;
                               });
   //终止操作：一次性执行全部内容，即"惰性求值"
   stream1.forEach(System.out::println);

   //limit
   employees.stream()
           //过滤，money大于5000
           .filter(e -> {
               System.out.println("---money > 5000---");
               return e.getMoney() > 5000;
           })
           //截断，截取2个（截取指定数量后，剩下的不会进行，提高效率）
           .limit(2)
           //终止操作
           .forEach(System.out::println);

   //skip
   employees.stream()
           .filter(e -> e.getMoney() > 5000)
           //跳过，跳过前2个元素
           .skip(2)
           .forEach(System.out::println);

   //distinct
   employees.stream()
       .filter(e -> e.getMoney() > 5000)
       .skip(2)
       //去重，去除重复元素（按照hashCode()和equals()去除重复元素，所以需要重写hashCode()和equals()）
       .distinct()
       .forEach(System.out::println);

映射

在这里插入图片描述

    //map
    List<String> list = Arrays.asList("aaa", "bbb", "ccc", "ddd");

    list.stream()
        .map((str -> str.toUpperCase()))
        .forEach(System.out::println);

    System.out.println("------------------------------");

    employees.stream()
            .map(emp -> emp.getName())
            .forEach(System.out::println);

public static void main(String[] args) {
    //flatMap
    Stream<Stream<Character>> stream = list.stream()
            //list的每个元素都放入filterCharacter方法拆成char数组放到一个新的list的流中
            .map(TestStream2::filterCharacter);
    //遍历流，Stream<Stream<Character>> {[a,a,a],[b,b,b],[c,c,c],[d,d,d]}
    stream.forEach((sm) -> {
        //遍历流中的流，即Stream<Character> [a,a,a]
        sm.forEach(System.out::println);
    });

    System.out.println("------------------------------");

    Stream<Character> stream2 = list.stream()
            //整合成一个流     {a,a,a,b,b,b,c,c,c,d,d,d}
            .flatMap(TestStream2::filterCharacter);
    stream2.forEach(System.out::println);
}

public static Stream<Character> filterCharacter(String str){
    List<Character> list = new ArrayList<>();

    for (char ch : str.toCharArray()) {
        list.add(ch);
    }
    return list.stream();
}

排序

在这里插入图片描述

    //sorted()：按照默认规则进行排序
    List<String> list = Arrays.asList("bbb", "ddd", "aaa", "ccc");

    list.stream()
            .sorted()
            .forEach(System.out::println);

	System.out.println("------------------------------");

    employees.stream()
            //自定义排序规则
            .sorted((e1, e2) -> {
                //年龄相同按姓名排
                if (e1.getAge().equals(e2.getAge())) {
                    return e1.getName().compareTo(e2.getName());
                }else{
                    //按照年龄排序
                    return e1.getAge().compareTo(e2.getAge());
                }
            })
            .forEach(System.out::println);

终止操作

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

查找与匹配

在这里插入图片描述

   	List<Employee> employees = Arrays.asList(
            new Employee("张三", 18, 9999.99, Employee.Status.FREE),
            new Employee("李四", 58, 5555.55, Employee.Status.BUSY),
            new Employee("王五", 26, 3333.33, Employee.Status.VOCATION),
            new Employee("赵六", 36, 6666.66, Employee.Status.FREE),
            new Employee("田七", 12, 8888.88, Employee.Status.BUSY)
    );

    //终止操作

    //allMatch
    boolean b1 = employees.stream()
            //检查所有元素是否符合条件，都符合才为true
            .allMatch((e) -> e.getStatus().equals(Employee.Status.BUSY));
    System.out.println(b1);

    //anyMatch
    boolean b2 = employees.stream()
            //检查所有元素是否有符合条件的元素，有一个符合就为true
            .anyMatch((e) -> e.getStatus().equals(Employee.Status.BUSY));
    System.out.println(b2);

    //noneMatch
    boolean b3 = employees.stream()
            //检查所有元素是否都不符合条件，都不符合为true
            .noneMatch((e) -> e.getStatus().equals(Employee.Status.BUSY));
    System.out.println(b3);

    //findFirst
    Optional<Employee> first = employees.stream()
            //按照工资排序
            .sorted((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary()))
            //获取第一个元素
            .findFirst();
    System.out.println(first.get());

    //findAny
    Optional<Employee> any = employees.parallelStream()
            //过滤出所有空闲状态的员工
            .filter((e) -> e.getStatus().equals(Employee.Status.FREE))
            //随机获取一个员工
            .findAny();
    System.out.println(any);

    //count
    long count = employees.stream()
            //查看总数
            .count();
    System.out.println(count);

    //max
    Optional<Employee> max = employees.stream()
            //按照工资获取最大值
            .max((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary()));
    System.out.println(max.get());

    //min
    Optional<Double> min = employees.stream()
            //提取所有的工资数据
            .map(Employee::getSalary)
            //获取最小值
            .min(Double::compare);
    System.out.println(min.get());

归约与收集

在这里插入图片描述

    //reduce
    List<Integer> list = Arrays.asList(0, 1, 2, 3, 4, 5, 6, 7, 8, 9);
    Integer sum = list.stream()
            //合并，起始索引为0，执行操作相加
            .reduce(0, (x, y) -> x + y);
    System.out.println(sum);


    Optional<Double> sum2 = employees.stream()
            //提取所有的工资数据
            .map(Employee::getSalary)
            //合并，工资总和
            .reduce(Double::sum);
    System.out.println(sum2.get());

在这里插入图片描述

    //collect
    List<String> list = employees.stream()
                            //获取所有名字数据
                            .map(Employee::getName)
                            //收集数据，并存放到list中
                            .collect(Collectors.toList());
    list.forEach(System.out::println);

    System.out.println("-----------------------------");

    Set<String> set = employees.stream()
            //获取所有名字数据
            .map(Employee::getName)
            //收集数据，并存放到set中，有去重功能
            .collect(Collectors.toSet());
    set.forEach(System.out::println);

    System.out.println("-----------------------------");


    Set<String> hs = employees.stream()
            //获取所有名字数据
            .map(Employee::getName)
            //收集数据，并存放到HashSet中，有去重功能
            .collect(Collectors.toCollection(HashSet::new));
    hs.forEach(System.out::println);

    //总数
    Long count = employees.stream()
            .collect(Collectors.counting());
    System.out.println(count);

    System.out.println("-----------------------------");

    //平均值
    Double avg = employees.stream()
            //工资的平均值
            .collect(Collectors.averagingDouble(Employee::getSalary));
    System.out.println(avg);

    System.out.println("-----------------------------");

    //总和
    Double sum = employees.stream()
            .collect(Collectors.summingDouble(Employee::getSalary));
    System.out.println(sum);

    //最大值
    Optional<Employee> max = employees.stream()
            .collect(Collectors.maxBy((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary())));
    System.out.println(max.get());

    //最小值
    Optional<Double> min = employees.stream()
            .map(Employee::getSalary)
            .collect(Collectors.minBy(Double::compare));
    System.out.println(min.get());

   //分组
    Map<Employee.Status, List<Employee>> map = employees.stream()
            //按照状态分组
            .collect(Collectors.groupingBy(Employee::getStatus));
    System.out.println(map);

    //多级分组
    Map<Employee.Status, Map<String, List<Employee>>> map2 = employees.stream()
            //按状态分组后再按照年龄分
            .collect(Collectors.groupingBy(Employee::getStatus, Collectors.groupingBy((e) -> {
                if (e.getAge() <= 35) {
                    return "青年";
                } else if (e.getAge() <= 50) {
                    return "中年";
                } else {
                    return "老年";
                }
            })));
    System.out.println(map2);

    //分区
    Map<Boolean, List<Employee>> map = employees.stream()
            //满足条件true一个区，不满足条件false一个区
            .collect(Collectors.partitioningBy((e) -> e.getSalary() > 8000));
    System.out.println(map);

    //计算
    DoubleSummaryStatistics dss = employees.stream()
            .collect(Collectors.summarizingDouble(Employee::getSalary));
    System.out.println(dss.getCount());
    System.out.println(dss.getAverage());
    System.out.println(dss.getMax());
    System.out.println(dss.getMin());

    //连接
    String s = employees.stream()
            .map(Employee::getName)
            .collect(Collectors.joining());
//                .collect(Collectors.joining(", "));
//                .collect(Collectors.joining(", ", "====", "===="));
    System.out.println(s);

并行流与顺序流

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
RecursiveAction没有返回值
RecursiveTask有返回值

三、Optional

在这里插入图片描述
在这里插入图片描述

四、接口中的默认方法与静态方法

在这里插入图片描述
在这里插入图片描述

public class Test {
    public static void main(String[] args) {
        //当某个类继承和实现的类中存在相同的方法时，如果父类中提供了具体实现，优先父类
        //如果实现的两个接口都有相同的方法，必须重写其中一个接口的方法
        SubClass subClass = new SubClass();
        System.out.println(subClass.getName()); //class

        MyFun.show();
    }
}

interface MyFun{
    default String getName(){
        return "interface";
    }

    //接口中可以写静态方法
    public static void show(){
        System.out.println("interface static method");
    }
}

class MyClass{
    public String getName(){
        return "class";
    }
}

class SubClass extends MyClass implements MyFun {
}

五、新时间日期API

在这里插入图片描述

LocalDate、LocalTime、LocalDateTime

  • LocalDate：日期
  • LocalTime：时间
  • LocalDateTime：日期时间

三个类用法相同，只是专注点不同。

	//获取当前时间
	LocalDateTime ldt = LocalDateTime.now();
	System.out.println(ldt);    //2020-08-09T22:19:45.912
	//获取指定时间，2020-01-01 00:00:00
	LocalDateTime ldt2 = LocalDateTime.of(2020, 1, 01, 00, 00, 00);
	System.out.println(ldt2);   //2020-01-01T00:00
	
	//plusXxx()方法为在当前时间上增加时间
	LocalDateTime ldt3 = ldt2.plusYears(2);
	System.out.println(ldt3);   //2022-01-01T00:00
	
	System.out.println(ldt2.getYear());         //年 2020
	System.out.println(ldt2.getMonthValue());   //月 1
	System.out.println(ldt2.getDayOfMonth());   //日 1
	System.out.println(ldt2.getHour());         //时 0
	System.out.println(ldt2.getMinute());       //分 0
	System.out.println(ldt2.getSecond());       //秒 0

Instant

Instant：时间戳（以Unix元年(1970-01-01 00:00:00)到某个时间之间时间的毫秒值）

    Instant instant = Instant.now();    //默认获取 UTC 时区
    System.out.println(instant);    //2020-08-09T14:19:45.914Z

    //偏移8个小时
    OffsetDateTime odt = instant.atOffset(ZoneOffset.ofHours(8));
    System.out.println(odt);    //2020-08-09T22:19:45.914+08:00

    //转成毫秒时间戳
    System.out.println(instant.toEpochMilli()); //1596983036271

    Instant instant2 = Instant.ofEpochSecond(60);
    System.out.println(instant2);   //1970-01-01T00:01:00Z

Duration、Period

  • Duration：计算两个"时间"的间隔
  • Period：计算两个"日期"的间隔
    //Duration：计算两个"时间"的间隔
    Instant ins1 = Instant.now();
    try {
        Thread.sleep(1000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    Instant ins2 = Instant.now();
    Duration duration = Duration.between(ins1, ins2);
    System.out.println(duration.toMillis());

    LocalTime lt1 = LocalTime.now();
    try {
        Thread.sleep(1000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    LocalTime lt2 = LocalTime.now();
    Duration duration2 = Duration.between(lt1, lt2);
    System.out.println(duration2.toMillis());


    //Period：计算两个"日期"的间隔
    LocalDate ld1 = LocalDate.of(2020, 1, 1);
    LocalDate ld2 = LocalDate.now();
    Period period = Period.between(ld1, ld2);
    //相差7个月8天
    System.out.println(period.getYears());  //0
    System.out.println(period.getMonths()); //7
    System.out.println(period.getDays());   //8

时间校正器

在这里插入图片描述

TemporalAdjuster：时间校正器

    //TemporalAdjuster：时间校正器
    LocalDateTime ldt = LocalDateTime.now();
    System.out.println(ldt);    //2020-08-10T11:09:16.967

    //withXxx()：
    LocalDateTime ldt2 = ldt.withDayOfMonth(10);
    System.out.println(ldt2);   //2020-08-10T11:09:16.967

    //返回下一个周日的日期时间
    LocalDateTime ldt3 = ldt.with(TemporalAdjusters.next(DayOfWeek.SUNDAY));
    System.out.println(ldt3);   //2020-08-16T11:09:16.967

    //自定义：返回下一个工作日的日期时间
    LocalDateTime ldt5 = ldt.with((l) -> {
        LocalDateTime ldt4 = (LocalDateTime) l;
        //获取当前为周几
        DayOfWeek dow = ldt4.getDayOfWeek();

        //如果是周五，日期加上3天
        if (dow.equals(DayOfWeek.FRIDAY)) {
            return ldt4.plusDays(3);
        } else if (dow.equals(DayOfWeek.FRIDAY)) {
            //如果是周五，日期加上1天
            return ldt4.plusDays(2);
        } else {
            //其他的加1天
            return ldt4.plusDays(1);
        }
    });
    System.out.println(ldt5);   //2020-08-11T11:17:36.618

DateTimeFormatter：格式化时间/日期

    //DateTimeFormatter：格式化时间/日期
    DateTimeFormatter dtf = DateTimeFormatter.ISO_DATE;
    LocalDateTime ldt = LocalDateTime.now();
    //格式化日期
    String strDate = ldt.format(dtf);
    System.out.println(strDate);    //2020-08-10

    //自定义：日期格式
    DateTimeFormatter dtf2 = DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH:mm:ss");
    String strDate2 = dtf2.format(ldt);
    System.out.println(strDate2);   //2020年08月10日 11:24:53

    //转换为原来的日期
    LocalDateTime newDate = ldt.parse(strDate2, dtf2);
    System.out.println(newDate);    //2020-08-10T11:27:28

ZonedDateTime：时区

在这里插入图片描述
在这里插入图片描述

    //支持的时区
    Set<String> set = ZoneId.getAvailableZoneIds();
    set.forEach(System.out::println);

    //指定时区的日期时间
    LocalDateTime ldt = LocalDateTime.now(ZoneId.of("Asia/Tokyo"));
    System.out.println(ldt);    //2020-08-10T12:34:06.619

    //指定时区的日期时间，返回带时区的日期时间
    LocalDateTime ldt2 = LocalDateTime.now();
    ZonedDateTime zdt = ldt2.atZone(ZoneId.of("Asia/Tokyo"));
    System.out.println(zdt);    //2020-08-10T11:36:39.001+09:00[Asia/Tokyo]

六、重复注解与类型注解

在这里插入图片描述
注解：MyAnnotation

@Repeatable(MyAnnotations.class)    //重复注解需要加上@Repeatable注解修饰，并指定注解的容器
@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE, TYPE_PARAMETER})  //注解可加的位置（TYPE_PARAMETER：类型注解）
@Retention(RetentionPolicy.RUNTIME) //注解的生命周期
public @interface MyAnnotation {

    String value() default "angenin";

}

注解的容器：MyAnnotations

@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE})  //注解可加的位置
@Retention(RetentionPolicy.RUNTIME) //注解的生命周期
public @interface MyAnnotations {

    //MyAnnotation的注解容器
    MyAnnotation[] value();

}

测试类：TestAnnotation

public class TestAnnotation {

    //@NotNull（类型注解）：对象不能为空
    private @NotNull Object obj = null;

    @MyAnnotation("hello")
    @MyAnnotation("world")
    public void show(@MyAnnotation("abc") String str){
    }

    public static void main(String[] args) throws Exception {
        Class<TestAnnotation> clazz = TestAnnotation.class;
        Method m1 = clazz.getMethod("show");

        MyAnnotation[] mas = m1.getAnnotationsByType(MyAnnotation.class);

        for (MyAnnotation ma : mas) {
            System.out.println(ma.value());
        }
    }
}

JDK1.8的新特性可能并不完整，按照视频记的笔记，目前正在查漏补缺。

学习视频：https://www.bilibili.com/video/BV14W411u7Ly?p=1

小楊同学的笔记本
关注
专栏目录
JDK 1.8 新特性之Stream 详解个人笔记
m0_52348758的博客
01-14 460
虽然java 10已经发布，11 已经在路上，虽然 java EE 已经更名为 jakarta EE，但是大多数人连jdk1.8的新特性都不太了解，本人也是如此，所以在学习Java 8 API 添加的 Stream 的时候 做一些个人笔记，希望帮助自己的同时也能帮到大家。 首先对stream的操作可以分为两类，中间操作(intermediate operations)和结束操作(terminal operations): 中间操作总是会惰式执行，调用中间操作只会生成一个标记了该操作的新stream。
Java虚拟机(jdk1.8)学习笔记(经典垃圾收集器)
最新发布
此物最相思
08-08 346
更具体的处理思路是让G1收集器去跟踪各个Region里面的垃圾堆积的“价值”大小，价值即回收所获得的空间大小以及回收所需时间的经验值，然后在后台维护一个优先级列表，每次根据用户设定允许的收集停顿时间（使用参数-XX：MaxGCPauseMillis指定，默认值是200毫秒），优先处理回收价值收益最大的那些Region，这也就是“Garbage First”名字的由来。-XX：GCTimeRatio参数：该参数的值则应当是一个大于0小于100的整数，也就是垃圾收集时间占总时间的比率，相当于吞吐量的倒数。
JDK1.8新特性-New Features in Java SE 8
06-23
JDK1.8新特性,New Features in Java SE 8
jdk1.8 学习笔记
ldybing的专栏
03-26 182
public class Jdk8Stream { /* *Stream 接口java.util.Stream 表示能应用在一组元素上一次执行的操作序列。 * Stream 操作分为中间操作或者最终操作两种，最终操作返回一特定类型的计算结果，而中间操作返回Stream本身，这样你就可以将多个操作依次串起来。 * Stream 的创建需要指定一个数据源，比如 ja...
JDK1.8简单了解
lvbinibnsb的博客
10-29 723
原文转载自http://www.cnblogs.com/snowInPluto/p/5981400.html 1.1 函数式编程简介 我们最常用的面向对象编程（Java）属于命令式编程（Imperative Programming）这种编程范式。常见的编程范式还有逻辑式编程（Logic Programming），函数式编程（Functional Programming）。 函数式编程作为
java jdk1.8新特性粗略总结
resistancealex的博客
08-18 223
JDK1.8中的特性： 接口方法 lambda表达式 方法引用 Stream API 接口增强 JDK1.8中引入了一种新的机制：接口可以支持在声明方法的同时，提供实现。 主要通过两种方式可以完成这种操作： 默认方法 静态方法 实现接口的类，可以继承这些方法并直接使用，就不再需要强制在实现类中的去实现（重写）接口中的方法了。这种机制可以使我们更平滑地进行接口的优化和演进。 方法调用的判断规则： 类中声明的方法优先级最高。 类或父类中，声明的方法要高于任何默认方法的优先级 如果无法依据第一条进行判断
JDK1.8新特性
小白成长之路~~~
07-25 264
侵权删。。
tomcat6.0.48+jdk1.7或jdk1.8或jdk1.6
06-28
标题中的"tomcat6.0.48+jdk1.7或jdk1.8或jdk1.6"指的是一个配置环境，其中Tomcat是Apache软件基金会的一个开源Java Servlet容器，版本为6.0.48，它主要用于部署和运行Java Web应用程序。而JDK（Java Development Kit...
JDK1.8 新时间日期API学习笔记
热门推荐
wangxuelei036的博客
02-24 1万+
目录 前言 预备知识 LocalDate、LocalTime、LocalDateTime、Instant 继承关系图 时间对象创建 时间信息获取 时间信息修改 时间格式化(获取指定格式字符串) 时间比较 时间戳（Instant） 计算时间差(Period、Duration、ChronoUnit) java.time.Period java.time.Duration ...
JDK1.8新特性学习(四)——Stream流
Sun_of_Rainy的博客
08-27 284
package test4; import java.util.ArrayList; import java.util.Arrays; import java.util.Collections; import java.util.Comparator; import java.util.DoubleSummaryStatistics; import java.util.List;import ...
HashMap (jdk1.8) clear()、containsValue（Object key)方法详细注释
汉堡配大蒜
07-15 130
clear() /* * 清空hashMap * */ public void clear() { HashMap.Node<K,V>[] tab; //定义node类型的数组tab modCount++; //记录hashMap被修改的次数 if ((tab = table) != null && size > 0) { //把hashMap的成员变量table赋值给tab,tab不为空，h
java1.8新特性Stream接口
Andrew_Yuan的博客
04-18 216
*List<String>转换为List<Integer> List<Integer> codesInteger = codes.stream().map(Integer::parseInt).collect(Collectors.toList()); 1.distinct（）是Stream接口的方法。distinct（）使用hashCode（）和e...
JDK8 lambda 表达式 与 方法引用(Method References)
HeatDeath的博客
04-08 752
引用静态方法 ContainingClass::staticMethodName 例子: String::valueOf，对应的Lambda：(s) -&gt; String.valueOf(s) 比较容易理解，和静态方法调用相比，只是把.换为:: 引用特定对象的实例方法 containingObject::instanceMethodName 例子: x::toString...
jdk1.8 List接口默认方法说明
听说的专栏
01-01 773
int size(); 返回list的长度。 boolean isEmpty(); 判断list是否为空。 boolean contains(Object o); 判断list是否包含指定对象。 Iterator&lt;E&gt; iterator(); 以适当的顺序返回列表中元素的迭代器 Object[] toArray(); 将list中的元素以Object数组的形...
04.jdk1.8常用API
qq_34352643的博客
10-23 2313
tiltle：自编jdk1.8API常用文档(按功能划分) 1.输入 包 import java.util.Scanner; ----不是lang包就要导入 new Scanner scanner = new Scanner(System.in); next（）----获取 next()方法读取到空白符就结束； 输入： 返回：String scanner.next() nextLine（）—获取行 nextLine()读取到回车结束也就是“\r” 输入： 返回：String scanner..
JDK1.8常用api整理
好记性不如烂笔头
07-25 1782
jdk1.8处理一些常用需求的流式处理
JDK1.8 新特性之常用函数式接口
哇哇哇，真的学到了！！！
05-02 730
目录 常用4种函数式接口 Supplier接口 Consumer接口 Function接口 Predicate 接口 常用的函数式接口主要在java.util.function包下，函数式接口是Lambda表达式使用的前提，而Lambda表达式不关心接口名，抽象方法名，只关心抽象方法的参数列表和返回值类型，因此，为了让Lambda表达式使用更方便，jdk提供了大量函数式接口。(常用的接口：Supplier接口、Consumer接口、Function接...
JDK1.8 的常用的两个新特性
qq_34249468的博客
11-07 857
Lambda表达式以及stream 日常开发自己总结
Java 1.8 新特性之（Lambda表达式）
fanxiaobin
01-29 4221
译文原址：Lambda Expressions  前言：本人英语水平不高，在此翻译官网文章纯属个人兴趣，肯定有些翻译不合理的地方，请大家即使指出，万分感谢！！   One issue with anonymous classes(匿名类) is that if the implementation of your anonymous class is very simple, such as ...
Java学习笔记：基础数据类型与JDK1.8特性
文档描述“从Java基础的数据类型、jdk1.8_java-study”进一步说明了学习内容的范围，涵盖了Java基础中的核心概念——数据类型，以及特定版本的Java开发工具包（JDK），在这个案例中是JDK 1.8。 首先，让我们详细...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值