首页  思维导图  详情

Java8新特性

2022-01-13 14:37:35   0  举报





AI智能生成

详细简绍Java8新特性

java

作者其他创作

大纲/内容

简介

Oracle在2014年3月份发布了java8正式版，Java 8 (又称为 jdk 1.8)是Java发布以来改动最大的一个版本。

特点

速度更快

数据结构

jdk1.7

数组、链表（单项链表）

HashMap在jdk1.7中他的底层数据结构是数组+链表，最开始以数组结构进行存储数据，HashMap是以哈希值确认位置，HashMap的加载因子是0.75（当链表的长度达到75%的时候，HashMap会自动扩容，需要将链表中的所有数据的哈希值从新计算，从新放入相应的哈希值对应的位置。这里存在一个问题就是哈希碰撞，哈希值是会重复的，也就是说发生碰撞，那这个时候它会把老的值以链的形式缀在新值后面，形成一个链型结构，也就是链表。）

jdk1.8

数组、链表、红黑树（平衡二叉树）

HashMap在jdk1.8中底层数据结构是数组+链表+红黑树，相比于jdk1.7多了一个红黑树，首先最初的数据结构是数据，如发生哈希碰撞就会以链表的形式存储。jdk1.8在链表的碰撞数量大于8，HashMap总容量大于64的时候，那么就会将链表转换成红黑树，红黑树就像一个二分法，一直把这个列表一分二，二分四。这样的好处是插入的时候我不需要比较这个链表中所有的哈希值按照树形结构比较，如果比较相同，就向下比较，反之就挂在上一个碰撞的值下面。

在线演示红黑树

内存结构

里面直接用的就是物理内存，而不是你来分配内存了，这样垃圾回收机制就几乎不做回收了，虽然1.7里面方法区也一般不会被回收，但还是有一些被回收的情况，所以1.8直接优化了内存机制。

jvm

永久区

永久区是Hotspot虚拟机对方法区的具体实现，在jdk1.8被移除，取而代之是元空间

元空间

内存泄漏以及新类加载器的创建导致的，通常出现于代码热部署时。相对于正式产品，该问题在开发机上出现的频率更高，在产品中最常见的“问题”是默认值太低了。常用的解决方法是将其设置为256MB或更高。JDK8 HotSpot JVM 将移除永久区，使用本地内存来存储类元数据信息并称之为：元空间（Metaspace）。这意味着不会再有java.lang.OutOfMemoryError: PermGen问题，也不再需要你进行调优及监控内存空间的使用。

方法区

类变量

类加载器的引用

Class类的引用

方法信息

域信息

类型信息

代码更少

新添加的Stream API（java.util.stream）把真正的函数式编程风格引入到Java中。它可以让你以一种声明的方式处理数据，从而写出高效率、干净、简洁的代码。

强大的Stream API

Stream 不是集合元素，它不是数据结构并不保存数据，它是有关算法和计算的，它更像一个高级版本的 Iterator 。可以执行非常复杂的查找、过滤和映射数据等操作。

1.使用Stream，并不会直接进行计算，只会在结束操作的时候才会运算。这种特质叫惰性求值，流在中间处理过程中，只是对操作进行了记录，并不会立即执行，流传递的可以理解为逻辑。
2.不是数据结构，不会保存数据。
3.不会修改原本的数据源，而是会生成一个个新的数据源。

便于并行

通过图上的例子可以很好理解并行的运行速度是要比串行要快的

并行流就是把一个内容分成多个数据块，并用不同的线程分别处理每个数据块的流。Java 8 中将并行进行了优化，我们可以很容易的对数据进行并行操作。Stream API 可以声明性地通过 parallel() 与 sequential() 在并行流与顺序流之间进行切换。

最大化减少空指针异常Optional

OptionalAPI

String isocode = user.getAddress().getCountry().getIsocode().toUpperCase(); 代码中存在什么问题？

可能会存在空指针的情况，那么我们平常的代码如何去写

if (user != null) {
    Address address = user.getAddress();
    if (address != null) {
        Country country = address.getCountry();
        if (country != null) {
            String isocode = country.getIsocode();
            if (isocode != null) {
                isocode = isocode.toUpperCase();
            }
        }
    }
}

使用Optional代码示例

public static void main(String[] args) {
        //返回一个Optional实例
        /*Optional<User> optional1 = Optional.empty();
        System.out.println(optional1);*/

        /*Map map =new HashMap<>();
        map.put("key1",1);
        Optional<Object> optional2 = Optional.ofNullable(map);
        System.out.println(optional2);
        Map  optionalMap = (Map)optional2.get();
        System.out.println(optionalMap);*/

        /*User user = null;
        String str = Optional.ofNullable(user).map(User::getName).orElse(null);
        System.out.println(str);*/

    }

@Data
public class User {
private Integer id;
private String name;
}

新增特性

lambda表达式

Lambda 是一个匿名函数，我们可以把 Lambda表达式理解为是一段可以传递的代码（将代码像数据一样进行传递）。可以写出更简洁、更灵活的代码。作为一种更紧凑的代码风格，使Java的语言表达能力得到了提升。

//匿名内部类
public class demo {

    public static void main(String[] args) {
        ICacheService ic = new ICacheService() {
            @Override
            public void initDictCache() {
                System.out.println("这个一个匿名方法");
            }
        };
        ic.initDictCache();
    }
}

Lambda 表达式的基础语法 : Java8 中引入了一个新的操作符 "->" 该操作符称为箭头操作符或 Lambda 操作符，箭头操作符将 Lambda 表达式拆分成两部分 :
左侧 : Lambda 表达式的参数列表
右侧 : Lambda 表达式中所需执行的功能，即 Lambda 体

lambda特性示例

集合处理

循环差异

List

public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);
        //旧循环方式
        for (Integer integer : list) {
            System.out.println(integer);
        }
        //使用 lambda
        list.forEach(x-> System.out.println(x));
    }

Map

public static void main(String[] args) {
        Map<String,Object> map = new HashMap<>();
        map.put("key1","value1");
        map.put("key2","value2");
        map.put("key3","value4");
        map.put("key4","value4");
        map.put("key5","value5");
        //旧循环方式
        Set<String> keys = map.keySet();
        for (String key : keys) {
            System.out.println("key是"+key+"value"+map.get(key));
        }
        //使用 lambda
        map.forEach((k,v)-> System.out.println("key是"+k+"value"+v));
    }

过滤条件

public static void main(String[] args) {
        List list = new ArrayList<>();
        list.add("1");
        list.add("1");
        list.add("2");
        list.add("2");
        list.add("2");
        list.add("3");
        list.add("4");
        list.add("4");
        list.add("4");
        //我现在只要list中为2的
        //旧方式
        List<Object> listTwo = new ArrayList<>();
        for (Object obj : list) {
            if("2".equals(obj)){
                listTwo.add(obj);
            }
        }
        System.out.println(listTwo);
        //使用 lambda
        List<Object> objectList = (List<Object>) list.stream().filter(x -> x.equals("2")).collect(Collectors.toList());
        System.out.println(objectList);
    }

函数式接口

@FunctionalInterfac

//函数式接口就是定义一个抽象方法
public interface demo {
void NoReturnMultiParam();
}

虽然这个也是函数式接口，但是后续的人可以继续加抽象方法，那么这个就不是函数式接口

@FunctionalInterface
public interface demo {
void NoReturnMultiParam();
}

总结：就是在类上面添加注解，标注这个类只有一个抽象方法，再多就直接报红

Stream API

并行流和串行流的比较

串行流

long start = System.currentTimeMillis();
        long sum = 0L;
        for (long i = 0L; i <= 100; i++) {
            sum += i;
        }
        System.out.println(sum);
        long end = System.currentTimeMillis();
        System.out.println("耗费的时间为: " + (end - start)+"毫秒");

long start = System.currentTimeMillis();
        Long sum1 = LongStream.rangeClosed(0L, 100L)
                .sequential()//串行
                .reduce(0,Long::sum);
        System.out.println(sum1);
        long end = System.currentTimeMillis();
        System.out.println("耗费的时间为: " + (end - start)+"毫秒");

并行流

并行流就是把一个内容分成多个数据块，并用不同的线程分别处理每个数据块的流。串行流则相反，并行流的底层其实就是ForkJoin框架的一个实现。

long start = System.currentTimeMillis();
        Long sum1 = LongStream.rangeClosed(0L, 100L)
                .parallel()//并行
                .reduce(0,Long::sum);
        System.out.println(sum1);
        long end = System.currentTimeMillis();
        System.out.println("耗费的时间为: " + (end - start)+"毫秒");

接口增强

默认方法

在 java 8 之前，接口与其实现类之间的耦合度太高了（tightly coupled），当需要为一个接口添加方法时，所有的实现类都必须随之修改。默认方法解决了这个问题，它可以为接口添加新的方法，而不会破坏已有的接口的实现。

public interface demo {

default void test(){
//逻辑代码
};
}

静态方法

public interface demo {
    static void staticMethod(){
        System.out.println("我是静态方法");
    }
}

Optional类

新增时间日期API

//获取当前日期对象
        LocalDate now = LocalDate.now();
        System.out.println("今天的日期是:"+now);


        Date date = new Date();
        System.out.println("今天的日期是:"+date);

API