关于java:Java基础16不可变集合Stream流和异常

38次阅读

共计 5587 个字符，预计需要花费 14 分钟才能阅读完成。

不能够扭转的汇合，在整个应用的生命周期中，自创立后汇合就不变，尝试批改会报错
。实现的起因，更好的进攻和被不信赖库调用时，不可变的模式会更平安。

在 List、Set 和 Map 这些接口中都提供了静态方法 of 来进行创立，创立出的汇合不可修
改、新增和删除。

public class Demo {public static void main(String[] args) {
        // 创立不可变 List
        List<Integer> lisOf = List.of(1, 2, 3, 4);
        // 只能够获取，不能够删，改和增
        System.out.println(lisOf.get(0));

        // 2、不可变的 Set 汇合,jdk 版本须要高于 8
        // Set<String> names = Set.of("迪丽热巴", "迪丽热九", "马尔扎哈", "卡尔眨巴");
        // names.add("三少爷");
        // System.out.println(names);

        // 3、不可变的 Map 汇合,jdk 版本须要高于 8
        // Map<String, Integer> maps = Map.of("huawei",2, "Java 开发", 1 , "手表", 1);
        // maps.put("衣服", 3);
        // System.out.println(maps);

    }
}

在 JDK8 之后，得益于 Lambda 表达式的函数式编程，引入了 Stream 流。它简化了汇合
和数值的操作。

// 示例
public class StreamTest {public static void main(String[] args) {ArrayList<String> arrayList = new ArrayList<>();
        Collections.addAll(arrayList, "李小龙", "成龙", "李连杰", "李莲英", "叶问", "沈腾");

        // 传统办法
        System.out.println("传统办法");
        for (int i = 0; i < arrayList.size(); i++) {String s = arrayList.get(i);
            if (s.startsWith("李") && s.length() >= 3) {System.out.println(s);
            }
        }

        // Stream 流办法
        System.out.println("Stream 流形式");
        Stream<String> stream = arrayList.stream();
        stream.filter(s -> s.startsWith("李")).filter(s -> s.length() >= 3).forEach(s -> System.out.println(s));
    }
}

流在应用过胜利，总共有三个阶段：

取得流：取得操作汇合和数值的 ’ 流水线 ’
两头操作：相似 ’ 流水线 ’ 上的操作，操作之后还能够持续前面的操作
终结办法：一个流水线只有一个终结办法，此办法一旦执行，流水线就会进行。

取得数组和汇合的 Stream 流

取得汇合流

// 在汇合中 Collection 默认办法，此办法 1.8 之后退出
default Stream<E> stream()

public class StreamDemo1 {public static void main(String[] args) {ArrayList<String> list = new ArrayList<>();
        HashSet<String> set = new HashSet<>();
        HashMap<Object, Object> map = new HashMap<>();
        
        // 取得汇合 Stream 流
        Stream<String> stream = list.stream();
        Stream<String> stream1 = set.stream();
        Stream<Object> stream2 = map.keySet().stream();
        Stream<Object> stream3 = map.values().stream();
    }
}

取得数组流

public class StreamDemo2 {public static void main(String[] args) {String[] str = {"张三", "李四", "王二"};

     // 取得数组流
     Stream<String> stream1 = Arrays.stream(str);
     Stream<String> stream2 = Stream.of("张三", "李四", "王二");
 }
}

// 罕用办法

// 去除流中反复元素
Stream<T> distinct()
// 获取流前指定元素
Stream<T> limit(long maxSize)
// 跳过指定元素
Stream<T> skip(long n)
// 过滤流指定数据
Stream<T> filter(Predicate<? super T> predicate)
// 合并两个流
static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b)
// 对流进行加工 
<R> Stream<R> map(Function<? super T,? extends R> mapper)

// 示例
public class StreamDemo3 {public static void main(String[] args) {
        // 创立数组
        Integer[] x = {0, 1, 3, 5, 7, 9, 11}, y = {9, 2, 4, 6, 8};

        // 创立数组流
        Stream<Integer> x1 = Stream.of(x);
        Stream<Integer> y1 = Stream.of(y);

        Stream<Integer> concat = Stream.concat(x1, y1);
        // 跳过前 4 个、取前 6 个、过滤数值大于等于 5、去重和后果值乘 10，而后打印流内容完结
        concat.skip(4).limit(6)
                .filter(i -> i >= 5)
                .distinct()
                .map(i -> i * 10)
                .forEach(i -> System.out.println(i));
    }
}

以上办法为非终结办法，操作流后不会被敞开，流反对链式编程
在 Stream 流中无奈批改汇合或者数组数据，然而能够通过相似 map 办法进行加工

能够通过终结办法终结流的操作，非终结办法能够持续链式操作，终结办法不反对。

// 罕用办法

// 循环流元素
void forEach(Consumer<? super T> action)
// 统计流大小
long count()

一些操作后须要取得流中数据，转换成汇合或数组。

// 罕用办法

// 转换成数组
<A> A[] toArray(IntFunction<A[]> generator)
// 转换成汇合 
<R,A> R collect(Collector<? super T,A,R> collector)

public class StreamDemo3 {public static void main(String[] args) {
        // 创立数组
        Integer[] x = {0, 1, 3, 5, 7, 9, 11, 9, 2, 4, 6, 8};

        // 取得流
        Stream<Integer> stream = Arrays.stream(x);
        // 流转换成 List 汇合
        List<Integer> list = stream.filter(i -> i >= 5).collect(Collectors.toList());
        // 流转换成 Set 汇合
        Set<Integer> set = stream.collect(Collectors.toSet());
        // 流转换成数组
        Integer[] array = stream.toArray(value -> new Integer[0]);
    }
}

异样是程序在 ’ 执行 ’ 或 ’ 编译 ’ 期呈现的问题，比方越界和空指针问题。一旦出现异常
jvm 就会退出执行，所有要提前解决异样，减少程序健壮性和安全性。

异样体系次要如下：

Error：零碎级别异样，代码无序管制
Excrption：
- RuntimeException 及其子类：运行时异样，编译时不会。
- 除以上异样：编译时异样，必须解决否则程序编译不通过，程序无奈进行运行

程序编写在后缀为 java 的文件中 -> 应用 javac 命令编译文件成 class（有编译异
常此时将不会通过）-> 应用 java 命令运行字节码文件（如果程序有运行时异样将
终止程序报错）-> 运行完结

程序会在出现异常的中央，默认创立一个异样对象：ArithmeticException
从出现异常的地点将异样抛给调用者，调用者抛给 jvm 虚拟机
虚拟机在接管到异样后，将在管制台上显示异样信息
从出现异常地点将程序终止

这种解决是被动的，出现异常程序就完结。

此种办法是把可能呈现的异样抛给调用者

// 格局一
修饰符 返回值 办法(形参列表) throws 异样类名{
}

// 格局二 
throw new 异样类名(实参);

此种办法是捕捉可能呈现的异样，如果出现异常，程序猿能够本人解决。

// 格局一
try{...} catch (异样类 变量名) {...}

// 格局二
try{...} catch (异样类 变量名 1) {...} catch (异样类 变量名 2) {...}

// 格局二
try{...} catch (异样类 变量名 1) {...} finally {...}

public class TrcatchTest {public static void main(String[] args) {
        try {int x = 1 / 0;} catch (Exception e) {
            // 取得异样信息
           System.out.println("异样信息：" + e.getMessage());
           // 解决异样代码
        }
        System.out.println("持续前面的的操作...");
    }
}

public class TrcatchTest1 {public static void main(String[] args) {
      try {int x = 1 / 0;} catch (Exception e) {
         // 取得异样信息
         System.out.println("异样信息：" + e.getMessage());
         // 解决异样代码
      }finally {System.out.println("这个程序始终会执行");
      }
      System.out.println("持续前面的的操作...");
   }
}

可本人抛出异样，而后本人捕捉异样解决。这样就能够个体解决异样。

// 示例
public class TrcatchTest2 {public static void main(String[] args) {
      try {exceptionTest();
      } catch (Exception e) {
         // 上面是默认解决异样的办法
         // e.printStackTrace();
         System.out.println(e.getMessage());
      }
   }

   // 将异样抛出去
   public static void exceptionTest() throws Exception {
      // 伪装出现异常
      throw new Exception("出现异常");
   }
}

程序不可能把全副异样创立出，这时咱们就要个性化创立异样。这样的话出现异常，
因为是自定义异样，所有异样解决较好。

继承 Exception
重写结构器
在出现异常中央 throw new 异样类(实参)

// 示例
public class ExceptioTest extends Exception {public ExceptioTest() { }
   public ExceptioTest(String message) {super(message);
   }
}

public class TrcatchTest3 {public static void main(String[] args) {
      try {exceptionTest();
      } catch (Exception e) {
         // 上面是默认解决异样的办法
         // e.printStackTrace();
         System.out.println(e.getMessage());
      }
   }
   public static void exceptionTest() throws Exception {
      // 伪装出现异常
      throw new ExceptioTest("出现异常");
   }
}

继承 RuntimeException
重写结构器
在出现异常中央 throw new 异样类(实参)

public class RuntimeExceptionTest extends RuntimeException {public RuntimeExceptionTest() { }

   public RuntimeExceptionTest(String message) {super(message);
   }
}

public class TrcatchTest3 {public static void main(String[] args) {
      try {exceptionTest();
      } catch (Exception e) {
         // 上面是默认解决异样的办法
         // e.printStackTrace();
         System.out.println(e.getMessage());
      }
   }
   public static void exceptionTest() throws Exception {
      // 伪装出现异常
      throw new ExceptioTest("出现异常");
   }
}

本章完结，用于集体学习和小白入门，大佬勿喷！心愿大家多多点赞珍藏撑持撑持！

源码【GitHub】【码云】

正文完

java

发表至： java

2021-12-30

0

关于java:Java并发编程从源码分析几道必问线程池的面试题

关于java:一张图解决IDEA项目的properties和yml文件不显示绿叶子问题

关于java:面试官Tomcat-有哪些组成部分讲讲工作原理面试必问

关于java:弃用-Windows政府机构-5000-万台电脑将替换为国产-Linux

关于数据库:SQLServer触发器调用JavaWeb接口

关于java:Java基础16不可变集合Stream流和异常

1. 不可变汇合

1.1 创立

2. Stream 流

2.1 Stream 流的创立

2.1.1 取得 Stream 流

2.1.2 两头操作

2.1.3 终结办法

2.1.4 Stream 流数据收集

3. 异样

3.1 异样体系

3.2 异样解决

3.2.1 零碎默认解决

3.2.2 手动解决

3.2.2.1 throws

3.2.2.1 try…catch…

3.2.2.2 混合双打

3.3 自定义异样

3.3.1 自定义编译时异样

3.3.2 自定义运行时异样

Just My Socks（注册教程内含优惠码）

关于java:Java基础16不可变集合Stream流和异常

1. 不可变汇合

1.1 创立

2. Stream 流

2.1 Stream 流的创立

2.1.1 取得 Stream 流

2.1.2 两头操作

2.1.3 终结办法

2.1.4 Stream 流数据收集

3. 异样

3.1 异样体系

3.2 异样解决

3.2.1 零碎默认解决

3.2.2 手动解决

3.2.2.1 throws

3.2.2.1 try…catch…

3.2.2.2 混合双打

3.3 自定义异样

3.3.1 自定义编译时异样

3.3.2 自定义运行时异样

Just My Socks（注册教程 内含优惠码）

Just My Socks（注册教程内含优惠码）