java学习笔记20（Lambda表达式、函数式编程、流式计算、练习）_随笔

java学习笔记20（Lambda表达式、函数式编程、流式计算、练习）

文章目录

11.3
学习内容
- Lambda表达式
- - Lambda标准格式
  - - 格式说明
    - 省略规则
  - 使用前提
- 函数式接口
- - 预定义的函数式接口
工作内容
- 任务1
总结&明日计划
11.4
学习内容
- 流式计算
- - 两大特征
  - 两大 *** 作
  - 获取流的方式
  - flatMap 方法
工作内容
- 任务1
- 任务2
练习内容
- codegym - 数组
- - 任务1 复制单词
  - 任务2 检查顺序
  - 任务3 以相反顺序显示数字
  - 任务4 移动一个 static 修饰符
  - 任务5 及时洗牌
  - 任务6 数组中的最小值和最大值
  - 任务7 结束
  - 任务8 家庭人口普查
  - 任务9 Cat 代码将无法编译
  - 任务10 更改功能
  - 任务11 降序
- codegym - 练习使用集合
- - 任务1 包含植物的 HashSet
  - 任务2 包含猫的 HashMap
  - 任务4 在屏幕上显示值！

11.3 学习内容 Lambda表达式

在一个 Runnable 接口中，只有一个 run() 方法：

public abstract void run();

代码特点：

无参数：不需要任何条件即可执行该方案。
无返回值：该方案不产生任何结果。
代码块（方法体）：该方案的具体执行步骤。

同样的语义体现在 Lambda 语法中，要更加简单：

() ‐> System.out.println("多线程任务执行！")

前面的一对小括号即 run 方法的参数（无），代表不需要任何条件；
中间的一个箭头代表将前面的参数传递给后面的代码；
后面的输出语句即业务逻辑代码。

Lambda标准格式

Lambda省去面向对象的条条框框，格式由3个部分组成：

一些参数
一个箭头
一段代码

即：(参数类型参数) -> {代码}

格式说明

小括号内的语法与传统方法参数列表一致：无参数则留空；多个参数则用逗号分隔。
-> 是新引入的语法格式，代表指向动作。
大括号内的语法与传统方法体要求基本一致。

省略规则

在Lambda标准格式的基础上，使用省略写法的规则为：

小括号内参数的类型可以省略；
如果小括号内有且仅有一个参，则小括号可以省略；
如果大括号内有且仅有一个语句，则无论是否有返回值，都可以省略大括号、return关键字及语句分号。
凡是可以通过上下文推导出来的内容，都可以省略书写。

可省略的内容：
1. 参数列表：括号中参数的数据类型可省略
2. 参数列表：括号中如果只有一个参数，那么类型和 () 都可以省略。
3. 代码块：如果代码块 {} 中的代码只有一行，那么无论是否有返回值，都可以省略({}，return，分号)，但他们3个必须一起省略

使用前提

使用Lambda必须具有接口，且要求接口中有且仅有一个抽象方法。无论是内置接口还是自定义接口，只有当接口中的抽象方法存在且唯一时，才可以使用Lambda。
使用Lambda必须具有上下文推断，也就是方法的参数或局部变量类型必须为Lambda对应的接口类型，才能使用Lambda作为该接口的实例。

函数式接口预定义的函数式接口预定义函数接口方法名描述符分类用途SupplierT get()() -> T供给型提供1个结果Consumervoid accept(T t)(T) -> void消费型消费1个输入BiConsumervoid accept(T t, U u)(T, U)-> void消费型消费2个输入FunctionR apply(T t)(T) -> R映射型完成类型转换BiFunctionR apply(T t, U u)(T, U) -> R映射型完成类型转换UnaryOperatorT apply(T t)(T) -> T映射型完成类型转换BinaryOperatorT apply(T t, U u)(T, T)映射型完成类型转换Predicateboolean test(T t)(T) -> boolean预测型判断输入是否符合预期Bipredicateboolean test(T t, U u)(T,U) -> boolean预测型判断输入是否符合预期工作内容任务1

尝试自定义几个函数式接口用于之前任务的代码中，并用 Lambda 表达式改造之前的代码。

答：在之前写过的 4 线程用同一个锁的任务基础上修改。

以单个线程为例：

   Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized ("lock1") {
                    System.out.println("t1 线程开始");
                    try {
                        "锁".wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("t1 线程结束");
                }
            }
        });

线程 t1 中，在 Runnable 中有且仅有一个抽象方法：run()，因此满足Lambda 表达式的省略条件。

因此可以改写成：

        new Thread(() -> {
            System.out.println("t1线程开始");
            try {
                "lock1".wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("t1 线程结束");
        }).start();

总结&明日计划

个人体会，Lambda 表达式是很容易眼高手低的知识点。看文档、看别人代码的时候会觉得比较好理解，实际自己写的时候却很容易卡壳，感觉明天还需要自己再把别人的代码多敲几次，在敲的过程中也可以更好的体会 Lambda 的省略原则。
明日争取把函数式编程和流式编程都搞完

11.4 学习内容流式计算

Stream，也就是流，也叫做流式计算。利用 Steam ，可以让 java 以声明性地迭代方式处理集合。

元素是特定类型的对象，形成一个队列。 Stream并不会存储元素，而是按需计算。

流的来源可以是集合，数组等。

两大特征

Pipelining: 中间 *** 作都会返回流对象本身。这样多个 *** 作可以串联成一个管道，如同流式风格（fluent style）。这样做可以对 *** 作进行优化，比如延迟执行(laziness)和短路( short-circuiting)。

内部迭代：以前对集合遍历都是通过Iterator或者增强for的方式, 显式的在集合外部进行迭代，这叫做外部迭代。 Stream提供了内部迭代的方式，流可以直接调用遍历方法。

两大 *** 作

Java8 的 Stream API 中定义了两大类流式 *** 作，一种是中间 *** 作，一种是终端 *** 作。

所谓中间 *** 作，就是类似于流水线上，给上游工序做一些加工和包装，然后再传给自己的下游工序。同样的道理，中间 *** 作流会返回另一个流对象，这个流对象的数据是需要继续传递给后面的流 *** 作处理的。

终端 *** 作就是真正结果的 *** 作，类似于流水线上最后一道工序。

获取流的方式

所有的 Collection 集合都可以通过 stream 默认方法获取流；
Stream 接口的静态方法 of 可以获取数组对应的流。

flatMap 方法

使用flatMap方法的效果是，各个数组并不是分别映射一个流，而是映射成流的内容，所有使用生成的单个流被合并起来，即扁平化为一个流。

例如，将流1：{"H","e","l","l","o"} 与流2：{"W","o","r","l","d"} 用普通方式合并，结果为：{"H","e","l","l","o","W","o","r","l","d"}。

用 flatMap 合并，其结果为：{"H","e","l","o","W","r","d"} 。

工作内容任务1

除了消费型函数式接口，从搜索引擎或 CSDN 上再分别找一些供给型、映射型和预测型函数式接口的实际应用例子。

package com.xxm.advanced_camp.mission12_FunctionalParadigm;

import java.util.Locale;
import java.util.function.*;

public class TestTask2 {
    public static void main(String[] args) {
        //供给型
        int arr[] = {24, 12, 34, 87, 5};
        int maxNum = getMax(() -> {
            int max = arr[0];
            for (int x : arr) {
                if (x > max) {
                    max = x;
                }
            }
            return max;
        });
        System.out.println("供给型函数接口测试。数组最大值为：" + maxNum);

        //消费型
        printString(s -> System.out.println(s));

        //映射型
        toUpper(s -> s.toUpperCase());

        //预测型
        lenthLongerThanThree(s -> s.length() > 3);

    }

    //供给型，方法
    public static int getMax(Supplier supplier) {
        return supplier.get();
    }

    //消费型，方法
    public static void printString(Consumer consumer) {
        consumer.accept("消费型接口测试：HelloWorld");
    }

    //映射型，方法
    public static String toUpper(UnaryOperator function) {
        String s = function.apply("映射型接口测试：HelloWorld");
        System.out.println(s);
        return s.toUpperCase();

    }

    //预测型，方法
    public static void lenthLongerThanThree(Predicate predicate) {
        boolean longer = predicate.test("HelloWorld");
        System.out.println("预测型接口测试。字符串 HelloWorld 的长度大于 3 吗？" + longer);
    }
}

输出结果为：

供给型函数接口测试。数组最大值为：87
消费型接口测试：HelloWorld
映射型接口测试：HELLOWORLD
预测型接口测试。字符串 HelloWorld 的长度大于 3 吗？true

任务2

实现如下需求：统计公司类型为 BIG 的所有未婚员工，同时按年龄排序，并且未婚员工不区分公司，也就是最终结果放在一个列表中（提示：整个需求可以用一行代码完成）。

package com.xxm.advanced_camp.mission13_stream;

import java.util.*;
import java.util.function.Supplier;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class Task1 {

    public static void main(String[] args) {

        List> list = new ArrayList<>();
        List employees = Arrays.asList(
                new Employee("张勇", "男", 28, true, Employee.Type.MANAGER),
                new Employee("李强", "男", 22, false, Employee.Type.SELLER),
                new Employee("王武", "男", 32, false, Employee.Type.SELLER),
                new Employee("梅丽", "女", 26, true, Employee.Type.OFFICER),
                new Employee("郑帅", "男", 29, false, Employee.Type.OFFICER),
                new Employee("曾美", "女", 27, true, Employee.Type.SELLER),
                new Employee("郝俊", "男", 22, true, Employee.Type.SELLER),
                new Employee("方圆", "女", 24, false, Employee.Type.SELLER)
        );
        Company moubao = new Company("某宝", Company.Type.BIG, employees);

        employees = Arrays.asList(

                new Employee("吴琼", "女", 27, true, Employee.Type.SELLER),
                new Employee("陈辰", "女", 20, false, Employee.Type.OFFICER),
                new Employee("刘能", "男", 25, true, Employee.Type.OFFICER),
                new Employee("周七", "男", 29, false, Employee.Type.OFFICER),
                new Employee("汪旺", "男", 21, false, Employee.Type.OFFICER),
                new Employee("胡涂", "男", 27, false, Employee.Type.OFFICER),
                new Employee("杨茂", "男", 34, true, Employee.Type.MANAGER),
                new Employee("朱坚", "男", 30, false, Employee.Type.MANAGER)
        );
        Company mouxin = new Company<>("某东", Company.Type.BIG, employees);

        employees = Arrays.asList(

                new Employee("冯过", "男", 35, false, Employee.Type.SELLER),
                new Employee("何花", "女", 27, false, Employee.Type.MANAGER),
                new Employee("卫精", "男", 25, true, Employee.Type.OFFICER),
                new Employee("施工", "男", 28, false, Employee.Type.OFFICER),
                new Employee("沈月", "女", 24, false, Employee.Type.OFFICER),
                new Employee("乐欢", "女", 22, false, Employee.Type.OFFICER),
                new Employee("安全", "男", 33, true, Employee.Type.MANAGER),
                new Employee("林森", "男", 26, true, Employee.Type.SELLER)
        );
        Company mouhaha = new Company<>("某哈哈", Company.Type.SMALL, employees);

        list.add(moubao);
        list.add(mouxin);
        list.add(mouhaha);

        List result = list.stream()
                .flatMap(company -> company.getEmployees().stream())
                .filter(employee -> !employee.isMarried())
                .sorted(Comparator.comparing(Employee::getAge))
                .collect(Collectors.toList());

        for (Employee emp : result) {
            System.out.println(emp.toString());
        }

    }
}

练习内容 codegym - 数组任务1 复制单词

1.从键盘读取 10 个单词并将其添加到字符串列表中。

2.doublevalues 方法应复制单词，如下所示：alpha、beta、gamma -> alpha、alpha、beta、beta、gamma、gamma。

3.显示结果，每行显示一个值。

Requirements:

声明字符串列表变量并立即初始化该变量。
从键盘读取 10 行内容并将其添加到列表中。
doublevalues 方法应复制列表元素，如下所示：alpha、beta、gamma -> alpha、alpha、beta、beta、gamma、gamma。
显示生成的列表，每行显示一个元素。

答：

package zh.codegym.task.task07.task0717;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.ArrayList;



public class Solution {
    public static void main(String[] args) throws Exception {
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));

        ArrayList list = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            String s = reader.readLine();
            list.add(s);
        }

        ArrayList result = doublevalues(list);

        for (String s : result) {
            System.out.println(s);
        }
    }

    public static ArrayList doublevalues(ArrayList list) {
        ArrayList result = new ArrayList<>();
        for (String s : list) {
            result.add(s);
            result.add(s);
        }
        return result;
    }
}

任务2 检查顺序

1.从键盘读取 10 个单词并将其添加到字符串列表中。
2.确定列表是否按字符串长度升序排序。
3.如果不是，则显示打乱此顺序的第一个元素的索引。

Requirements:

声明字符串列表变量并立即初始化该变量。
从键盘读取 10 行内容并将其添加到列表中。
如果列表是按字符串长度升序排序的，则无需显示任何内容。
如果列表不是按字符串长度升序排序的，则显示第一个打乱此顺序的元素的索引。

package zh.codegym.task.task07.task0718;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;



public class Solution {

    public static void main(String[] args) throws IOException {
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));

        ArrayList list = new ArrayList();
        for (int i = 0; i < 10; i++) {
            String s = reader.readLine();
            list.add(s);
        }

        String minElement = list.get(0);

        for (int i = 1; i < 10; i++) {
            if (list.get(i).length() >= minElement.length()) {
                minElement = list.get(i);
            } else {
                System.out.println(i);
                break;
            }
        }
    }
}

任务3 以相反顺序显示数字

从键盘输入 10 个数字并将其放入列表中。
以相反顺序显示它们。每行显示一个元素。
只使用 for 循环。

package zh.codegym.task.task07.task0719;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;



public class Solution {
    public static void main(String[] args) throws IOException {
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));

        ArrayList data = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            data.add(Integer.parseInt(reader.readLine()));
        }

        for (int i = data.size() - 1; i >= 0; i--) {
            System.out.println(data.get(i));
        }
    }
}

任务4 移动一个 static 修饰符

移动一个 static 修饰符以使示例编译。

要求：
程序不得从键盘读取数据。
该类必须包含变量 A。
该类必须包含变量 B。
该类必须包含变量 C。
该类必须包含 main 方法。
该类必须包含 getValue 方法。
该类必须包含 4 个 static 修饰符（变量和方法）。

答：

package zh.codegym.task.task07.task0725;



public class Solution {

    public final static int A = 5;
    public final static int B = 2;
    public final static int C = A * B;

    public static void main(String[] args) {
    }

    public int getValue() {
        return C;
    }
}

任务5 及时洗牌

使用键盘输入 2 个数字 N 和 M。
输入 N 个字符串并将其放入列表中。
将前 M 个字符串移到列表末尾。
显示列表，每行显示一个值。

注意：
不能创建多个列表。

Requirements:

声明字符串列表变量并立即初始化该变量。
从键盘读取数字 N 和 M。读取 N 个字符串并将其添加到列表中。
将前 M 个字符串移到列表末尾。
显示列表，每行显示一个值。

答：

package zh.codegym.task.task07.task0720;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;



public class Solution {
    public static void main(String[] args) throws IOException {
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        int N = Integer.parseInt(reader.readLine());
        int M = Integer.parseInt(reader.readLine());

        ArrayList list = new ArrayList<>();
        //键盘录入 n 个数字
        for (int i = 0; i < N; i++) {
            String s = reader.readLine();
            list.add(s);
        }

        for (int i = 0; i < M; i++) {
            list.add(list.get(0));
            list.remove(0);
        }

        for (String x : list) {
            System.out.println(x);
        }


    }
}

任务6 数组中的最小值和最大值

创建包含 20 个数字的数组。
从键盘输入数字来填充该数组。
找出数组中的最大和最小数字。
显示最大数字和最小数字，用空格分隔。

Requirements:

创建包含 20 个元素的 integers (int[]) 数组。
从键盘读取 20 个整数并将其添加到数组中。
找出最大和最小的整数，然后显示它们，用空格分隔。
使用 for 循环。

答：

package zh.codegym.task.task07.task0721;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;



public class Solution {
    public static void main(String[] args) throws IOException {
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));

        int maximum;
        int minimum;

        int[] arr = new int[20];
        for (int i = 0; i < 20; i++) {
            arr[i] =Integer.parseInt(reader.readLine());

        }
        maximum = arr[0];
        minimum = arr[0];
        for (int x : arr) {
            if (x > maximum) {
                maximum = x;
            } else if (x < minimum) {
                minimum = x;
            }
        }

        //在此编写你的代码

        System.out.print(maximum + " " + minimum);
    }
}

任务7 结束

创建字符串列表。
从键盘输入字符串并将其添加到列表中。
从键盘输入字符串，直至用户输入“结束”为止。忽略字符串“结束”。
在屏幕上显示字符串，每行显示一个。

Requirements:

声明字符串列表变量并立即初始化该变量。
从键盘读取字符串并将其添加到列表中，直至用户输入“结束”为止。
不要将“结束”添加到列表中。
显示列表，每行显示一个值。
使用 for 循环。

答：

package zh.codegym.task.task07.task0722;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;



public class Solution {
    public static void main(String[] args) throws IOException {
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        ArrayList list = new ArrayList<>();

        while (true) {
            String s = reader.readLine();
            if (s.equals("结束")) {
                break;
            } else {
                list.add(s);
            }
        }

        for (String x : list) {
            System.out.println(x);
        }
        //在此编写你的代码
    }
}

任务8 家庭人口普查

家庭人口普查
创建 Human 类，该类包含 String name、boolean sex、int age、Human father 和 Human mother 字段。创建并填充对象，以便我们最终得到：两个祖父、两个祖母、一个父亲、一个母亲和三个孩子。在屏幕上显示对象。

注意：
如果你在 Human 类中编写自己的 String toString() 方法，该方法将用于在屏幕上显示对象。

示例输出：
名字：安娜，性别：女，年龄：21，父亲：保罗，母亲：凯特
名字：凯特，性别：女，年龄：55
名字：本，性别：男，年龄：2，父亲：迈克尔，母亲：

package zh.codegym.task.task07.task0724;



答：
public class Solution {
    public static void main(String[] args) {
        //创建 9 个不同的 Human 对象。
        Human h1 = new Human("张三", true, 24);
        Human h2 = new Human("张三", false, 24);
        Human h3 = new Human("张三", true, 24);
        Human h4 = new Human("张三", true, 24);
        Human h5 = new Human("赵四", false, 21, h1, h2);
        Human h6 = new Human("赵四", false, 21, h1, h2);
        Human h7 = new Human("赵四", false, 21, h1, h2);
        Human h8 = new Human("赵四", false, 21, h1, h2);
        Human h9 = new Human("赵四", false, 21, h1, h2);
    }

    public static class Human {
        //字段
        String name = null;
        boolean sex = true;
        int age = 0;
        Human father = null;
        Human mother = null;

        //构造方法

        public Human(String name, boolean sex, int age) {
            this.name = name;
            this.sex = sex;
            this.age = age;
            System.out.println(this.toString());
        }

        public Human(String name, boolean sex, int age, Human father, Human mother) {
            this.name = name;
            this.sex = sex;
            this.age = age;
            this.father = father;
            this.mother = mother;
            System.out.println(this.toString());
        }

        @Override
        public String toString() {
            String text = "";
            text += "名字：" + this.name;
            text += "，性别：" + (this.sex ? "男" : "女");
            text += "，年龄：" + this.age;

            if (this.father != null) {
                text += "，父亲：" + this.father.name;
            }

            if (this.mother != null) {
                text += "，母亲：" + this.mother.name;
            }

            return text;
        }
    }
}

任务9 Cat 代码将无法编译

任务：程序从键盘读取有关猫的数据并在屏幕上显示它们。

例如：
猫的名字：泰格，年龄：6，体重：5，尾巴：22
猫的名字：米西，年龄：8，体重：7，尾巴：20

Requirements:

程序必须从键盘读取数据。
如果用户输入空字符串而不是名字，程序应在屏幕上显示数据并终止运行。
如果用户输入：泰格、6、5 和 22（每行一个值），程序应显示“猫的名字：泰格，年龄：6，体重：5，尾巴：22”。
如果用户输入：米西、8、7 和 20（每行一个值），程序应显示“猫的名字：米西，年龄：8，体重：7，尾巴：20”。
如果用户输入：泰格、6、5、22、米西、8、7 和 20（每行一个值），程序应显示两行内容：“猫的名字：泰格，年龄：6，体重：5，尾巴：22”和“猫的名字：米西，年龄：8，体重：7，尾巴：20”。

答：

package zh.codegym.task.task07.task0726;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;



public class Solution {
    public final static ArrayList CATS = new ArrayList<>();

    public static void main(String[] args) throws IOException {
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));

        while (true) {
            String name = reader.readLine();

            int age;
            int weight;
            int tail;

            if (name.isEmpty()) {
                break;
            } else {
                age = Integer.parseInt(reader.readLine());
                weight = Integer.parseInt(reader.readLine());
                tail = Integer.parseInt(reader.readLine());
            }

            Cat cat = new Cat(name, age, weight, tail);
            CATS.add(cat);
        }

        printList();
    }

    public static void printList() {
        for (Cat cat : CATS) {
            System.out.println(cat);
        }
    }

    public static class Cat {
        private String name;
        private int age;
        private int weight;
        private int tailLength;

        Cat(String name, int age, int weight, int tailLength) {
            this.name = name;
            this.age = age;
            this.weight = weight;
            this.tailLength = tailLength;
        }

        public Cat(String name) {
            this.name = name;
        }

        @Override
        public String toString() {
            return "猫的名字：" + name + "，年龄：" + age + "，体重：" + weight + "，尾巴：" + tailLength;
        }
    }
}

任务10 更改功能

任务：程序读取字符串，直至用户输入空字符串（通过按 Enter 键）为止。然后将字符串转换为大写字母（“mother”变成“MOTHER”）并显示它们。

新任务：程序读取字符串，直至用户输入空字符串（通过按 Enter 键）为止。
然后，程序将构建一个新列表。如果字符串的字母数为偶数，则复制该字符串。如果字母数为奇数，则该字符串被重复三次。
程序显示新列表的内容。

答：

package zh.codegym.task.task07.task0727;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;



public class Solution {
    public static void main(String[] args) throws IOException {
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));

        ArrayList list = new ArrayList();
        while (true) {
            String s = reader.readLine();
            if (s.isEmpty()) {
                break;
            }
            list.add(s);
        }

        ArrayList list1 = new ArrayList();
        for (int i = 0; i < list.size(); i++) {
            String s = list.get(i);
            if (s.length() % 2 == 0) {
                s = s + " " + s;
            } else {
                s = s + " " + s + " " + s;
            }
            list.set(i, s);
        }

        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
    }
}

任务11 降序

任务：编写程序，该程序从键盘读取 20 个数字并以降序显示它们

Requirements:

程序应从键盘读取 20 个整数。
程序应显示 20 个数字。
Solution 类必须包含 public static void sort(int[] array) 方法。
main 方法应调用 sort 方法。
sort 方法应对所传递的数组进行降序排序。
答：

package zh.codegym.task.task07.task0728;

import java.io.BufferedReader;
import java.io.InputStreamReader;



public class Solution {
    public static void main(String[] args) throws Exception {
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        int[] array = new int[20];
        for (int i = 0; i < 20; i++) {
            array[i] = Integer.parseInt(reader.readLine());
        }

        sort(array);

        for (int x : array) {
            System.out.println(x);
        }
    }

    public static void sort(int[] array) {
        for (int i = array.length; i > 0; i--) {
            for (int j = 0; j < array.length - 1; j++) {
                if (array[j] < array[j + 1]) {
                    int temp = 0;
                    temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                }
            }
        }
    }
}

codegym - 练习使用集合任务1 包含植物的 HashSet

使用 String 元素创建 HashSet。
向其中添加以下字符串：
西瓜
香蕉
樱桃
梨
哈密瓜
黑莓
人参
草莓
鸢尾花
土豆

显示集合的内容，每行显示一个元素。
观察条目的顺序有何变化。

答：

package zh.codegym.task.task08.task0801;



import java.util.HashSet;

public class Solution {
    public static void main(String[] args) throws Exception {
        HashSet set = new HashSet<>();
        set.add("西瓜");
        set.add("香蕉");
        set.add("樱桃");
        set.add("梨");
        set.add("哈密瓜");
        set.add("黑莓");
        set.add("人参");
        set.add("草莓");
        set.add("鸢尾花");
        set.add("土豆");

        for (String s : set) {
            System.out.println(s);
        }


    }
}

任务2 包含猫的 HashMap

有一个包含 String name 的 Cat 类。
创建 HashMap。
向该集合中添加 10 个猫。猫的名字应用作键。
在屏幕上显示结果，每行显示一个元素。

package zh.codegym.task.task08.task0803;

import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;



public class Solution {
    public static void main(String[] args) throws Exception {
        String[] cats = new String[]{"泰格", "米西", "斯摩基", "果酱", "奥斯卡", "雪球", "博斯", "斯马奇", "马克斯", "辛巴"};

        HashMap map = addCatsToMap(cats);

        for (Map.Entry pair : map.entrySet()) {
            System.out.println(pair.getKey() + " - " + pair.getValue());
        }
    }


    public static HashMap addCatsToMap(String[] cats) {
        HashMap map = new HashMap<>();
        for (int i = 0; i < cats.length; i++) {
            map.put(cats[i], new Cat(cats[i]));
        }
        return map;
    }


    public static class Cat {
        String name;

        public Cat(String name) {
            this.name = name;
        }

        @Override
        public String toString() {
            return name != null ? name.toUpperCase() : null;
        }
    }
}

···

### 任务3 显示键的列表
有一个 HashMap。已向其中添加了 10 个不同的字符串。
在屏幕上显示键的列表，每行显示一个元素。

答：
```java
package zh.codegym.task.task08.task0804;

import java.util.HashMap;
import java.util.Map;



public class Solution {
    public static void main(String[] args) {
        HashMap map = new HashMap<>();
        map.put("西姆", "西姆");
        map.put("汤姆", "汤姆");
        map.put("阿勃斯", "阿勃斯");
        map.put("婴儿", "婴儿");
        map.put("猫", "猫");
        map.put("狗", "狗");
        map.put("吃", "吃");
        map.put("食物", "食物");
        map.put("万能激活卡", "万能激活卡");
        map.put("拥抱", "拥抱");

        printKeys(map);
    }

    public static void printKeys(Map map) {
        for (Map.Entry m : map.entrySet()) {
            System.out.println(m.getKey());
        }
    }
}

任务4 在屏幕上显示值！

有一个 HashMap。已向其中添加了 10 个不同的字符串。
在屏幕上显示值的列表，每行显示一个元素。

package zh.codegym.task.task08.task0805;

import java.util.HashMap;
import java.util.Map;



public class Solution {
    public static void main(String[] args) {
        HashMap map = new HashMap<>();
        map.put("西姆", "西姆");
        map.put("汤姆", "汤姆");
        map.put("阿勃斯", "阿勃斯");
        map.put("婴儿", "婴儿");
        map.put("猫", "猫");
        map.put("狗", "狗");
        map.put("吃", "吃");
        map.put("食物", "食物");
        map.put("万能激活卡", "万能激活卡");
        map.put("拥抱", "拥抱");

        printValues(map);
    }

    public static void printValues(Map map) {
        for (String value : map.values()) {
            System.out.println(value);
        }
    }
}

欢迎分享，转载请注明来源：内存溢出

原文地址: http://outofmemory.cn/zaji/5434930.html

java学习笔记20（Lambda表达式、函数式编程、流式计算、练习）

发表评论

评论列表（0条）