zoukankan      html  css  js  c++  java
  • 96.java基础10(java9/10/11新特性)

    126.java 9 新特性1(模块化功能):

    1.java模块化
    2.java 交互式环境jshell
    3.泛型
        
    package com.atguigu.java;
    import org.junit.Test;
    import java.io.IOException;
    import java.io.InputStreamReader;
    import java.net.MalformedURLException;
    import java.net.URL;
    import java.util.ArrayList;
    import java.util.Comparator;
    /**
     * @author shkstart
     * @create 2019 下午 2:20
     */
    public class Java9Test {
        //
        @Test
        public void test1() {
            try {
                URL url = new URL("http://www.atguigu.com");
            } catch (MalformedURLException e) {
                e.printStackTrace();
            }
        }
        //java9特性五:钻石操作符的升级
        @Test
        public void test2() {
            //钻石操作符与匿名内部类在java 8中不能共存。在java9可以。
            Comparator<Object> com = new Comparator<>() {
                @Override
                public int compare(Object o1, Object o2) {
                    return 0;
                }
            };
            //jdk7中的新特性:类型推断
            ArrayList<String> list = new ArrayList<>();
        }
        //java9 特性六:try操作的升级
        public static void main(String[] args) {
            //java 8之前的资源关闭的操作
    //        InputStreamReader reader = null;
    //        try {
    //            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();
    //        } finally {
    //            if(reader != null){
    //                try {
    //                    reader.close();
    //                } catch (IOException e) {
    //                    e.printStackTrace();
    //                }
    //
    //            }
    //        }
            //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);
                }
    //            reader = null;
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    

    127.java 9 新特性2(异常以及资源关闭):

    4.关于资源关闭在异常中的变化
    5.String, StringBuffer, StringBuilder 底层有char[]变为byte[]
    6.集合工厂:创建只读集合
    7.inputStream 加强
    ----------------------------------------------------------------------------------------    
    package com.atguigu.java;
    import org.junit.Test;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.OutputStream;
    import java.util.*;
    /**
     * @author shkstart
     * @create 2019 下午 3:12
     */
    public class Java9Test1 {
        //java8中的写法:
        @Test
        public void test1() {
            List<String> namesList = new ArrayList<>();
            namesList.add("Joe");
            namesList.add("Bob");
            namesList.add("Bill");
            //返回的namesList是一个只读的集合
            namesList = Collections.unmodifiableList(namesList);
            namesList.add("Tom");
            System.out.println(namesList);
        }
        @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 test3() {
            //此时得到的集合list也是一个只读集合。
            List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
            //报异常
            list.add(6);
        }
        //java9新特性八:集合工厂方法:创建只读集合
        @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);
        }
        //java9新特性九: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();
            }
        }
    }
    

    128.java 9 新特性3StreamApi 加强:

    8.StreamApi 加强
    9.StreamApi iterate重载 
    10.Optinal 增加Stream方法
    ---------------------------------------------------------------------------------------- 
    package com.atguigu.java;
    import org.junit.Test;
    import java.util.ArrayList;
    import java.util.Arrays;
    import java.util.List;
    import java.util.Optional;
    import java.util.stream.Stream;
    /**
     * @author shkstart
     * @create 2019 下午 3:32
     */
    public class Java9Test2 {
        //java9新特性十:Stream API的加强
        @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值。否则,报异常
    //        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);
        }
        //java9新特性十一: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);
        }
    }
    

    129.java 10 新特性:

    1.局部变量类型推断 ***
    2.增强创建不可变集合
    ---------------------------------------------------------------------------------------- 
    package com.atguigu.java1;
    import org.junit.Test;
    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStreamReader;
    import java.net.URL;
    import java.util.ArrayList;
    import java.util.List;
    /**
     * @author shkstart
     * @create 2019 下午 4:24
     */
    public class Java10Test {
        /*
        java10新特性一:局部变量的类型推断
         */
        @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);
            }
        }
        @Test
        public void test2() {
            //1.局部变量不赋值,就不能实现类型推断
    //        var num ;
            //2.lambda表示式中,左边的函数式接口不能声明为var
    //        Supplier<Double> sup = () -> Math.random();
    //        var sup = () -> Math.random();
            //3.方法引用中,左边的函数式接口不能声明为var
    //        Consumer<String> con = System.out::println;
    //        var con = System.out::println;
            //4.数组的静态初始化中,注意如下的情况也不可以
            int[] arr = {1, 2, 3, 4};
    //        var arr = {1,2,3,4};
        }
        @Test
        public void test3() {
    //        情况1:没有初始化的局部变量声明
    //        var s = null;
    //        情况6:catch块
    //        try{
    //
    //        }catch(var e){
    //            e.printStackTrace();
    //        }
        }
        //情况2:方法的返回类型
    //    public var method1(){
    //
    ////        return 0;
    //    }
        // 情况3:方法的参数类型
    //    public void method2(var num){
    //
    //    }
        //情况4:构造器的参数类型
    //    public Java10Test(var i){
    //
    //    }
        //情况5:属性
    //    var num;
        @Test
        public void test4() {
            try {
                var url = new URL("http://www.atguigu.com");
                var connection = url.openConnection();
                var reader = new BufferedReader(
                        new InputStreamReader(connection.getInputStream()));
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        //java10的新特性二:集合中新增的copyOf(),用于创建一个只读的集合
        @Test
        public void test5(){
            //示例1:
            var list1 = List.of("Java", "Python", "C");
            var copy1 = List.copyOf(list1);
            System.out.println(list1 == copy1); // true
            //示例2:
            var list2 = new ArrayList<String>();
            list2.add("aaa");
            var copy2 = List.copyOf(list2);
            System.out.println(list2 == copy2); // false
            //示例1和2代码基本一致,为什么一个为true,一个为false?
            //结论:copyOf(Xxx coll):如果参数coll本身就是一个只读集合,则copyOf()返回值即为当前的coll
            //如果参数coll不是一个只读集合,则copyOf()返回一个新的集合,这个集合是只读的。
        }
    }
    

    130java 11 新特性:

    1.String中新增方法
    2.Optional加强
    3.局部推断的类型推断升级
    4.http客户端api
    5.简化的编译运行文件
    6.废弃Nashorn引擎
    7.ZGC
    ---------------------------------------------------------------------------------------- 
    package com.atguigu.java2;
    import org.junit.Test;
    import java.io.IOException;
    import java.net.URI;
    import java.net.http.HttpClient;
    import java.net.http.HttpRequest;
    import java.net.http.HttpResponse;
    import java.util.Optional;
    import java.util.concurrent.CompletableFuture;
    import java.util.function.Consumer;
    /**
     * @author shkstart
     * @create 2019 下午 5:09
     */
    public class Java11Test {
        //java 11新特性一:String中新增的方法
        @Test
        public void test1(){
    //        isBlank():判断字符串是否为空白
            System.out.println("  	  	  
      ".isBlank());
    //        strip():去除首尾空白
            System.out.println("-----" + "  	 abc 	  
      ".strip() + "-------");
            System.out.println("-----" + "  	 abc 	  
      ".trim() + "-------");
    //        stripTrailing():去除尾部空格
            System.out.println("-----" + "  	 abc 	  
      ".stripTrailing() + "-------");
    //        stripLeading():去除首部空格
            System.out.println("-----" + "  	 abc 	  
      ".stripLeading() + "-------");
    //        repeat(int count):复制字符串
            String str1 = "abc";
            String str2 = str1.repeat(5);
            System.out.println(str2);
    //        lines().count():行数统计
            String str3 = "abc
    def
    g";
            System.out.println(str3.lines().count());
        }
        //java11新特性二:Optional新增的方法
        @Test
        public void test2(){
            var op = Optional.empty();
            System.out.println(op.isPresent());//判断内部的value是否存在
            System.out.println(op.isEmpty());//判断内部的value是否为空
            op = Optional.of("abc");
            //orElseThrow():value非空,返回value;否则抛异常NoSuchElementException
            var obj = op.orElseThrow();
            System.out.println(obj);
            Optional<String> op1 = Optional.of("hello");
    //        op = Optional.empty();
            //or:value非空,返回对应的Optional(op);value为空,返回形参封装的Optional(op1)
            Optional<Object> op2 = op.or(() -> op1);
            System.out.println(op2);//
        }
        //java11新特性三:局部变量类型推断的升级
        @Test
        public void test3(){
            //错误的形式: 必须要有类型, 可以加上var
    //        Consumer<String> con1 = (@Deprecated t) -> System.out.println(t.toUpperCase());
            // 正确的形式:
            // 使用var的好处是在使用lambda表达式时给参数加上注解。
             Consumer<String> con2 = (@Deprecated var t) -> System.out.println(t.toUpperCase());
        }
        //java11新特性四:HttpClient替换原有的HttpURLConnection。
        @Test
        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();
            }
        }
        @Test
        public void test5(){
            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();
            CompletableFuture<HttpResponse<String>> sendAsync = client.sendAsync(request, responseBodyHandler);
            sendAsync.thenApply(t -> t.body()).thenAccept(System.out::println);
            //HttpResponse<String> response = sendAsync.get();
            //String body = response.body();
            //System.out.println(body);
        }
    }
    
  • 相关阅读:
    bash 中的 ; && 与|| 的作用
    远程root用户无法登陆
    MySQL5.6主从同步(热备份)
    进程之间的通信方式
    远程连接openGuass配置
    openGuass1.1.0部署
    Go同步原语
    spring boot集成activiti6
    解决默认的jackson序列化循环引用的问题
    spring boot集成websocket
  • 原文地址:https://www.cnblogs.com/liuzhanghao/p/13683927.html
Copyright © 2011-2022 走看看