iterator java增加 java新增

目录

• 一、集合 增强

• 1.1、List集合 of()方法
• 1.2、Set集合 of()方法
• 1.3、Map集合 of()方法
• 1.4、List集合copyOf()方法
• 1.5、of()和copyOf()方法创建集合的注意事项

• 二、Stream 增强

• 2.1、Stream 新增of()方法
• 2.2、Stream 新增ofNullable()方法
• 2.3、Stream 新增takeWhile() 和 dropWhile()方法

• 2.3.1、Stream中takeWhile() 方法示例
• 2.3.2、Stream中dropWhile() 方法示例

• 2.4、Stream 新增iterate()重载方法

• 三、增加了一系列的字符串处理方法

• 3.1、判断字符串是否为空白
• 3.2、去除字符串首尾空白
• 3.3、去除字符串尾部空白
• 3.4、去除字符串首部空白
• 3.5、复制字符串
• 3.6、行数统计

• 四、Optional 加强

• 4.1、Optional.of()方法中如果传入的参数是null, 会抛出空指针异常
• 4.2、Optional.ofNullable()可以兼容空指针, 但是实际传入null后要小心
• 4.3、Optional.orElse() 如果内部引用为空, 则返回参数中的引用,否则返回内部引用
• 4.4、optional.orElseThrow() 传入null后 抛异常

一、集合 增强

概述：自 Java 9 开始，Jdk 里面为集合（List/ Set/ Map）都添加了 of 和 copyOf 方法，它们两个都用来创建不可变的集合，

1.1、List集合 of()方法

• of方法往List集合添加元素，示例如下：

import java.util.List;
public class Test1 {
    public static void main(String[] args) {
        t1();
    }
	/**
     * list集合 ，往list集合添加元素
     * */
    public static void t1(){
        var list = List.of("a", "b", "c");
        System.out.println(list);

        list.add("d");//不可以添加元素
        System.out.println(list);
    }
}

• 输出结果如下：

1.2、Set集合 of()方法

• of方法往Set集合添加元素，示例如下：

import java.util.Set;
public class Test1 {
    public static void main(String[] args) {
        t2();
    }
	/**
     * set集合 ，往set集合添加元素
     * */
    public static void t2(){
        var set1 = Set.of("a", "b", "c");
        System.out.println("添加的集合元素："+set1);
        System.out.println("所属的类信息："+set1.getClass());
        //添加重复元素时，不是无法添加，而是抛出异常
        var set = Set.of("a", "b", "c","c");
        System.out.println(set);
    }
}

• 输出结果如下：

1.3、Map集合 of()方法

• of方法往Map集合添加元素，示例如下：

import java.util.Set;
public class Test1 {
    public static void main(String[] args) {
        t3();
    }
	/**
    * map集合
    * */
   public static void t3(){
       var map = Map.of("key1", "value1","key2","value2");
       System.out.println("添加的集合元素："+map);
       System.out.println("所属的类信息："+map.getClass());
   }
}

• 输出结果如下：

1.4、List集合copyOf()方法

• copyOf()方法复制集合元素，示例如下：

import java.util.*;
public class Test1 {
    public static void main(String[] args) {
        t4();
    }
	/**
    * List集合copyOf()方法
    * */
   public static void t4(){
   	   //示例1
       var list = List.of("a", "b", "c");
       var copy  = List.copyOf(list);
       System.out.println(list == copy); // true
       //示例2
       var list1 = new ArrayList<String>();
       var copy1 = List.copyOf(list);
       System.out.println(list1 == copy1); // false
   }
}

• 输出结果如下：
• 示例1和2代码差不多，为什么一个为true,一个为false?
  由下图源码可以看出 copyOf 方法会先判断来源集合是不是 AbstractImmutableList 类型的，如果是，就直接返回，如果不是，则调用 of 创建一个新的集合。



• 示例2因为用的 new 创建的集合，不属于不可变 AbstractImmutableList 类的子类，所以 copyOf 方法又创建了一个新的实例，所以为false.

1.5、of()和copyOf()方法创建集合的注意事项

• 使用of和copyOf创建的集合为不可变集合，不能进行添加、删除、替换、排序等操作，不然会报 java.lang.UnsupportedOperationException 异常。

二、Stream 增强

概述：Stream 是 Java 8 中的新特性，Java 9 开始对 Stream 增加了以下 4 个新方法。
（1）、增加of()方法
（2）、增加单个参数构造方法，可为null
（3）、增加 takeWhile() 和 dropWhile()方法
（4）、iterate重载

2.1、Stream 新增of()方法

• of()方法往Stream 流中新增元素，代码示例：

package com.xz.jdk11.day1;
import java.util.stream.Stream;
public class Test2 {
    public static void main(String[] args) {
        t1();
    }
    public static void t1(){
        //Stream流中添加元素
        Stream<String> stream = Stream.of("a","b","c");
        stream.forEach(System.out::println);
    }
}

• 输出结果如下：

2.2、Stream 新增ofNullable()方法

• Stream 中of()方法传入null，会被解析为是一个数组对象，会进一步访问它的长度信息。报空指针异常。示例代码如下：

package com.xz.jdk11.day1;
import java.util.stream.Stream;
public class Test2 {
    public static void main(String[] args) {
        t2();
    }
    /**
     * Stream流操作
     * */
    public static void t2(){
        //Stream流中of()传入null，会被解析为是一个数组对象，会进一步访问它的长度信息
        Stream<String> stream = Stream.of(null);
        stream.forEach(System.out::println);
    }
}

• 输出结果如下：



• Stream流中可以使用ofNullable传入null来创建流对象。示例代码如下：

package com.xz.jdk11.day1;
import java.util.stream.Stream;
public class Test2 {
    public static void main(String[] args) {
        t2();
    }

    /**
     * Stream流操作
     * */
    public static void t2(){
        //Stream流中可以使用ofNullable传入null来创建流对象
        Stream<String> stream = Stream.ofNullable(null);
        stream.forEach(System.out::println);
    }
}

• 输出结果如下：

2.3、Stream 新增takeWhile() 和 dropWhile()方法

2.3.1、Stream中takeWhile() 方法示例

• 示例代码

package com.xz.jdk11.day1;
	import java.util.stream.Stream;
	public class Test2 {
	    public static void main(String[] args) {
	        t4();
	    }
	
	    /**
	     * Stream流操作
	     * */
	     public static void t4() {
        //从流中一直获取判定器为n < 3 的元素，一旦遇到元素 >3,就终止处理
        Stream<Integer> stream = Stream.of(1, 2, 3, 2, 1);
        Stream<Integer> stream2 = stream.takeWhile(n -> n < 3);
        stream2.forEach(System.out::println);
    }
	}

• 输出结果如下：

2.3.2、Stream中dropWhile() 方法示例

• 示例代码

package com.xz.jdk11.day1;
import java.util.stream.Stream;
public class Test2 {
    public static void main(String[] args) {
        t5();
    }

    /**
     * Stream流操作
     * */
    public static void t5() {
        //从流中一直获取判定器为n < 3 不成立就开始计算
        Stream<Integer> stream = Stream.of(1, 2, 3, 2, 1);
        Stream<Integer> stream2 = stream.dropWhile(n -> n < 3);
        stream2.forEach(System.out::println);
    }
}

• 输出结果如下：

2.4、Stream 新增iterate()重载方法

• 无限流的示例代码

package com.xz.jdk11.day1;
import java.util.stream.Stream;
public class Test2 {
    public static void main(String[] args) {
        t6();
    }
    /**
     * Stream流操作
     * */
    public static void t6() {
        //无限流
        Stream<Integer> stream1 = Stream.iterate(1, t->(2*t)+1);
        //因为是无限流，即无限制的计算，因此通过limit()方法去限制输出结果
        stream1.limit(10).forEach(System.out::println);
    }
}

• 输出结果如下：



• 有限流的示例代码

package com.xz.jdk11.day1;
import java.util.stream.Stream;
public class Test2 {
    public static void main(String[] args) {
        t7();
    }
    /**
     * Stream流操作
     * */
     public static void t7() {
       //有限流，通过iterate()方法中第二个参数判定器指定什么时候结束迭代
       Stream<Integer> stream2 = Stream.iterate(1, t->t<20,t->(2*t)+1);
       stream2.forEach(System.out::println);
   }
}

• 输出结果如下：

三、增加了一系列的字符串处理方法

3.1、判断字符串是否为空白

• 示例代码

public class Test3 {
    public static void main(String[] args) {
        t1();
    }
    /**
     * 判断字符串是否为空白
     * */
    public static void t1(){
        String str=" \t \r \n";
        boolean b = str.isBlank();
        System.out.println("判断字符串是否为空白:"+b);
    }
}

• 输出结果如下：

3.2、去除字符串首尾空白

• 示例代码

public class Test3 {
    public static void main(String[] args) {
        t2();
        t3();
    }
     /**
     * 去除字符串首尾空白,包括英文和其他所有语言中的空白字符
     * */
    public static void t2(){
        String string = " \t  \r\n abc \t　";
        String string2 = string.strip(); 
        System.out.println("去除首尾空白的字符串="+string2);
        System.out.println("去除首尾空白的字符串长度="+string2.length());


    }

    /**
     * 去除字符串首尾空白，只能去除码值小于等于32的空白字符
     * */
    public static void t3(){
        String string = " \t  \r\n abc \t　";
        String string3 = string.trim(); 
        System.out.println("去除首尾空白的字符串="+string3);
        System.out.println("去除首尾空白的字符串长度="+string3.length());
    }
}

• 输出结果如下：

3.3、去除字符串尾部空白

• 示例代码

public class Test3 {
    public static void main(String[] args) {
        t4();
    }
    /**
     * 去除字符串尾部空白
     * */
    public static void t4(){
        String string=" \t \r\n abc \t ";
        String s = string.stripTrailing();
        System.out.println("去除字符串尾部空白的字符串="+s);
        System.out.println("去除字符串尾部空白的字符串长度="+s.length());
    }
}

• 输出结果如下：

3.4、去除字符串首部空白

• 示例代码

public class Test3 {
    public static void main(String[] args) {
        t5();
    }
    /**
     * 去除字符串首部空白
     * */
    public static void t5(){
        String string = " \t  \r\n abc \t　";
        String s = string.stripLeading();
        System.out.println("去除字符串首部空白的字符串="+s);
        System.out.println("去除字符串首部空白的字符串长度="+s.length());
    }
}

• 输出结果如下：

3.5、复制字符串

• 示例代码

public class Test3 {
    public static void main(String[] args) {
        t6();
    }
     /**
     * 复制字符串
     * */
    public static void t6(){
        String string = "abcd";
        String s = string.repeat(5);
        System.out.println("复制字符串="+s);
        System.out.println("复制字符串的长度="+s.length());
    }
}

• 输出结果如下：

3.6、行数统计

• 示例代码

public class Test3 {
    public static void main(String[] args) {
        t7();
    }
    /**
     * 行数统计
     * */
    public static void t7(){
        String string = "abcd\n" +
                "abcd";
        System.out.println("行数="+string.lines().count());
        string.lines().forEach(System.out::println);
    }
}

• 输出结果如下：

四、Optional 加强

Opthonal 也增加了几个非常酷的方法，现在可以很方便的将一个 Optional 转换成一个 Stream, 或者当一个空 Optional 时给它一个替代的。

4.1、Optional.of()方法中如果传入的参数是null, 会抛出空指针异常

• 示例代码

import java.util.Optional;
public class Test4 {
    public static void main(String[] args) {
        t1();
    }

    /**
     * Optional.of()方法中如果传入的参数是null, 会抛出空指针异常
     * */
    public static void t1(){
        Optional<String> optional = Optional.of(null);
    }
}

• 输出结果如下：

4.2、Optional.ofNullable()可以兼容空指针, 但是实际传入null后要小心

• 示例代码

import java.util.Optional;
public class Test4 {
    public static void main(String[] args) {
        t2();
    }

    /**
     * Optional.ofNullable()可以兼容空指针, 但是实际传入null后要小心
     * */
    public static void t2(){
        // optional.ofNullable可以兼容空指针, 但是实际传入null后要小心
        Optional<Object> optional = Optional.ofNullable(null);
    }
}

• 输出结果如下：

4.3、Optional.orElse() 如果内部引用为空, 则返回参数中的引用,否则返回内部引用

• 示例代码

import java.util.Optional;
public class Test4 {
    public static void main(String[] args) {
        t3();
    }

     /**
     * Optional.orElse() 如果内部引用为空, 则返回参数中的引用,否则返回内部引用
     * */
    public static void t3(){
        // optional.ofNullable可以兼容空指针, 但是实际传入null后要小心
        Optional<Object> optional = Optional.ofNullable(null);
        // optional.orElse()方法 如果内部引用为空, 则返回参数中的引用 即abd
        Object object = optional.orElse("abc");
        System.out.println("返回参数中的引用=="+object);

        // optional.ofNullable可以兼容空指针, 但是实际传入null后要小心
        Optional<Object> optional1 = Optional.ofNullable("123");
        // optional.orElse()方法 如果内部引用不为空, 否则返回内部引用 即123
        Object object1 = optional1.orElse("abc");
        System.out.println("返回内部引用=="+object1);
    }
}

• 输出结果如下：

4.4、optional.orElseThrow() 传入null后 抛异常

• 示例代码

import java.util.Optional;
public class Test4 {
    public static void main(String[] args) {
        t4();
    }

    /**
     *  optional.orElseThrow() 传入null后 抛异常
     * */
    public static void t4(){
        // optional.ofNullable可以兼容空指针, 但是实际传入null后要小心
        Optional<Object> optional = Optional.ofNullable(null);
        // optional.orElseThrow()方法 如果内部引用为空, 则抛异常
        Object object = optional.orElseThrow();
        System.out.println("抛异常=="+object);
    }
}

• 输出结果如下：