Day06——方法，Stream流

Day06

方法

方法的意义

• 用于封装一段特定的业务逻辑功能
• 方法应该尽可能独立，一个方法只实现一个逻辑功能
• 方法可以被多次调用
• 减少代码重复，有利于代码的维护

方法的定义

方法五要素：权限修饰词、返回值类型、方法名、参数列表、方法体

• 权限修饰词

  1. public 公有
  2. private 私有
  3. protected 受保护

• 返回值类型

  1. 基本数据类型 int、double、String…
  2. 引用数据类型 int[]、double[]、ArrayList<>、List<>…
  3. 无返回值 void

• 方法名

  与变量命名规则相同，小驼峰命名方式

• 参数列表

  形参：在定义方法时参数列表中的参数，只在方法域中生效

  public static void say(String name, int age) { //形参
   System.out.println("Hello, " + name + "! You are " + age + " years old.");
  }
  

  实参：调用方法时传入的参数为实参

  public static void main(String[] args) {
    // 调用方法
    say("ZhangSan", 20); //实参
  }
  

  1. 有参：

     public static void say(String name, int age) {
         System.out.println("Hello, " + name + "! You are " + age + " years old.");
     }
     

  2. 无参

     public static void say() {
         System.out.println("Hello, world!");
     }
     

• 方法体

  具体逻辑实现代码

return

• 在有返回值的方法中用于返回执行结果给调用方

  public static int add(int a, int b) {
      return a+b;
  }
  

• 在无返回值的方法中只用于结束方法的执行（可有可无）

  public static void add(int a, int b) {
      System.out.println(a+b);
      return;
  }
  

方法的重载（Overloading）

方法的重载发生在同一类中，表现为方法名相同，参数列表不同

[!NOTE]

必须参数列表不同，可以是参数数量不同，也可以是参数类型不同

只有返回值类型不同则不能成为方法重载，会报错

public class Demo{
    public void say(){...}
    public void say(int a){...}//重载
    public int say(){...}//不是重载，会报错
}

---

扩展——Stream流

Java8新增数据处理方式，以声明式的方式对数据进行操作

特点：

• 不存储数据，通过管道传输数据
• 可以操作任何数据源
• 可以进行串行、并行操作

Stream流的使用

• 创建Stream流

  对象.stream();
  List<String> list = Arrays.asList("a", "b", "c");
  Stream<String> stream = list.stream();
  

• 中间操作：包含filter()、map()、distinct()…等方法

  List<String> list = Arrays.asList("a", "b", "c");
  List<String> newList = list.stream()
          .filter(x -> x.equals("a"))
          .collect(Collectors.toList());
  

• 终端操作：用于对流数据的组织，聚合、收集、遍历等

常见方法

Stream流中常见的操作有：过滤filter()、映射map()、排序sorted()、聚合reduce()……

filter()

示例：筛选list中的偶数

List<Integer> numList = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
        .stream()
        .filter(x -> x % 2 == 0)
        .collect(Collectors.toList());

map()
示例：求List中各个元素的平方根

List<Double> sqrtList = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
        .stream()
        .map(x -> Math.sqrt(x))

//将list中字符转换为大写
Arrays.asList("a","b", "c").stream()
    .map(String::toUpperCase)
    .forEach(System.out::println);

[!NOTE]

String::toUpperCase

双冒号 “::” 的用法：

• 省略lambda表达式

  //使用lambda表达式
  list.forEach(x-> System.out.println(x));
  //使用“::”方法引用
  list.forEach(System.out::println);
  

• 对父方法的引用

  //父类
  class Test04Fu{
      void print(String s){
          System.out.println(s);
      }
  }
  
  //子类
  public class Test04 extends Test04Fu {
      public  void test() {
          String arr[] =new String[]{"aaa","bbb","ccc"};
          List<String> list = Arrays.asList(arr);
          //引用父类方法，通过super+::+方法名的方式
          list.forEach(super::print);
      }
  }
  
  

• 对实例方法的引用

  public class Test03 {
      public static void main(String[] args) {
          String arr[]=new String[]{"aaa","bbb","ccc"};
          List<String> list = Arrays.asList(arr);
          Test03 test03=new Test03();
          //引用实例方法，通过对象+::+方法名的方式
          list.forEach(test03::print);
      }
      public void print(String s){
          System.out.println(s);
      }
  }
  

sorted()

示例：将list中的数据进行从小到大排序

List<Integer> numbers = Arrays.asList(31, 12, 53, 64, 5);
List<Integer> sortedNumbers = numbers.stream()
    .sorted()
    .collect(Collectors.toList());

reduce()

示例：将list中的数据迭代求和

Integer reduce = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10).stream().reduce(0, (a, b) -> a + b);

输出结果：

55

代码解释：

• 该行代码对List进行了迭代求和
• reduce()方法的第一个参数表示a的初始值为0，第二个参数b则指向list中的元素，第一次迭代时指向第一个元素1
• a和b相加得3，而后进行第二次迭代，a的值变为上次迭代的a+b的结果3，b则指向list的下一个元素2
• 以此类推，直到list中所有元素均加入a
• 最终返回的值就是a的值，即list中所有元素与a初始值的和

collect()

使用collect方法将Stream流中的元素收集到一个指定的集合中

示例：将list中的偶数提取出来后，再将其封装成List集合

List<Integer> numList = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
        .stream()
        .filter(x -> x % 2 == 0)
        .collect(Collectors.toList());

---