Java9 - Java11部分特性学习笔记

最新推荐文章于 2023-10-26 11:55:07 发布

心如镜止于水

最新推荐文章于 2023-10-26 11:55:07 发布

阅读量128

点赞数

分类专栏： JAVA 文章标签： java 开发语言后端

本文链接：https://blog.csdn.net/qq_37863891/article/details/121020767

版权

JAVA 专栏收录该内容

15 篇文章 0 订阅

订阅专栏

Java9部分特性

钻石操作符的升级

钻石操作符与匿名内部类在java 8中不能共存。在java9可以

    @Test
    public void test2() {
        //钻石操作符与匿名内部类在java 8中不能共存。在java9可以。
        Comparator<Object> com = new Comparator<>() {
            @Override
            public int compare(Object o1, Object o2) {
                return 0;
            }
        };
    }

try操作的升级

    //java9 特性六：try操作的升级
    public static void main(String[] args) {

//        java 8中资源关闭操作: Java 8 中，可以实现资源的自动关闭
//        要求自动关闭的资源的实例化必须放在try的一对小括号中
//        try(InputStreamReader reader = new InputStreamReader(System.in)){
//            char[] cbuf = new char[20];
//            int len;
//            if((len = reader.read(cbuf) )!= -1){
//                String str = new String(cbuf,0,len);
//                System.out.println(str);
//            }
//        } catch (IOException e) {
//            e.printStackTrace();
//        }

        //java9中资源关闭操作：需要自动关闭的资源的实例化可以放在try的一对小括号外。
        //此时的资源属性是常量，声明为final的，不可修改
        InputStreamReader reader = new InputStreamReader(System.in);
        try (reader) {
            char[] cbuf = new char[20];
            int len;
            if((len = reader.read(cbuf) )!= -1){
                String str = new String(cbuf,0,len);
                System.out.println(str);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

unmodifiableList与of

Collections::unmodifiable…创建一个不可修改的视图。它不是一成不变的，因为如果您要更改原始的后备集合（list在您的示例中），则它会更改。
…::of另一方面，创建一个不变的副本。更改原始列表不会影响它。

    @Test
    public void test2() {
        List<String> list = Collections.unmodifiableList(Arrays.asList("a", "b", "c"));
        Set<String> set = Collections.unmodifiableSet(new HashSet<>(Arrays.asList("a", "b", "c")));
        // 如下操作不适用于jdk 8 及之前版本,适用于jdk 9
        Map<String, Integer> map = Collections.unmodifiableMap(new HashMap<>() {
            {
                put("a", 1);
                put("b", 2);
                put("c", 3);
            }
        });
        map.forEach((k, v) -> System.out.println(k + ":" + v));

    }

    @Test
    public void test4() {
        List<Integer> list1 = List.of(1, 2, 3, 4, 5);
        //不能添加
//        list1.add(6);
        System.out.println(list1);

        Set<Integer> set1 = Set.of(23, 3, 54, 65, 43, 76, 87, 34, 46);
        //不能添加
//        set1.add(4);
        System.out.println(set1);

        Map<String, Integer> map1 = Map.of("Tom", 23, "Jerry", 54, "HanMeimei", 12);
        //不能添加
        //map1.put("Lilei",34);

        System.out.println(map1);

        Map<String, Integer> map2 = Map.ofEntries(Map.entry("Tom", 34), Map.entry("Jerry", 21));
//        map2.put("Lilei",34);
        System.out.println(map2);
    }

InputStream的新方法:tranferTo()

把输入流中的所有数据直接自动地复制到输出流中

    @Test
    public void test5() {
        ClassLoader cl = this.getClass().getClassLoader();
        try (InputStream is = cl.getResourceAsStream("hello.txt");
             OutputStream os = new FileOutputStream("src\\hello1.txt")) {
            is.transferTo(os); // 把输入流中的所有数据直接自动地复制到输出流中
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

Stream API的加强

方法	描述
takeWhile	返回从开头开始的按照指定规则尽量多的元素，碰到第一个不满足的时候终止
dropWhile	与 takeWhile 相反，返回剩余的元素
ofNullable	形参变量是可以为null值的单个元素
iterate(T seed, Predicate<? super T> hasNext,UnaryOperator next)	新增的重载的方法，新增了断言条件

@Test
public void test1(){
    List<Integer> list = Arrays.asList(23, 43, 45, 55, 61, 54, 32, 2, 45, 89, 7);
    //takeWhile 返回从开头开始的按照指定规则尽量多的元素
//        list.stream().takeWhile(x -> x < 60).forEach(System.out::println);
    //dropWhile():与 takeWhile 相反，返回剩余的元素。
    list.stream().dropWhile(x -> x < 60).forEach(System.out::println);
}

@Test
public void test2(){
    //of()参数中的多个元素，可以包含null值
    Stream<Integer> stream1 = Stream.of(1, 2, 3,null);
    stream1.forEach(System.out::println);
    //of()参数不能存储单个null值，但是of()可以存储多个null值。否则，报异常
//        Stream<Object> stream2 = Stream.of(null);
//        stream2.forEach(System.out::println);
    Integer i = 10;
    i = null;
    //ofNullable()：形参变量是可以为null值的单个元素
    Stream<Integer> stream3 = Stream.ofNullable(i);
    long count = stream3.count();
    System.out.println(count);
}

@Test
public void test3(){
    Stream.iterate(0,x -> x + 1).limit(10).forEach(System.out::println);
    //java9中新增的重载的方法
    Stream.iterate(0,x -> x < 100,x -> x + 1).forEach(System.out::println);
}

Optional提供了生成stream的方法

    @Test
    public void test4(){
        List<String> list = new ArrayList<>();
        list.add("Tom");
        list.add("Jerry");
        list.add("Tim");
        
        Optional<List<String>> optional = Optional.ofNullable(list);
        Stream<List<String>> stream = optional.stream();
        long count = stream.count();
        System.out.println(count);
        stream.flatMap(x -> x.stream()).forEach(System.out::println);
    }

Java10

局部类型推断

类似于C++中的auto，个人觉的既然IDEA代码补全功能很强大，为了可读性尽量还是写出类型。

@Test
public void test1() {
    //1.声明变量时，根据所附的值，推断变量的类型
    var num = 10;

    var list = new ArrayList<Integer>();
    list.add(123);

    //2.遍历操作
    for (var i : list) {
        System.out.println(i);
        System.out.println(i.getClass());
    }

    //3.普通的遍历操作
    for (var i = 0; i < 100; i++) {
        System.out.println(i);
    }
}

集合中新增方法copyOf()

用于创建一个只读的集合,copyOf(Xxx coll):如果参数coll本身就是一个只读集合，则copyOf()返回值即为当前的coll，如果参数coll不是一个只读集合，则copyOf()返回一个新的集合，这个集合是只读的。

    @Test
    public void test5(){
        var list1 = List.of("Java", "Python", "C");
        var copy1 = List.copyOf(list1);
        System.out.println(list1 == copy1); // true

        var list2 = new ArrayList<String>();
        list2.add("aaa");
        var copy2 = List.copyOf(list2);
        System.out.println(list2 == copy2); // false
    }

Java11

String新增方法

    @Test
    public void test1(){
//        isBlank():判断字符串是否为空白，空白是指制表符，不单单空格
        System.out.println("  \t  \t  \n  ".isBlank());
//        strip():去除首尾空白
        System.out.println("-----" + "  \t abc \t  \n  ".strip() + "-------"); //-----abc-------
        System.out.println("-----" + "  \t abc \t  \n  ".trim() + "-------"); // -----abc-------
//        stripTrailing():去除尾部空格
        System.out.println("-----" + "  \t abc \t  \n  ".stripTrailing() + "-------");// -----  	 abc-------
//        stripLeading():去除首部空格
        System.out.println("-----" + "  \t abc \t  \n  ".stripLeading() + "-------");
//        repeat(int count):复制字符串
        String str1 = "abc";
        String str2 = str1.repeat(5);
        System.out.println(str2);                // abcabcabcabcabc
//        lines().count():行数统计
        String str3 = "abc\ndef\ng";
        System.out.println(str3.lines().count()); // 3
    }

Optional新增的方法

方法	描述
isPresent	判断内部的value是否存在
isEmpty	判断内部的value是否为空
orElseThrow()	value非空，返回value；否则抛异常NoSuchElementException
or()	value非空，返回对应的Optional；value为空，返回形参封装的Optional

    @Test
    public void test2(){
        var op = Optional.empty();
        System.out.println(op.isPresent());
        System.out.println(op.isEmpty());

        op = Optional.of("abc");
        var obj = op.orElseThrow();
        System.out.println(obj);

        Optional<String> op1 = Optional.of("hello");
//        op = Optional.empty();
        Optional<Object> op2 = op.or(() -> op1);
        System.out.println(op2);//
    }

HttpClient类

替换原有的HttpURLConnection。

public void test4(){
    try {
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder(URI.create("http://127.0.0.1:8080/test/")).build();
        HttpResponse.BodyHandler<String> responseBodyHandler = HttpResponse.BodyHandlers.ofString();
        HttpResponse<String> response = client.send(request, responseBodyHandler);
        String body = response.body();
        System.out.println(body);
    } catch (IOException e) {
        e.printStackTrace();
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

心如镜止于水

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java9 - Java11部分特性学习笔记

Java9部分特性钻石操作符的升级钻石操作符与匿名内部类在java 8中不能共存。在java9可以 @Test public void test2() { //钻石操作符与匿名内部类在java 8中不能共存。在java9可以。 Comparator<Object> com = new Comparator<>() { @Override public int compare(Obj
复制链接

扫一扫