Java 学习笔记-第七课

1. 泛型编程

1.1 泛型的概念

• 泛型：使得类、接口和方法能够操作指定类型的对象。使用泛型可以提高代码的重用性、类型安全性和可读性。

1.2 泛型类

• 定义和使用：

  public class Box<T> {
      private T value;
  
      public void setValue(T value) {
          this.value = value;
      }
  
      public T getValue() {
          return value;
      }
  }
  
  public class Main {
      public static void main(String[] args) {
          Box<Integer> integerBox = new Box<>();
          integerBox.setValue(10);
          System.out.println("Integer Value: " + integerBox.getValue());
  
          Box<String> stringBox = new Box<>();
          stringBox.setValue("Hello");
          System.out.println("String Value: " + stringBox.getValue());
      }
  }
  

1.3 泛型方法

• 定义和使用：

  public class Util {
      public static <T> void printArray(T[] array) {
          for (T element : array) {
              System.out.println(element);
          }
      }
  }
  
  public class Main {
      public static void main(String[] args) {
          Integer[] intArray = {1, 2, 3, 4, 5};
          String[] stringArray = {"A", "B", "C", "D"};
  
          Util.printArray(intArray);
          Util.printArray(stringArray);
      }
  }
  

1.4 泛型接口

• 定义和使用：

  public interface Container<T> {
      void add(T element);
      T get(int index);
  }
  
  public class MyContainer<T> implements Container<T> {
      private List<T> list = new ArrayList<>();
  
      public void add(T element) {
          list.add(element);
      }
  
      public T get(int index) {
          return list.get(index);
      }
  }
  
  public class Main {
      public static void main(String[] args) {
          Container<String> stringContainer = new MyContainer<>();
          stringContainer.add("Hello");
          System.out.println(stringContainer.get(0));
      }
  }
  

2. Lambda 表达式

2.1 Lambda 表达式的概念

• Lambda 表达式：简化代码的方式，使代码更加简洁和易读。常用于实现简单的接口方法，如函数式接口。

2.2 使用 Lambda 表达式

• 示例：

  import java.util.ArrayList;
  import java.util.List;
  
  public class Main {
      public static void main(String[] args) {
          List<String> list = new ArrayList<>();
          list.add("Apple");
          list.add("Banana");
          list.add("Orange");
  
          // 使用 Lambda 表达式遍历列表
          list.forEach(item -> System.out.println(item));
      }
  }
  

2.3 函数式接口

• 定义：只有一个抽象方法的接口，可以用作 Lambda 表达式的目标类型。
• 示例：

  @FunctionalInterface
  public interface MyFunctionalInterface {
      void execute();
  }
  
  public class Main {
      public static void main(String[] args) {
          MyFunctionalInterface myFunc = () -> System.out.println("Executing...");
          myFunc.execute();
      }
  }
  

3. Stream API

3.1 Stream 的概念

• Stream API：用于处理集合数据的强大工具，提供了多种操作如过滤、排序和聚合。

3.2 创建和使用 Stream

• 示例：

  import java.util.Arrays;
  import java.util.List;
  import java.util.stream.Collectors;
  
  public class Main {
      public static void main(String[] args) {
          List<String> list = Arrays.asList("Apple", "Banana", "Orange", "Apple");
  
          // 过滤和收集
          List<String> filteredList = list.stream()
                                          .filter(item -> item.startsWith("A"))
                                          .collect(Collectors.toList());
  
          System.out.println(filteredList); // 输出：[Apple, Apple]
  
          // 排序
          List<String> sortedList = list.stream()
                                        .sorted()
                                        .collect(Collectors.toList());
  
          System.out.println(sortedList); // 输出：[Apple, Apple, Banana, Orange]
  
          // 聚合操作
          long count = list.stream()
                           .filter(item -> item.equals("Apple"))
                           .count();
  
          System.out.println(count); // 输出：2
      }
  }
  

3.3 常见的 Stream 操作

• 过滤 (filter)：筛选符合条件的元素。
• 映射 (map)：对每个元素应用函数并返回新的元素。
• 排序 (sorted)：对元素进行排序。
• 收集 (collect)：将 Stream 转换为其他形式（如 List、Set）。
• 统计 (count)：统计元素个数。

4. Optional 类

4.1 Optional 的概念

• Optional：避免 NullPointerException 的一种方式，用于表示可能为空的值。

4.2 使用 Optional

• 示例：

  import java.util.Optional;
  
  public class Main {
      public static void main(String[] args) {
          Optional<String> optional = Optional.of("Hello, World!");
  
          // 检查值是否存在
          if (optional.isPresent()) {
              System.out.println(optional.get());
          }
  
          // 使用 ifPresent
          optional.ifPresent(value -> System.out.println("Value: " + value));
  
          // 设置默认值
          String defaultValue = optional.orElse("Default Value");
          System.out.println(defaultValue);
      }
  }
  

小结

• 本课学习了泛型编程，包括泛型类、方法和接口。
• 介绍了 Lambda 表达式和函数式接口，简化代码编写。
• 探讨了 Stream API，用于处理集合数据的强大工具。
• 介绍了 Optional 类，避免 NullPointerException 的有效手段。