• 13-JavaSE基础巩固练习：ArrayList集合的练习

    集合综合练习

    1、集合的遍历方式

    • 需求：

      • 定义一个集合，添加字符串，并进行遍历。
      • 遍历格式参照：
        • [元素1, 元素2, 元素3]

    • 分析：

      • 需要一个集合，类型是字符串，用于存储字符串类型的元素。
      • 需要添加一些元素进集合中。
      • 需要遍历集合，依次获取每个元素并按照指定格式输出。

    • 实现：

      package com.app.demo22_array_list;

import java.util.ArrayList;

/*
    集合综合练习：集合的遍历方式
        需求：
            定义一个集合，添加字符串，并进行遍历。
            遍历格式参照：
              [元素1, 元素2, 元素3]
 */
public class ArrayListDemo1 {
    public static void main(String[] args) {
        // 1、定义一个字符串类型的集合，用于存储一些字符串类型的数据
        ArrayList<String> list = new ArrayList<>();

        // 2、往集合里添加数据
        list.add("你真是老6");
        list.add("Hello World!");
        list.add("甄姬");

        // 3、遍历集合
        System.out.print("[");
        for (int i = 0; i < list.size(); i++) {
            System.out.print(i == list.size() - 1 ? list.get(i) + "]\n" : list.get(i) + ", ");
        }
    }
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23
      • 24
      • 25
      • 26
      • 27
      • 28
      [你真是老6, Hello World!, 甄姬]

Process finished with exit code 0


      • 1
      • 2
      • 3
      • 4
    2、添加数字并遍历

    • 需求：

      • 定义一个集合，添加数字，并进行遍历。
      • 遍历格式参照：
        • [元素1, 元素2, 元素3]

    • 分析：

      • 需要定义Integer类型、Double类型的集合，用于存储数字数据。
      • 需要添加一些元素进集合中。
      • 需要遍历集合，查看集合所有元素。

    • 实现：

      package com.app.demo22_array_list;

import java.util.ArrayList;

/*
    集合综合练习：添加数字并遍历
        需求：
            定义一个集合，添加数字，并进行遍历。
            遍历格式参照：
                [元素1, 元素2, 元素3]
 */
public class ArrayListDemo2 {
    public static void main(String[] args) {
        // 1、定义Integer类型、Double类型的集合，用于存储数字数据
        ArrayList<Integer> numbers = new ArrayList<>();
        ArrayList<Double> scores = new ArrayList<>();

        // 2、添加整数进numbers集合
        numbers.add(12);
        numbers.add(45);
        numbers.add(22);
        numbers.add(1000);
        numbers.add(9);

        // 3、添加小数进scores集合
        scores.add(66.5);
        scores.add(100.0);
        scores.add(99.5);
        scores.add(59.5);

        // 4、遍历集合，查看集合所有元素
        System.out.print("numbers: [");
        for (int i = 0; i < numbers.size(); i++) {
            System.out.print(i == numbers.size() - 1 ? numbers.get(i) + "]\n" : numbers.get(i) + ", ");
        }

        System.out.print("scores: [");
        for (int i = 0; i < scores.size(); i++) {
            System.out.print(i == scores.size() - 1 ? scores.get(i) + "]\n" : scores.get(i) + ", ");
        }
    }
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23
      • 24
      • 25
      • 26
      • 27
      • 28
      • 29
      • 30
      • 31
      • 32
      • 33
      • 34
      • 35
      • 36
      • 37
      • 38
      • 39
      • 40
      • 41
      • 42
      numbers: [12, 45, 22, 1000, 9]
scores: [66.5, 100.0, 99.5, 59.5]

Process finished with exit code 0


      • 1
      • 2
      • 3
      • 4
      • 5
    3、添加学生对象并遍历

    • 需求：

      • 定义一个集合，添加一些学生对象，并进行遍历。
      • 学生类的属性为：
        • 姓名、年龄。

    • 分析：

      • 需要一个学生类对象，用于将学生信息封装成一个学生对象。
      • 需要一个学生对象类型的集合，用于存储每个学生对象。
      • 需要遍历集合，查看所有学生对象的信息。

    • 实现：

      package com.app.demo23_array_list_custom_type;

/*
    学生类
 */
public class Student {
    // 定义学生属性：姓名、年龄
    private String name;
    private int age;

    // 有参、无参构造器
    public Student() {

    }
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // 提供全套的getXXX和setXXX方法，暴露其属性的取值和赋值
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    // 重写toString，格式化输出学生对象的属性值
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23
      • 24
      • 25
      • 26
      • 27
      • 28
      • 29
      • 30
      • 31
      • 32
      • 33
      • 34
      • 35
      • 36
      • 37
      • 38
      • 39
      • 40
      • 41
      • 42
      • 43
      • 44
      • 45
      package com.app.demo23_array_list_custom_type;

import java.util.ArrayList;
import java.util.Scanner;

/*
    集合综合练习：添加学生对象并遍历
        需求：
          定义一个集合，添加一些学生对象，并进行遍历。
          学生类的属性为：
             姓名、年龄。
 */
public class StudentTest {
    public static void main(String[] args) {
        // 1、定义一个学生对象类型的集合，用于存储学生对象
        ArrayList<Student> students = new ArrayList<>();

        // 2、创建学生对象，并添加进students集合中
        addStudent(students);

        // 3、遍历students集合，查看所有学生对象的信息
        showStudents(students);
    }



    /**
     * 添加学生信息
     *
     * @param students      学生对象集合
     */
    public static void addStudent(ArrayList<Student> students) {
        // 1、判断students是否为null
        if (students == null) {
            System.out.println("您的学生对象集合为null~");
            return;
        }

        System.out.println("--------录入学生信息界面--------");
        // 2、从键盘录入学生信息：姓名、年龄
        Scanner sc = new Scanner(System.in);
        System.out.println("请您录入学生的姓名：");
        String name = sc.next();
        System.out.println("请您录入学生的年龄：");
        int age = sc.nextInt();

        // 3、将从键盘录入的学生信息封装成学生对象并添加到集合中
        students.add(new Student(name, age));
        System.out.println("学生" + name + "的信息已成功录入！");

        // 4、问一下是否还要继续录入学生信息
        isContinue(students, sc);
    }


    /**
     * 问一下是否要继续录入
     *
     * @param students      学生对象集合
     * @param sc            键盘录入对象
     */
    public static void isContinue(ArrayList<Student> students, Scanner sc) {
        // 1、判断sc是否为null
        if (sc == null) {
            System.out.println("您的键盘录入对象为null~");
            return;
        }

        // 2、问一下是否要继续录入
        System.out.println("您是否还要继续录入？(yes/no)：");
        String command = sc.next();
        switch (command) {
            case "yes":
                // 输入的是yes，回调addStudent方法，继续录入
                addStudent(students);
                break;
            default:
                // 输入的是其他，结束录入
                System.out.println("好的！");
                break;
        }
    }


    /**
     * 查看所有学生对象的信息
     *
     * @param students   学生对象集合
     */
    public static void showStudents(ArrayList<Student> students) {
        // 2、遍历students集合，依次获取集合中的每个学生对象
        System.out.println("\n学生信息如下：");
        for (Student student : students) {
            // 依次查看学生对象信息
            System.out.println("姓名：" + student.getName() + "\t" + "年龄：" + student.getAge() + "岁");
        }
    }
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23
      • 24
      • 25
      • 26
      • 27
      • 28
      • 29
      • 30
      • 31
      • 32
      • 33
      • 34
      • 35
      • 36
      • 37
      • 38
      • 39
      • 40
      • 41
      • 42
      • 43
      • 44
      • 45
      • 46
      • 47
      • 48
      • 49
      • 50
      • 51
      • 52
      • 53
      • 54
      • 55
      • 56
      • 57
      • 58
      • 59
      • 60
      • 61
      • 62
      • 63
      • 64
      • 65
      • 66
      • 67
      • 68
      • 69
      • 70
      • 71
      • 72
      • 73
      • 74
      • 75
      • 76
      • 77
      • 78
      • 79
      • 80
      • 81
      • 82
      • 83
      • 84
      • 85
      • 86
      • 87
      • 88
      • 89
      • 90
      • 91
      • 92
      • 93
      • 94
      • 95
      • 96
      • 97
      • 98
      --------录入学生信息界面--------
请您录入学生的姓名：
张飞
请您录入学生的年龄：
29
学生张飞的信息已成功录入！
您是否还要继续录入？(yes/no)：
yes
--------录入学生信息界面--------
请您录入学生的姓名：
关羽
请您录入学生的年龄：
30
学生关羽的信息已成功录入！
您是否还要继续录入？(yes/no)：
yes
--------录入学生信息界面--------
请您录入学生的姓名：
甄姬
请您录入学生的年龄：
24
学生甄姬的信息已成功录入！
您是否还要继续录入？(yes/no)：
no
好的！

学生信息如下：
姓名：张飞	年龄：29岁
姓名：关羽	年龄：30岁
姓名：甄姬	年龄：24岁

Process finished with exit code 0


      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23
      • 24
      • 25
      • 26
      • 27
      • 28
      • 29
      • 30
      • 31
      • 32
      • 33
    4、添加用户对象并判断是否存在

    • 需求：

      • 定义一个集合，存入三个用户对象。
      • 用户属性为：id、username、password
      • 定义一个方法，根据id查找对应的用户信息：
        • 如果存在，返回true。
        • 如果不存在，返回false。

    • 分析：

      • 需要一个用户类对象，用于将录入的用户信息封装成一个用户对象。
      • 需要一个用户类型的集合，用于存储用户对象。
      • 需要一个方法，根据id查找对应的用户信息：
        • 如果存在，返回true，否则返回false。

    • 实现：

      package com.app.demo23_array_list_custom_type;

/*
    用户类
 */
public class User {
    // 定义用户属性：id、用户名、密码
    private String id;
    private String name;
    private String password;

    // 提供有参、无参数构造器
    public User() {
    }

    public User(String id, String name, String password) {
        this.id = id;
        this.name = name;
        this.password = password;
    }

    // 提供全套的get、set方法，暴露其属性的取值和赋值
    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }


    /*
        重写toString方法，格式化输出用户对象的信息
     */
    @Override
    public String toString() {
        return "User{" +
                "id='" + id + '\'' +
                ", name='" + name + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23
      • 24
      • 25
      • 26
      • 27
      • 28
      • 29
      • 30
      • 31
      • 32
      • 33
      • 34
      • 35
      • 36
      • 37
      • 38
      • 39
      • 40
      • 41
      • 42
      • 43
      • 44
      • 45
      • 46
      • 47
      • 48
      • 49
      • 50
      • 51
      • 52
      • 53
      • 54
      • 55
      • 56
      • 57
      • 58
      • 59
      package com.app.demo23_array_list_custom_type;

import java.util.ArrayList;
import java.util.Scanner;

/*
    集合综合练习：添加用户对象并判断是否存在
        需求：
           定义一个集合，存入三个用户对象。
           用户属性为：id、username、password
           定义一个方法，根据id查找对应的用户信息：
              如果存在，返回true。
              如果不存在，返回false。
 */
public class UserTest {
    public static void main(String[] args) {
        // 1、定义集合，类型为用户对象，用于存储用户对象
        ArrayList<User> users = new ArrayList<>();

        // 2、添加用户：从键盘录入用户信息，封装成用户对象并添加到集合中
        addUsers(users);

        // 3、查看所有用户信息
        showUsers(users);

        /*
          4、查询指定用户是否存在：
            从键盘录入用户的id，根据该id查询该用户是否存在集合中？
            存在返回true，否则返回false
         */
        // 输入要查询的用户的id
        System.out.println("------根据id查询用户是否存在------");
        Scanner sc = new Scanner(System.in);
        System.out.println("请您输入要查询的用户的id：");
        String inputId = sc.next();
        // 根据输入的id，判断该用户是否存在
        boolean flag = isExist(users, inputId);
        System.out.println("id为" + inputId + "的用户是否存在：" + flag);
    }


    /**
     * 根据id查询用户
     *
     * @param users     用户对象集合
     * @param inputId   要查询的用户id
     * @return          用户存在返回true，否则返回false
     */
    public static boolean isExist(ArrayList<User> users, String inputId) {
        // 2、遍历集合，依次获取集合中每个用户对象
        for (User user : users) {
            // 依次判断输入的id 是否与 当前用户的id一样
            if (inputId.equals(user.getId())) {
                // 一样，说明存在，返回true
                return true;
            }
        }

        // 3、遍历结束，说明仍然找不到对应id的用户，说明不存在。返回false
        return false;
    }


    /**
     * 查看所有用户信息
     *
     * @param users     用户对象集合
     */
    public static void showUsers(ArrayList<User> users) {
        // 1、判断users是否为null
        if (users == null) {
            System.out.println("您的用户对象集合为null~");
            return;
        }

        // 2、遍历users，依次获取集合中每个用户对象
        System.out.println("\n用户信息如下：");
        for (User user : users) {
            System.out.println("id：" + user.getId()
                    + "\t用户名：" + user.getName()
                    + "\t密码：" + user.getPassword());
        }
    }


    /**
     * 添加用户信息
     *
     * @param users     用户对象集合
     */
    public static void addUsers(ArrayList<User> users) {
        // 1、判断users是否为null
        if (users == null) {
            System.out.println("您的用户对象集合为null~");
            return;
        }

        // 2、从键盘录入用户信息
        System.out.println("-------录入用户信息界面-------");
        Scanner sc = new Scanner(System.in);

        while (true) {
            System.out.println("请您录入用户的id：");
            String id = sc.next();

            // 判断用户id是否已经存在
            boolean flag = isExist(users, id);
            if (flag) {
                System.out.println("该用户id已存在，请重新录入！");
            }else {
                System.out.println("请您录入用户的名称：");
                String username = sc.next();
                System.out.println("请您录入用户的密码：");
                String password = sc.next();

                // 3、将录入的用户信息封装成用户对象，并添加进集合中
                users.add(new User(id, username, password));
                System.out.println("id为" + id + "的用户已成功录入！");

                // 4、问一下是否要继续录入用户信息
                isContinue(users, sc);
                break;
            }
        }
    }


    /**
     * 问一下是否要继续录入用户信息
     *
     * @param users     用户对象集合
     * @param sc        键盘录入对象
     */
    public static void isContinue(ArrayList<User> users, Scanner sc) {
        // 1、判断users是否为null
        if (users == null) {
            System.out.println("您的用户对象集合为null~");
            return;
        }

        // 2、判断sc是否为null
        if (sc == null) {
            System.out.println("您的键盘录入对象为null~");
            return;
        }

        // 3、问一下是否要继续录入用户信息
        System.out.println("您是否要继续录入？(yes/no)：");
        String command = sc.next();
        switch (command) {
            case "yes":
                // 输入的是yes，回调addUsers方法，继续录入用户信息
                addUsers(users);
                break;
            default:
                // 输入的是其他，结束录入
                System.out.println("好的！");
                break;
        }
    }
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23
      • 24
      • 25
      • 26
      • 27
      • 28
      • 29
      • 30
      • 31
      • 32
      • 33
      • 34
      • 35
      • 36
      • 37
      • 38
      • 39
      • 40
      • 41
      • 42
      • 43
      • 44
      • 45
      • 46
      • 47
      • 48
      • 49
      • 50
      • 51
      • 52
      • 53
      • 54
      • 55
      • 56
      • 57
      • 58
      • 59
      • 60
      • 61
      • 62
      • 63
      • 64
      • 65
      • 66
      • 67
      • 68
      • 69
      • 70
      • 71
      • 72
      • 73
      • 74
      • 75
      • 76
      • 77
      • 78
      • 79
      • 80
      • 81
      • 82
      • 83
      • 84
      • 85
      • 86
      • 87
      • 88
      • 89
      • 90
      • 91
      • 92
      • 93
      • 94
      • 95
      • 96
      • 97
      • 98
      • 99
      • 100
      • 101
      • 102
      • 103
      • 104
      • 105
      • 106
      • 107
      • 108
      • 109
      • 110
      • 111
      • 112
      • 113
      • 114
      • 115
      • 116
      • 117
      • 118
      • 119
      • 120
      • 121
      • 122
      • 123
      • 124
      • 125
      • 126
      • 127
      • 128
      • 129
      • 130
      • 131
      • 132
      • 133
      • 134
      • 135
      • 136
      • 137
      • 138
      • 139
      • 140
      • 141
      • 142
      • 143
      • 144
      • 145
      • 146
      • 147
      • 148
      • 149
      • 150
      • 151
      • 152
      • 153
      • 154
      • 155
      • 156
      • 157
      • 158
      • 159
      • 160
      • 161
      -------录入用户信息界面-------
请您录入用户的id：
ha001
请您录入用户的名称：
zhangsan
请您录入用户的密码：
123abc
id为ha001的用户已成功录入！
您是否要继续录入？(yes/no)：
yes
-------录入用户信息界面-------
请您录入用户的id：
ha001
该用户id已存在，请重新录入！
请您录入用户的id：
ha001
该用户id已存在，请重新录入！
请您录入用户的id：
ha002
请您录入用户的名称：
lisi
请您录入用户的密码：
abc123
id为ha002的用户已成功录入！
您是否要继续录入？(yes/no)：
yes
-------录入用户信息界面-------
请您录入用户的id：
ha002
该用户id已存在，请重新录入！
请您录入用户的id：
ha003
请您录入用户的名称：
wangwu
请您录入用户的密码：
123456
id为ha003的用户已成功录入！
您是否要继续录入？(yes/no)：
no
好的！

用户信息如下：
id：ha001	用户名：zhangsan	密码：123abc
id：ha002	用户名：lisi	密码：abc123
id：ha003	用户名：wangwu	密码：123456
------根据id查询用户是否存在------
请您输入要查询的用户的id：
ha004
id为ha004的用户是否存在：false

Process finished with exit code 0


      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23
      • 24
      • 25
      • 26
      • 27
      • 28
      • 29
      • 30
      • 31
      • 32
      • 33
      • 34
      • 35
      • 36
      • 37
      • 38
      • 39
      • 40
      • 41
      • 42
      • 43
      • 44
      • 45
      • 46
      • 47
      • 48
      • 49
      • 50
      • 51
      • 52
      -------录入用户信息界面-------
请您录入用户的id：
001
请您录入用户的名称：
zhangfei
请您录入用户的密码：
123123
id为001的用户已成功录入！
您是否要继续录入？(yes/no)：
yes
-------录入用户信息界面-------
请您录入用户的id：
001
该用户id已存在，请重新录入！
请您录入用户的id：
002
请您录入用户的名称：
guanyu
请您录入用户的密码：
123abc
id为002的用户已成功录入！
您是否要继续录入？(yes/no)：
no
好的！

用户信息如下：
id：001	用户名：zhangfei	密码：123123
id：002	用户名：guanyu	密码：123abc
------根据id查询用户是否存在------
请您输入要查询的用户的id：
002
id为002的用户是否存在：true

Process finished with exit code 0


      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23
      • 24
      • 25
      • 26
      • 27
      • 28
      • 29
      • 30
      • 31
      • 32
      • 33
      • 34
      • 35
    5、添加手机对象并返回要求的数据

    • 需求：

      • 定义手机类对象：
        • 手机属性：品牌、价格。
      • 定义一个集合，存入三个手机对象。
      • 分别为：小米，1000；苹果，8000。锤子，2999。
      • 定义一个方法，将价格低于3000的手机信息返回。

    • 分析：

      • 需要一个手机类对象，用于将录入的手机信息封装成一个手机对象。
      • 需要一个手机对象类型的集合，用于存储手机对象。
      • 需要录入手机对象到集合中。
      • 需要一个方法，将价格低于3000的手机信息返回。

    • 实现：

      package com.app.demo23_array_list_custom_type;

/*
    手机类
 */
public class Phone {
    // 定义手机的属性：品牌、价格
    private String brand;
    private double price;

    public Phone() {
    }

    public Phone(String brand, double price) {
        this.brand = brand;
        this.price = price;
    }

    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    @Override
    public String toString() {
        return "Phone{" +
                "brand='" + brand + '\'' +
                ", price=" + price +
                '}';
    }
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23
      • 24
      • 25
      • 26
      • 27
      • 28
      • 29
      • 30
      • 31
      • 32
      • 33
      • 34
      • 35
      • 36
      • 37
      • 38
      • 39
      • 40
      • 41
      • 42
      package com.app.demo23_array_list_custom_type;

import java.util.ArrayList;
import java.util.Scanner;

/*
    集合综合练习：添加手机对象并返回要求的数据
        需求：
          定义手机类对象：
             手机属性：品牌、价格。
          定义一个集合，存入三个手机对象。
          分别为：小米，1000；苹果，8000。锤子，2999。
          定义一个方法，将价格低于3000的手机信息返回。
 */
public class PhoneTest {
    public static void main(String[] args) {
        // 1、定义一个手机对象类型的集合，用于存储手机对象
        ArrayList<Phone> phones = new ArrayList<>();

        // 2、添加手机信息：从键盘录入手机的品牌、价格并封装成一个手机对象添加进集合中
        addPhone(phones);

        // 3、查看所有手机信息
        System.out.println("\n手机信息如下：");
        showPhones(phones);

        // 4、将价格低于3000的手机信息返回
        ArrayList<Phone> newPhones = judgePrice(phones);
        System.out.println("所有低于指定价格的手机信息如下：");
        showPhones(newPhones);
    }


    /**
     * 获取低于指定价格的手机对象(多个数据)
     * 技巧：如果我们要返回多个数据，可以把这些数据先放到一个容器当中，再把容器返回
     * 容器可以是集合、数组（推荐使用集合）
     *
     * @param phones        手机对象集合
     * @return              返回低于指定价格的手机对象集合
     */
    public static ArrayList<Phone> judgePrice(ArrayList<Phone> phones) {
        // 1、判断phones是否为null
        if (phones == null) {
            System.out.println("您的手机对象集合不能为null~");
            return null;
        }

        // 2、定义一个手机对象类型的集合，用于存储所有低于指定价格的手机对象
        ArrayList<Phone> newPhones = new ArrayList<>();

        // 3、输入指定价格
        System.out.println("-----查看所有低于指定价格的手机信息-----");
        Scanner sc = new Scanner(System.in);
        while (true) {
            System.out.println("请您输入指定价格：");
            double price = sc.nextDouble();
            // 3、判断price是否大于0
            if (price > 0) {
                // a.遍历phones，依次获取集合中每个手机对象
                for (Phone phone : phones) {
                    // b.判断当前获取到的手机对象的价格 是否小于 指定价格
                    if (phone.getPrice() < price) {
                        // 小于，则将该手机对象添加进newPhones集合中
                        newPhones.add(phone);
                    }
                }
                // c.循环结束，说明所有低于指定价格的手机对象已存入newPhones集合中了，将该集合返回
                return newPhones;

            }else {
                System.out.println("您输入的指定价格不合理！请重新输入~");
            }
        }
    }


    /**
     * 查看所有手机信息
     *
     * @param phones    手机对象集合
     */
    public static void showPhones(ArrayList<Phone> phones) {
        // 1、判断phones是否为null
        if (phones == null) {
            System.out.println("您的手机对象集合不能为null~");
            return;
        }

        // 2、遍历phones，依次获取集合中每个手机对象
        for (Phone phone : phones) {
            System.out.println("品牌：" + phone.getBrand() + "\t价格：" + phone.getPrice());
        }
    }


    /**
     * 录入手机信息
     *
     * @param phones    手机对象集合
     */
    public static void addPhone(ArrayList<Phone> phones) {
        // 1、判断phones是否为null
        if (phones == null) {
            System.out.println("您的手机对象集合不能为null~");
            return;
        }

        // 2、从键盘录入手机信息：品牌、价格
        System.out.println("-----录入手机信息-----");
        Scanner sc = new Scanner(System.in);
        System.out.println("请您录入手机的品牌：");
        String brand = sc.next();
        while (true) {
            System.out.println("请您录入手机的价格：");
            double price = sc.nextDouble();

            // 判断价格是否大于等于0
            if (price >= 0) {
                // 价格合理，将手机信息封装成手机对象，并添加进集合中
                phones.add(new Phone(brand, price));
                System.out.println("品牌为" + brand + "的手机录入成功！");
                break;
            }else {
                System.out.println("价格不合理！请重新录入~");
            }
        }

        // 3、循环结束，说明手机信息录入完成，问一下是否还要继续录入手机信息
        isContinue(phones, sc);
    }


    /**
     * 问一下是否要继续录入手机信息
     *
     * @param phones        手机对象集合
     * @param sc            键盘录入对象
     */
    public static void isContinue(ArrayList<Phone> phones, Scanner sc) {
        // 1、判断phones和sc是否都为null
        if (phones == null && sc == null) {
            System.out.println("您的手机对象集合与键盘录入对象都不能为null~");
            return;
        }else if (sc == null){
            // 2、判断键盘录入对象是否为null
            System.out.println("您的键盘录入对象不能为null~");
            return;
        } else if (phones == null){
            // 3、判断手机对象集合是否为null
            System.out.println("您的手机对象集合不能为null~");
            return;
        }

        // 4、问一下是否要继续录入手机信息
        System.out.println("您是否要继续录入？(yes/no)：");
        String command = sc.next();
        switch (command) {
            case "yes":
                // 输入的是yes，回调addPhone方法，继续录入手机信息
                addPhone(phones);
                break;
            default:
                // 输入的是其他，结束录入
                System.out.println("好的！");
                break;
        }
    }
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23
      • 24
      • 25
      • 26
      • 27
      • 28
      • 29
      • 30
      • 31
      • 32
      • 33
      • 34
      • 35
      • 36
      • 37
      • 38
      • 39
      • 40
      • 41
      • 42
      • 43
      • 44
      • 45
      • 46
      • 47
      • 48
      • 49
      • 50
      • 51
      • 52
      • 53
      • 54
      • 55
      • 56
      • 57
      • 58
      • 59
      • 60
      • 61
      • 62
      • 63
      • 64
      • 65
      • 66
      • 67
      • 68
      • 69
      • 70
      • 71
      • 72
      • 73
      • 74
      • 75
      • 76
      • 77
      • 78
      • 79
      • 80
      • 81
      • 82
      • 83
      • 84
      • 85
      • 86
      • 87
      • 88
      • 89
      • 90
      • 91
      • 92
      • 93
      • 94
      • 95
      • 96
      • 97
      • 98
      • 99
      • 100
      • 101
      • 102
      • 103
      • 104
      • 105
      • 106
      • 107
      • 108
      • 109
      • 110
      • 111
      • 112
      • 113
      • 114
      • 115
      • 116
      • 117
      • 118
      • 119
      • 120
      • 121
      • 122
      • 123
      • 124
      • 125
      • 126
      • 127
      • 128
      • 129
      • 130
      • 131
      • 132
      • 133
      • 134
      • 135
      • 136
      • 137
      • 138
      • 139
      • 140
      • 141
      • 142
      • 143
      • 144
      • 145
      • 146
      • 147
      • 148
      • 149
      • 150
      • 151
      • 152
      • 153
      • 154
      • 155
      • 156
      • 157
      • 158
      • 159
      • 160
      • 161
      • 162
      • 163
      • 164
      • 165
      • 166
      • 167
      • 168
      • 169
      -----录入手机信息-----
请您录入手机的品牌：
小米
请您录入手机的价格：
-1
价格不合理！请重新录入~
请您录入手机的价格：
1000
品牌为小米的手机录入成功！
您是否要继续录入？(yes/no)：
yes
-----录入手机信息-----
请您录入手机的品牌：
苹果
请您录入手机的价格：
8000
品牌为苹果的手机录入成功！
您是否要继续录入？(yes/no)：
yes
-----录入手机信息-----
请您录入手机的品牌：
锤子
请您录入手机的价格：
2999
品牌为锤子的手机录入成功！
您是否要继续录入？(yes/no)：
no
好的！

手机信息如下：
品牌：小米	价格：1000.0
品牌：苹果	价格：8000.0
品牌：锤子	价格：2999.0
-----查看所有低于指定价格的手机信息-----
请您输入指定价格：
-1
您输入的指定价格不合理！请重新输入~
请您输入指定价格：
3000
所有低于指定价格的手机信息如下：
品牌：小米	价格：1000.0
品牌：锤子	价格：2999.0

Process finished with exit code 0


      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23
      • 24
      • 25
      • 26
      • 27
      • 28
      • 29
      • 30
      • 31
      • 32
      • 33
      • 34
      • 35
      • 36
      • 37
      • 38
      • 39
      • 40
      • 41
      • 42
      • 43
      • 44
      • 45
  • 相关阅读:
    论文阅读笔记 | 三维目标检测——PointRCNN
    深入Python网络编程：从基础到实践
    【校招VIP】java开源框架之Zookeeper
    开源软件的国际化和本地化
    SAS|lag和dif函数
    【校招VIP】产品行测能力之数图问题
    ZMQ协议
    AntiSamy：防 XSS 攻击的一种解决方案使用教程
    Typescript 笔记：初识Typescript
    python使用cv2获取截图中的匹配项目的中心位置
  • 原文地址：https://blog.csdn.net/yelitoudu/article/details/127853000