视频链接：Java入门-01-Java学习介绍

阿玮老师讲的是真的详细！！！

01 Java概述

1、JAVA安装

（此部分不做详细介绍）三步走：

• 下载
• 安装
• 环境变量

1、下载

官网：Java Downloads | Oracle

2、安装

下载好exe文件，直接安装，无脑点击下一步即可。

之后验证是否安装成功，打开cmd，输入java -version进行测试

3、配置环境变量

• 新建JAVA_HOME变量：用于说明JDK的安装目录
• 修改系统环境变量Path，追加%JAVA_HOME%\bin

备注：如果不行的话，可以考虑直接用绝对路径

知识补充：

• 了解JDK的安装目录

2、HelloWorld

• javac：编译。javac是JDK提供的编译工具

• java：运行。java是JDK提供的工具

public class HelloWorld {
	public static void main(String[] args) {
		System.out.println("Hello World!");
	}
}

3、JAVA概述

3.1 JAVA的发展

java版本更新比较快，其版本分为两种：

• 过度版本
• LST：长期支持版本，如JAVA8和JAVA11

3.2JAVA可以做什么

JAVA三大使用平台（JAVA的三大类）

• JAVA SE
• JAVA ME
• JAVA EE

3.2.1 JAVA SE

3.2.2 JAVA ME

JAVA ME 已经没落了，但华为鸿蒙系统等还是可以用JAVA开发。

3.2.3 JAVA EE

服务器开发，JAVA就是天。

3.2.4 总结

4、JAVA跨平台的原理

5、JDK与JRE

5.1 JDK

JDK（Java Development kit，java开发工具包）由一下几部分构成

• JVM：Java虚拟机，真正运行Java程序的地方
• 核心类库
• 开发工具

5.2 JRE

JRE是Java运行环境。

当我们已经写完代码编译好了，需要传给别人时，我们并不需要完整的JDK。

5.3 Other

临时拓展：06 Python面向对象与JAVA面向对象

说到面向对象（OOP：Object Oriented Programming）就要先说面向过程(Procedure-Oriented Programming)

• 面向过程就是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了。

• 面向对象是把整个需求按照特点、功能划分，将这些存在共性的部分封装成对象，创建对象不是为了完成某一个步骤，而是描述某个事物在解决问题的步骤中的行为。

编程的思想是非常重要的,编程只是一个工具。

02 基础语法

大纲：

• JAVA入门
• 小概念
• Idea和运算符
• 判断和循环
• 方法
• 数组
• 斯坦福大学练习题

1、注释

注释内容不参与编译和运行

2、关键字

关键字：被Java赋予了特殊涵义的单词

总结：

3、字面量

4、变量

小练习：

题意：公交车问题，每一站会上下乘客，用变量去计算，并输出最后在终点站剩余的乘客

public class BusProblem{
	public static void main(String[] args){
		int count = 0;
		count = count + 1;
		System.out.println(count);
		count = count + 2 - 1;
		count = count + 1;
		System.out.println(count);
	}
}

输出展示：

1
3

5、计算机中的数据存储

本节通过了解文字、图片、声音在计算机中的存储形式，进而学习计算机中的数据存储

5.1 进制

示例代码：

public class PrintSystem{
	public static void main(String[] args){
		System.out.println(0b101);
		System.out.println(17);
		System.out.println(0761);
		System.out.println(0xabc);
	}
}

输出展示：

5
17
497
2748

补充：Java中print 和 println区别

区别是：print()输出完毕后不换行，而println()输出完毕后会换行，因此println()不输出任何东西时，就输出一个换行符。

5.2 计算机为什么用二进制

以前计算机采用打孔的形式（左图），只有有孔和无孔两个状态。这个形式现在依旧存在，当前常用的5V电路板中，我们将大于3.3V定义为1，小于3.3V定义为0。

5.3 进制转换

5.3.1 任意进制转十进制

任意进制转十进制公式：系数 * 基础的权次幂，相加

二进制转十进制有个快速转换法：8421快速转换法

• 每一位二进制的1都代表一个固定值，那把每一位的1代表的十进制数加起来即可，示例如下：

5.3.2 十进制转其他进制

5.4 计算机的存储规则

计算机中，任何数据都是以二进制的形式存储的

5.4.1 文字：数字、英文、汉字

一、一个数字是怎么存储的？

以二进制的形式在计算机中存储。

二、那英文或者字符怎么存储呢？

三、那汉字怎么存储呢？

Unicode编码，万国码

5.4.2 图片

常见的三类图片：黑白图、灰度图、彩色图。

这里直接说彩色图了，如1080p的分辨率就是1920×1080，也就是显示1920×1080个像素点，而每个像素点可以基于光学三原色，也就是RGB值表示，R、G、B三个数值对应0~255的其中一个整数，进而我们可以用数字表示图片。

5.4.3 声音

声音数据可以用波形图表示，进而用数据表示

6、数据类型

JAVA语言的数据类型分为：基本数据类型、引用数据类型。本节我们只讲述前者。

基本数据类型：四类八种

定义bool类型数据时，用关键词boolean

注意事项：

1、long

定义long类型时需注意：

不加的话，终端会报错。

2、float与double

float需要加后缀，double不用

小结：

练习：输出老师信息

public class TeacherIntroduce{
	public static void main(String[] args){
		String name = "黑马程序员";
		System.out.println(name);
		int age = 18;
		System.out.println(age);
		char sex = '男';
		System.out.println(sex);
		double height = 180.1;
		System.out.println(height);
		boolean single = true;
		System.out.println(single);
	}
}

错误: 编码GBK的不可映射字符

javac 默认按照本机语言（GBK） 编译代码，而我们的代码是 utf-8 编码，所以会报错

这里提供三种解决方法：

• 方法一：运行是指定编码格式 javac -encoding UTF-8 xxx.java
• 方法二：更改java源文件编码格式
• 方法三：删除中文

7、标识符

标识符：就是给类、方法、变量等起的名字

8、键盘录入

示例代码：

// 1、导包
import java.util.Scanner;

public class ScannerDemo{
	public static void main(String[] args){
		// 2、创建对象，表示我们准备要用Scanner这个类
		Scanner port = new Scanner(System.in);
		System.out.print("请输入数字：");
		// 3、接收数据
		int i = port.nextInt();
		System.out.println(i);
	}
}

后续编程时需注意：我们定义的变量是int型，此时只能输入数字，其他的会报错

请输入数字：afsf
Exception in thread "main" java.util.InputMismatchException
        at java.util.Scanner.throwFor(Unknown Source)
        at java.util.Scanner.next(Unknown Source)
        at java.util.Scanner.nextInt(Unknown Source)
        at java.util.Scanner.nextInt(Unknown Source)
        at ScannerDemo.main(ScannerDemo.java:10)

补充：

9、关于IDEA

9.1 安装

官网链接：https://www.jetbrains.com/idea/download/

视频教程：Java基础概念-12-idea的概述和下载安装

9.2 IDEA项目结构介绍

• project：项目
• module：模块
• package：包
• class：类

IDEA用法：Java基础概念-13-idea中的第一个代码

示例代码：

package day1.code;

public class Hello {
    public static void main(String[] args){
        System.out.println("HelloWorld");
    }
}

10、运算符

什么是运算符？什么是表达式？

运算符种类：

• 算数运算符
• 自增自减运算符
• 赋值运算符
• 关系运算符
• 逻辑运算符
• 三元运算符
• 运算符优先级

10.1 算数运算符

• /
  • 注意，想得到小数，必须有浮点数参与运算
  • System.out.println(10 / 3); // 3
  • System.out.println(10.0 / 3); // 3.3333333333333335
  • System.out.println(10.0 / 3.0); // 3.3333333333333335
• % 取余、取模

10.1.1 隐式转换和强制转换

数字进行运算时，数据类型不一样是不能运算的

类型转换分类

• 隐式转换（自动类型提升）：取值范围小 --> 取值范围大
• 强制转换：取值范围大 --> 取值范围小

10.1.1.1 隐式转换

示例代码：

public class ArithmeticOperator01 {
    public static void main(String[] args) {
        int a = 10;
        double b = 10.1;
        double c = a + b;
        System.out.println(a + b);  // 20.1
        System.out.println(c);  // 20.1
    }
}

小练习：

小结：

10.1.1.2 强制转换

注意，超过范围结果会错误：

• 程序不报错，但结果是错误的

int d = 300;
byte e = (byte) d;
System.out.println(e);  // 44

小练习：

注意，细节决定成败：

byte a1 = 10;
        byte a2 = 20;
        byte result1 = (byte) (a1 + a2); // 错误写法：byte result3 = (byte) a1 + (byte) a2;
        System.out.println(result1);  // 30
        byte b1 = 100;
        byte b2 = 100;
        byte result2 = (byte) (b1 + b2);  
        System.out.println(result2);  // -56 超出范围，结果错误

10.1.2 字符串和字符的加操作

一、字符串的加操作

小练习：

二、字符 + 数字

示例代码：

System.out.println(1 + 'a');  // 98

10.2 自增自减运算符

• ++

---

10.2.1 单独使用时

无论放变量前面还是后面，结果一样，示例代码如下：

// 单独使用时，无论放变量前面还是后面，结果一样
        int temp = 10;
        temp++;
        System.out.println(temp);  // 11
        ++temp;
        System.out.println(temp);  // 12
        
        // 不是单独使用时
        int temp2 = 10;
        System.out.println(temp2++);  // 10
        System.out.println(++temp2);  // 12

10.2.2 参与计算时

这里一定要小心，多观察下面的示例代码及结果，示例代码如下：

int t1 = 100;
int t2 = t1++;
System.out.println(t2);  // 100
System.out.println(t1);  // 101 注意t1自身也发生了变化

int t3 = 100;
int t4 = ++t3;
System.out.println(t4);  // 101
System.out.println(t3);  // 101

10.3 赋值运算符

注意：

10.4 关系运算符

练习

输入两个整数（范围为1~10），分别代表1号和2号两个人的时髦程度，若1号大于2号则输出true，反之输出false。

import java.util.Scanner;

public class ArithmeticOperator02 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入1号的时髦度: ");
        int fashion1 = sc.nextInt();
        System.out.println("请输入2号的时髦度: ");
        int fashion2 = sc.nextInt();

        boolean result = fashion1 > fashion2;
        System.out.println(result);
    }
}

示例结果：

请输入1号的时髦度: 
4
请输入2号的时髦度: 
3
true

10.5 四种逻辑运算符 与 短路逻辑运算符

10.5.1 四种逻辑运算符号

10.5.2 短路逻辑运算符号

应用：

• 典型应用场景如我们登录QQ时，账号和密码均输入正确才能登录
• 我们需要做两个判断，但如果账号已经错了，就不需要再去验证密码是否正确了
• 这时候就可以用短路逻辑运算符。

10.6 三元运算符号

作用：可以进行判断，根据判断的结果得到不同的内容。

练习

利用三元运算符比较两个整数，相同则输出”相同“，不同则输出”不同“

import java.util.Scanner;

public class ArithmeticOperator03 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int num1 = sc.nextInt();
        int num2 = sc.nextInt();
        System.out.println(num1 == num2 ? "相同" : "不同");
    }
}

10.7 运算符优先级

比较多，关键点：小括号优先所有。

10.8 其他运算符

例子：

11、原码、反码、补码

视频教程：运算符-12-多学一招原码反码补码

• 原码：十进制数据的二进制表现形式，最左边是符号位，0为正，1为负
• 反码：正数的补码和反码是其本身，负数的反码是符号位保持不变，其余位置取反
• 补码：正数的补码和反码是其本身，负数的补码是其在反码的基础上+1

11.1 原码

原码：十进制数据的二进制表现形式，最左边是符号位，0为正，1为负

P： 为什么是8位数呢？

A：计算机中一个0或者一个1为一个比特位（bit），但一个bit表示的数太小了，所以我们将8个bit分成一组，称为一个字节（byte）。

这一点可能会有点晕，且看下文。

11.2 反码

下图中，-4 -1 = -5，如果你用原码，就回变成-3，与预期结果相反，如果用反码就没问题。

总结：

11.3 补码

12、流程控制语句

• 循序结构
• 分支结构
• 循环结构

12.1 顺序结构

12.2 分支结构

12.2.1 if

if的三种格式：

12.2.2 switch

示例：

public class Main {
    public static void main(String[] args) {
        int option = 1;
        switch (option) {
        case 1:
            System.out.println("Selected 1");
            break;
        case 2:
            System.out.println("Selected 2");
            break;
        case 3:
            System.out.println("Selected 3");
            break;
        }
    }
}

switch语句还可以匹配字符串。字符串匹配时，是比较“内容相等”。例如：

public class Main {
    public static void main(String[] args) {
        String fruit = "apple";
        switch (fruit) {
        case "apple":
            System.out.println("Selected apple");
            break;
        case "pear":
            System.out.println("Selected pear");
            break;
        case "mango":
            System.out.println("Selected mango");
            break;
        default:
            System.out.println("No fruit selected");
            break;
        }
    }
}

switch其他知识点：

• default的位置和省略
• case穿透
• switch新特性
• switch和if第三种格式各自的使用场景

一、default的位置和省略

二、case穿透

三、switch新特性

特性一：JDK12及之后，switch可以简化写法，不用写那么多break了

特性二：switch的结果可以赋值给变量。此特性暂不详述。

12.3 循环结构

分类：

• for
• while
• do…while

其他：

• 无限循环
  
• 跳转控制语句
  

13、数组

• 数组介绍
• 数组的定义与静态初始化
• 数组元素访问
• 数组遍历
• 数组动态初始化
• 数组内存图
• 数组常见问题
• 数组常见操作

13.1 数组的概述及静态初始化

什么是数组？

数组的定义：

• 格式一：数据类型[] 数组名 ，例如：int[] array
• 格式二：数据类型 数组名[] ，例如：int array[]

静态初始化：

13.2 数组的地址值和元素访问

地址值：

元素访问：利用索引对数组中的元素进行访问

13.3 数组遍历

三种方式：

• 遍历数组可以使用for循环，for循环可以访问数组索引
• for each循环直接迭代每个数组元素，但无法获取索引；
• 使用Arrays.toString()可以快速获取数组内容。

13.3.1 基于for循环遍历

通过for循环就可以遍历数组。因为数组的每个元素都可以通过索引来访问。

public class Main {
    public static void main(String[] args) {
        int[] ns = { 1, 4, 9, 16, 25 };
        for (int i=0; i<ns.length; i++) {
            int n = ns[i];
            System.out.println(n);
        }
    }
}

13.3.2 基于for each遍历

第二种方式是使用for each循环，直接迭代数组的每个元素：

public class Main {
    public static void main(String[] args) {
        int[] ns = { 1, 4, 9, 16, 25 };
        for (int n : ns) {
            System.out.println(n);
        }
    }
}

12.3.3 基于Arrays.toString()

Java标准库提供了Arrays.toString()，可以快速打印数组内容：

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] ns = { 1, 1, 2, 3, 5, 8 };
        System.out.println(Arrays.toString(ns));
    }
}

13.4 数组动态初始化

动态初始化：初始化时只指定数组长度，由系统为数组分配初始值

• 格式：数据类型[] 数组名 = new 数据类型[数组长度]
• 范例: int[] arr = new int[5]

13.5 数组常见问题

索引越界异常

• 原因：访问了不存在的索引

数组小练习：

一、求一个数组中的最大值并打印

示例代码：

public class ArrayExercise {
    public static void main(String[] args) {
        // int[] arr = new int[5]
        int[] arr = {14, 32, 12, 9, 15};
        int temp = arr[0];
        for(int a:arr){
            if(temp < a){
                temp = a;
            }
        }
        System.out.println("The maximum value in the array is : ");
        System.out.println(temp);
    }
}

13.6 数组的内存图

13.6.1 Java的内存分配

我们主要了解栈和堆两个概念：

13.6.2 数组的内存图

注意：arr2虽然没使用new关键字，但本质上是使用了的，他依旧会在堆内存中开辟空间

13.6.3 两个数组指向同一个空间的内存图

13.7 二维数组

14、方法

• 什么是方法？
• 方法的格式
• 方法的重载
• 方法的内存

方法（method）是程序中最小的执行单元

14.1 方法的格式

• 最简单的方法定义与调用
• 带参数的方法定义和调用
• 带返回值的方法的定义和调用

总结：

• 方法其实只有这一种格式

修饰符 返回值类型 方法名(参数类型 参数名){
    ...
    方法体
    ...
    return 返回值;
}

14.1.1 最简单的方法定义与调用

格式：

public static void 方法名(){
	方法体
}

示例代码：

public class MethodExercise1 {
    public static void main(String[] args) {
        HelloWorld();
    }

    public static void HelloWorld(){
        System.out.println("HelloWorld");
    }
}

14.1.2 带参数的方法定义和调用

示例代码：

public class MethodExercise2 {
    public static void main(String[] args) {
        Add(10, 20);
    }
    public static void Add(int a, int b) {
        System.out.println(a + b);
    }
}

14.1.3 带返回值的方法的定义和调用

格式：

修饰符 返回值类型 方法名(参数类型 参数名){
    ...
    方法体
    ...
    return 返回值;
}

示例代码：

public class MethodExercise3 {
    public static void main(String[] args) {
        int result;
        result = Add(10, 20);
        System.out.println(result);
    }

    public static int Add(int a, int b) {
        int c = a + b;
        return c;
    }
}

14.1.4 小结

方法其实只有这一种格式

修饰符 返回值类型 方法名(参数类型 参数名){
    ...
    方法体
    ...
    return 返回值;
}

注意：

14.2 方法的重载

看一个需求：

我们定义一个方法用于求变量之和，虽然功能相同，但由于参数不同，我们写了一堆函数，每个函数名不同，用于区分

这样非常不方便记忆，那么是否可以将这些函数都用一个名字呢

示例：

public class MethodExercise4 {
    public static void main(String[] args) {
        int result1 = GetSum(10, 20);
        System.out.println(result1);
        double result2 = GetSum(10.1, 20.2, 30.3);
        System.out.println(result2);
        byte result3 = GetSum((byte) 1, (byte) 2, (byte) 3, (byte) 4);
        System.out.println(result3);
    }

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

    public static double GetSum(double a, double b, double c) {
        return a + b + c;
    }

    public static byte GetSum(byte a, byte b, byte c, byte d) {
        return (byte) (a + b + c + d);
    }
}

运行结果：

30
60.599999999999994
10

小练习：复制数组

• 需求：定义一个方法copyOfRange(int[] arr, int form, int to)
• 功能：将数组arr中从索引from（包含from）开始。到索引to结束（不包含to）的元素复制到新的数组中，将新数组返回。

示例代码：

import java.util.Arrays;

public class MethodExercise5 {
    public static void main(String[] args) {
        int arr[] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
        int[] result = copyOfRange(arr, 2, 4);
        System.out.println(Arrays.toString(result));
    }

    public static int[] copyOfRange(int[] arr, int form, int to) {
        int[] result = new int[to - form];
        for (int i = 0; form < to; i++) {
            result[i] = arr[form];
            form += 1;
        }
        return result;
    }
}

14.3 方法的内存

14.3.1 方法调用的基本内存原理

先进先出

14.3.2 方法传递基本数据类型、引用数据类型的内存原理

首先区别基本数据类型与引用数据类型：

• 基本数据类型：整数类型、浮点数类型、布尔类型、字符类型
• 引用数据类型：除了上述类型的其他所有类型

从深层次区别：

小结：

14.4 方法中值传递时的内存

直接看两段代码：

public class ArgsDemo01 {
    public static void main(String[] args) {
        int number = 100;
        change(number);
        System.out.println(number);  // 100
    }

    public static void change(int number){
        number = 200;
    }
}

number未发生变化，而下面一段代码：

public class ArgsDemo02 {
    public static void main(String[] args) {
        int[] number = {1, 2, 3, 4, 5};
        change(number);
        System.out.println(number[0]);  // 200
    }

    public static void change(int[] number) {
        number[0] = 200;
    }
}

number[0]发生了变化，引用数据类型在传递时传递的是地址值。

15、综合练习

15.1 卖飞机

示例代码：

import java.util.Scanner;

public class Exercise01 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输出机票原价：");
        int original_cost = sc.nextInt();
        System.out.println("请输出当前月份（1~12）：");
        int month = sc.nextInt();
        System.out.println("请输入机票类型：1、经济仓； 2、头等仓。");
        int ticket_type = sc.nextInt();
        System.out.println("您的机票价格为：");
        InquireAirFare(original_cost, month, ticket_type);
    }

    public static void InquireAirFare(int original_cost, int month, int ticket_type){
        if(month>=5 && month<=10){
            if(ticket_type == 1){
                System.out.println(original_cost * 0.85);
            }
            else {
                System.out.println(original_cost * 0.9);
            }
        }
        else if((month>=1 && month<=4) || (month>=11 && month<=12)) {
            if(ticket_type == 1){
                System.out.println(original_cost * 0.65);
            }
            else {
                System.out.println(original_cost * 0.7);
            }
        }
        else {
            System.out.println("输入月份不合法");
        }
    }
}

示例结果：

请输出机票原价：
200
请输出当前月份（1~12）：
1
请输入机票类型：1、经济仓； 2、头等仓。
1
您的机票价格为：
130.0

请输出机票原价：
200
请输出当前月份（1~12）：
13
请输入机票类型：1、经济仓； 2、头等仓。
1
您的机票价格为：
输入月份不合法

15.2 找质数

判断101 ~ 200 之间有多少个质数（及素数），并输出所有质数

示例代码：

public class Exercise02 {
    public static void main(String[] args) {
        int num = 0;
        System.out.println("101 ~ 200 之间的质数如下: ");
        for (int i = 101; i <= 200; i++) {
            // 判断是否为质数
            boolean prime_number = true;
            for (int j = 2; j < i; j++) {
                if (i % j == 0) {
                    prime_number = false;
                    break;
                }
            }
            if(prime_number){
                System.out.println(i);
                num++;
            }
        }
        System.out.println("101 ~ 200 之间的质数数量为：" + num);
    }
}

输出结果：

101 ~ 200 之间的质数如下: 
101
103
107
109
113
127
131
137
139
149
151
157
163
167
173
179
181
191
193
197
199
101 ~ 200 之间的质数数量为：21

15.3 开发验证码

• 实现一个随机产生一个5位的验证码，格式如下：
  • 长度为5
  • 前四位是大写字母 or 小写字母
  • 最后一位是数字

示例代码：

import java.util.Random;

public class Exercise03 {
    public static void main(String[] args) {
        char[] letter = new char[52];  // 存储a~z和A~Z共52个数
        for (int i = 0; i < 52; i++) {
            // 基于ASCII码表
            // a:97
            if (i <= 25) {
                letter[i] = (char) (97 + i);
            }
            // A:65
            else {
                letter[i] = (char) (65 + i - 26);
            }
        }

        // 开始随机产生验证码
        int random_number;
        String result = "";
        // 前4位为字母
        for(int i =0 ;i<4;i++){
            random_number = new Random().nextInt(letter.length);
            result += letter[random_number];
        }
        // 最后一位为 0~9 的一个数字
        result += new Random().nextInt(10);
        System.out.println(result);
    }
}

15.4 数组元素的复制

把一个数组中的元素复制到另一个新数组中

示例代码：

import java.util.Arrays;

public class Exercise04 {
    public static void main(String[] args) {
        int[] old_arr = {1, 2, 3, 4, 5};
        int[] new_arr = new int[old_arr.length];
        for(int i=0;i<old_arr.length;i++){
            new_arr[i] = old_arr[i];
        }
        System.out.println(Arrays.toString(new_arr));
    }
}

15.5 评委打分

示例代码：

import java.util.Scanner;

public class Exercise05 {
    public static void main(String[] args) {
        int[] mark = getMark(6);
        int max = getMax(mark);
        int min = getMin(mark);
        int ave = (getSum(mark) - max - min) / (mark.length - 2);
        System.out.println("平均分为：" + ave);
    }

    public static int[] getMark(int num) {
        int[] mark = new int[num];
        Scanner sc = new Scanner(System.in);
        for (int i = 0; i < num; i++) {
            System.out.println("请输出评分：");
            mark[i] = sc.nextInt();
            while (mark[i] < 0 || mark[i] > 100) {
                System.out.println("评分格式错误，请重新输入：");
                mark[i] = sc.nextInt();
            }
        }
        return mark;
    }

    public static int getMax(int arr[]) {
        int max = arr[0];
        if (arr.length == 1) {
            return arr[0];
        }
        for (int i = 1; i < arr.length; i++) {
            if (max < arr[i]) {
                max = arr[i];
            }
        }
        System.out.println("最大值为：" + max);
        return max;
    }

    public static int getMin(int arr[]) {
        int min = arr[0];
        if (arr.length == 1) {
            return arr[0];
        }
        for (int i = 1; i < arr.length; i++) {
            if (min > arr[i]) {
                min = arr[i];
            }
        }
        System.out.println("最小值为：" + min);
        return min;
    }

    public static int getSum(int arr[]) {
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum += arr[i];
        }
        return sum;
    }
}

结果展示：

请输出评分：
10
请输出评分：
110
评分格式错误，请重新输入：
20
请输出评分：
30
请输出评分：
40
请输出评分：
50
请输出评分：
120
评分格式错误，请重新输入：
60
最大值为：60
最小值为：10
平均分为：35

03 字符串

1、String

1.1 API

API：应用程序编程接口

一些不懂的API可以查阅Java的API帮助文档

1.2 String概述

String的注意点：

小结:

1.3 创建String对象的两种方式

示例代码：

String创建对象的两种方式：

• 直接赋值：最常使用，简单且节约内存
• new
  • 空参构造
  • 有参构造

1.4 创建String对象时的内存变化

方式一、直接赋值：

方式二、new

较费内存

1.5 字符串的比较

1.5.1 情况一

先看一段代码：

String s1 = "abc";
String s2 = "abc";
System.out.println(s1 == s2);  // true

String s3 = new String("abc");  
System.out.println(s1 == s3);  // false

我靠，为什么直接赋值出来的abc和new出来的abc不相等？

这就需要我们了解==号到底比的时什么。

• 基本数据类型：比较数据值
• 引用数据类型：比较地址值

那么问题来了，如果我想只比较字符串的内容，不考虑地址值怎么办？

基于两个API：

示例代码：

String s1 = "abc";
String s2 = new String("Abc");

boolean result1 = s1.equals(s2);
System.out.println(result1);  // false

boolean result2 = s1.equalsIgnoreCase(s2);
System.out.println(result2);  // true

备注：equalsIgnoreCase中的忽略大小写只适用与英文，中文的”一“和”壹“是不行的

1.5.2 情况二

键盘录入的abc和直接赋值的abc用==号比较不相等

String s1 = "abc";

Scanner sc = new Scanner(System.in);
String s2 = sc.next();  // 输入 abc

System.out.println(s1 == s2);  // false

通过观察sc.next()源码可知，本质上还是用了new。

总结：

• 以后只要是想比较字符串的内容，就用那俩API

1.6 小练习

1.6.1 用户登录

示例代码：

import java.util.Scanner;

public class StringExcise1 {
    public static void main(String[] args) {
        String name = "Abc";
        String password = "123456";

        for (int i = 0; i < 3; i++) {
            Scanner sc = new Scanner(System.in);
            System.out.println("请输入您的账号：");
            String n = sc.next();
            System.out.println("请输入您的密码：");
            String p = sc.next();

            if (n.equals(name) && p.equals(password)) {
                System.out.println("登录成功！");
                break;
            } else {
                System.out.println("用户名或者密码错误，您还有" + (2 - i) + "次机会，请重新输入。");
            }
        }
    }
}

结果展示：

请输入您的账号：
abc
请输入您的密码：
132
用户名或者密码错误，您还有2次机会，请重新输入。
请输入您的账号：
Abc
请输入您的密码：
314
用户名或者密码错误，您还有1次机会，请重新输入。
请输入您的账号：
Abc
请输入您的密码：
123456
登录成功！

1.6.2 遍历字符串、统计字符次数、字符串拼接和反转

需求：键盘录入字符串，使用程序实现遍历该字符串。

示例代码：

import java.util.Scanner;

public class StringExcise2 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串：");
        String s = sc.next();

        for (int i = 0; i < s.length(); i++) {
            System.out.println(s.charAt(i));
        }
    }
}

结果展示：

请输入一个字符串：
dasf
d
a
s
f

统计字符次数：键盘录入字符串，统计其中大写字母、小写字母、数字、其他字符的个数

示例代码：

import java.util.Scanner;

public class StringExcise3 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串：");
        String s = sc.next();

        int capitalLetter = 0;  // 大写字母
        int smallLetter = 0;  // 小写字母
        int figure = 0;  // 数字
        int other = 0;  // 其他字符

        for (int i = 0; i < s.length(); i++) {
            if(s.charAt(i) >= 'a' && s.charAt(i) <= 'z'){
                smallLetter += 1;
            }
            else if(s.charAt(i) >= 'A' && s.charAt(i) <= 'Z'){
                capitalLetter += 1;
            }
            else if(s.charAt(i) >= '0' && s.charAt(i) <= '9'){
                figure += 1;
            }
            else {
                other += 1;
            }
        }
        System.out.println("大写字母个数为：" + capitalLetter);
        System.out.println("小写字母个数为：" + smallLetter);
        System.out.println("数字个数为：" + figure);
        System.out.println("其他字符个数为：" + other);

    }
}

结果展示：

请输入一个字符串：
aAbc1230,,
大写字母个数为：1
小写字母个数为：3
数字个数为：4
其他字符个数为：2

拼接字符串

示例代码：

public class StringExcise4 {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5};
        String result = StringSplicing(arr);
        System.out.println(result);  // [1,2,3,4,5]
    }

    public static String StringSplicing(int arr[]) {
        if (arr == null) {
            return "";
        } else if (arr.length == 0) {
            return "[]";
        }

        String result = "[";
        for (int i = 0; i < arr.length; i++) {
            if (i == arr.length - 1) {
                result = result + arr[i] + "]";
                return result;
            }
            result = result + arr[i] + ',';
        }
        return result;
    }
}

字符串反转

示例代码：

import java.util.Scanner;

public class StringExcise5 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输出需要反转的字符串:");
        String str = sc.next();
        String result = ReverseString(str);
        System.out.println(result);
    }

    public static String ReverseString(String str) {
        String result = "";
        for (int i = 0; i < str.length(); i++) {
            result += str.charAt(str.length() - i -1);
        }
        return result;
    }
}

结果展示：

请输出需要反转的字符串:
adc
cda

1.6.3 金额转换

思路：

示例代码：

import java.util.Scanner;

public class StringDemo9 {
    public static void main(String[] args) {
        //1.键盘录入一个金额
        Scanner sc = new Scanner(System.in);
        int money;
        while (true) {
            System.out.println("请录入一个金额");
            money = sc.nextInt();
            if (money >= 0 && money <= 9999999) {
                break;
            } else {
                System.out.println("金额无效");
            }
        }

        //定义一个变量用来表示钱的大写
        String moneyStr = "";

        //2.得到money里面的每一位数字,再转成中文
        while (true) {//2135
            //从右往左获取数据，因为右侧是数据的个位
            int ge = money % 10;
            String capitalNumber = getCapitalNumber(ge);
            //把转换之后的大写拼接到moneyStr当中
            moneyStr = capitalNumber + moneyStr;
            //第一次循环 ： "伍" + "" = "伍"
            //第二次循环 ： "叁" + "伍" = "叁伍"
            //去掉刚刚获取的数据
            money = money / 10;

            //如果数字上的每一位全部获取到了，那么money记录的就是0，此时循环结束
            if (money == 0) {
                break;
            }
        }

        //3.在前面补0，补齐7位
        int count = 7 - moneyStr.length();
        for (int i = 0; i < count; i++) {
            moneyStr = "零" + moneyStr;
        }
        System.out.println(moneyStr);//零零零贰壹叁伍

        //4.插入单位
        //定义一个数组表示单位
        String[] arr = {"佰","拾","万","仟","佰","拾","元"};
        //               零    零   零   贰   壹   叁   伍

        //遍历moneyStr，依次得到 零    零   零   贰   壹   叁   伍
        //然后把arr的单位插入进去

        String result = "";
        for (int i = 0; i < moneyStr.length(); i++) {
            char c = moneyStr.charAt(i);
            //把大写数字和单位拼接到result当中
            result = result + c + arr[i];
        }

        //5.打印最终结果
        System.out.println(result);

    }


    //定义一个方法把数字变成大写的中文
    //1 -- 壹
    public static String getCapitalNumber(int number) {
        //定义数组，让数字跟大写的中文产生一个对应关系
        String[] arr = {"零", "壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌", "玖"};
        //返回结果
        return arr[number];
    }

}

1.6.4 手机号屏蔽

需求：以字符串的形式从键盘接受一个手机号，将中间四位号码屏蔽

最终效果为：131****9468

示例代码：

public class Test8手机号屏蔽 {
    public static void main(String[] args) {
        /*以字符串的形式从键盘接受一个手机号，将中间四位号码屏蔽
        最终效果为：131****9468*/

        //1.键盘录入一个手机号码
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入手机号码");
        String phoneNumber = sc.next();//13112349408

        //2.截取手机号码中的前三位
        String star = phoneNumber.substring(0, 3);

        //3.截取手机号码中的最后四位
        //此时我用substring方法，是用1个参数的，还是两个参数的？1个参数的会更好
        //因为现在我要截取到最后，所以建议使用1个参数的。
        String end = phoneNumber.substring(7);

        //4.拼接
        String result = star + "****" + end;

        System.out.println(result);

    }
}

1.6.5 敏感词替换

需求1：键盘录入一个 字符串，如果字符串中包含（TMD），则使用***替换

public class Test9敏感词替换 {
    public static void main(String[] args) {
        //1.定义一个变量表示骂人的话
        String talk = "后裔你玩什么啊，TMD";


        //2.把这句话中的敏感词进行替换
        String result = talk.replace("TMD", "***");

        //3.打印
        System.out.println(talk);
        System.out.println(result);
    }
}

需求2：如果要替换的敏感词比较多怎么办？

public class Test10多个敏感词替换 {
    public static void main(String[] args) {
        //实际开发中，敏感词会有很多很多

        //1.先键盘录入要说的话
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入要说的话");
        String talk = sc.next();//后裔你玩什么啊，TMD,GDX,ctmd,ZZ

        //2.定义一个数组用来存多个敏感词
        String[] arr = {"TMD","GDX","ctmd","ZZ","lj","FW","nt"};

        //3.把说的话中所有的敏感词都替换为***

        for (int i = 0; i < arr.length; i++) {
            //i 索引
            //arr[i] 元素 --- 敏感词
            talk = talk.replace(arr[i],"***");
        }

        //4.打印结果
        System.out.println(talk);//后裔你玩什么啊，***,***,***,***

    }
}

1.6.6 身份证信息查看

​ 身份证的每一位都是有固定的含义：

• 1、2位：省份
• 3、4位：城市
• 5、6位：区县
• 7-14位：出生年、月、日
• 15、16位：所在地派出所
• 17位：性别（奇数男性，偶数女性）
• 18位：个人信息码（随机产生）

要求打印内容方式如下：

​ 人物信息为：

​ 出生年月日：XXXX年X月X日

​ 性别为：男/女

package com.itheima.stringdemo;

public class StringDemo11 {
    public static void main(String[] args) {
        //1.定义一个字符串记录身份证号码
        String id = "321281202001011234";

        //2.获取出生年月日
        String year = id.substring(6, 10);
        String month = id.substring(10, 12);
        String day = id.substring(12, 14);


        System.out.println("人物信息为：");
        System.out.println("出生年月日:" + year + "年" + month + "月" + day + "日");

        //3.获取性别
        char gender = id.charAt(16);//'3'  ---> 3
        //利用ASCII码表进行转换
        //'0' --->  48
        //'1' --->  49
        //'2' --->  50
        //'3' --->  51
        //'4' --->  52
        //'5' --->  53
        //'6' --->  54
        //'7' --->  55
        //'8' --->  56
        //'9' --->  57

       int num = gender - 48;
        if(num % 2 == 0){
            System.out.println("性别为:女");
        }else{
            System.out.println("性别为:男");
        }
    }
}

2、StringBuilder

2.1 概述

构造函数：

常用方法;

示例代码：

public class StringBuilderDemo1 {
    public static void main(String[] args) {
        // 1、创建对象
        StringBuilder sb = new StringBuilder("abc");
        // StringBuilder在内部已做过处理，打印出的不是地址值而是属性值
        System.out.println(sb);  // abc

        // 2、添加元素 append()
        sb.append(1);
        sb.append(2.1);
        sb.append(true);
        System.out.println(sb); // abc12.1true

        // 3、反转 reverse()
        System.out.println(sb.reverse());  // eurt1.21cba

        // 4、获取长度 length()
        int len = sb.length();
        System.out.println(len);  // 11

        // 5、将StringBuilder变回字符串 toString()
        String str = sb.toString();
        System.out.println(str);  // eurt1.21cba
    }
}

应用场景：

• 字符串的拼接
• 字符串的反转

2.2 链式编程

链式编程：当我们在调用一个方法的时候，不需要用变量接收他的结果，可以继续调用其他方法。

示例代码：

StringBuilder str = new StringBuilder("abc");
int len = str.append(123).reverse().append("adc").length();
System.out.println(len);  // 9

2.3 练习

反转字符串：键盘输入一个字符串，控制台输出其是否为反转字符串

示例代码：

Scanner sc = new Scanner(System.in);
System.out.println("请输入一个字符串：");
String str1 = sc.next();

String str2 = new StringBuilder().append(str1).reverse().toString();

System.out.println(str1.equals(str2));

结果展示：

请输入一个字符串：
abc
false

请输入一个字符串：
abcba
true

拼接字符串

示例代码：

public class StringBuilderDemo4 {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5,6};
        String result = ConcatenationString(arr);
        System.out.println(result);  // [1,2,3,4,5,6]
    }

    public static String ConcatenationString(int arr[]) {
        StringBuilder sb = new StringBuilder();
        sb.append("[");
        for (int i = 0; i < arr.length; i++) {
            if(i == arr.length -1){
                sb.append(arr[i]).append("]");
                break;
            }
            sb.append(arr[i]).append(",");
        }
        String result = sb.toString();
        return result;
    }
}

3、StringJoiner

3.1 概述

3.2 示例代码

示例代码一：

import java.util.StringJoiner;

public class StringJoinerDemo1 {
    public static void main(String[] args) {
        // 1、创建对象，并设置间隔符
        StringJoiner sj = new StringJoiner("***");

        // 2、添加元素
        sj.add("aaa").add("bbb").add("ccc");
        
        // 3.打印结果
        System.out.println(sj);  // aaa***bbb***ccc
        System.out.println(sj.length());  // 15

    }
}

示例代码二：

import java.util.StringJoiner;

public class StringJoinerDemo2 {
    public static void main(String[] args) {
        // 1、创建对象
        StringJoiner sj = new StringJoiner(",","[","]");

        // 2、添加元素
        sj.add("aaa").add("bbb").add("ccc");

        // 3.打印结果
        System.out.println(sj);  // [aaa,bbb,ccc]
        System.out.println(sj.length());  // 13
    }
}

4、字符串原理

前两个在前文已讲述。

4.1 字符串拼接的底层原理

两种情况：

• 等号右边没有变量
• 等号右边有变量

4.1.1 等号右边没有变量

4.1.2 等号右边有变量

通过看StringBuilder中toString（）的源码可知，在变回字符串时还是使用了new，也就是创建了一个新的对象

4.1.3 JDK8字符串拼接的底层原理

JDK8之前

s1+s2,先拼，后toString，至少创建了俩对象；然后再s3，又调用toString方法。

JDK8优化了，但还是很浪费资源

• JDK8会预估数组长度，如下面创建s4时，JDK8会预估出创建一个长为3的数组

总结：

所以遇到拼接，不要直接+，用StringBuilder和StringJoiner

4.2 StringBuilder提高效率的原理图

我们通过两道面试题理解一下：

4.3 StringBuilder源码分析

示例代码：

package day5.code;

public class StringBuilderDemo5 {
    public static void main(String[] args) {
        StringBuilder sb1 = new StringBuilder();

        // StringBuilder的两个概念
        // 1、容量 capacity()
        // 2、长度 length()

        sb1.append("abc");  // 3
        System.out.println(sb1.capacity());  // 16
        System.out.println(sb1.length());  // 2

        StringBuilder sb2 = new StringBuilder();
        sb2.append("abcdefghijklmnopqrstuvwxyz");  // 26
        System.out.println(sb2.capacity());  // 34
        System.out.println(sb2.length());  // 26

        StringBuilder sb3 = new StringBuilder();
        sb3.append("abcdefghijklmnopqrstuvwxyz0123456789");  // 36
        System.out.println(sb3.capacity());  // 36
        System.out.println(sb3.length());  // 36

        StringBuilder sb4 = new StringBuilder();
        sb4.append("abcdefghijklmnopqrstuvwxyz0123456789abcd");  // 40
        System.out.println(sb4.capacity());  // 40
        System.out.println(sb4.length());  // 40
    }
}

5、综合练习

总结：

练习：转换罗马数字

示例代码：

import java.util.Scanner;

public class StringTest1 {
    public static void main(String[] args) {
        // 1、输入字符串
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入：");
        String str = sc.next();

        // 2、判断是否符合要求
        if (!checkStr(str)) {
            System.out.println("字符串不符合要求");
            return;
        }

        // 3、转换为罗马数字
        StringBuilder result = new StringBuilder();
        for (int i = 0; i < str.length(); i++) {
            // 基于ascii码表,将字符的0~9变为数字
            // 忘记ascii表，可以基于System.out.println('0' + 0);得到0对应48
            int num = str.charAt(i) - 48;
            result.append(changeLuoMa(num));
        }

        System.out.println(result);
    }

    public static boolean checkStr(String str) {
        // 1、长度为小于等于9
        if (str.length() > 9) {
            return false;
        }

        // 2、只能是数字
        for (int i = 0; i < str.length(); i++) {
            if (str.charAt(i) > '9' || str.charAt(i) < '0') {
                return false;
            }
        }
        return true;
    }
    
    // 将一个0~9的整数转换为一个字符（其对应的罗马数字）
    public static String changeLuoMa(int number) {
        //定义一个数组，让索引跟罗马数字产生一个对应关系
        String[] arr = {"", "Ⅰ", "Ⅱ", "Ⅲ", "Ⅳ", "Ⅴ", "Ⅵ", "Ⅶ", "Ⅷ", "Ⅸ"};
        return arr[number];
    }
}

结果展示：

请输入：
123456789
ⅠⅡⅢⅣⅤⅥⅦⅧⅨ

调整字符串

解题思路：

示例代码：

package day5.code;

public class StringTest2 {
    public static void main(String[] args) {
        String str1 = "abcd";
        String str2 = "cdab";  // true
        // String str2 = "cdaa";  // false

        boolean result = checkStr(str1, str2);
        System.out.println(result);
    }

    public static boolean checkStr(String str1, String str2){
        for(int i=0;i<str1.length();i++){
            str1 = rotateStr(str1);
            if(str1.equals(str2)){
                return true;
            }
        }
        return false;
    }
    public static String rotateStr(String str){
        char first = str.charAt(0);
        String end = str.substring(1);
        return end + first;
    }
}

04 集合

1、集合和数组的对比

为什么要有集合？

集合和数组的对比：

• 长度
  • 数组：长度固定
  • 集合：长度可变，自动扩容
• 存储类型：
  • 数组：基本数据类型、引用数据类型
  • 集合：基本数据类型（需要包装类，详情见下文练习第二题）、引用数据类型

2、集合的基本使用

示例代码：

import java.util.ArrayList;

public class ArrayListDemo1 {
    public static void main(String[] args) {
        // 1.创建集合：JDK7之后的创建方式
        ArrayList<String> list = new ArrayList<>();
        System.out.println(list);  // []

        // 2.添加元素
        boolean result1 = list.add("aaa");
        System.out.println(result1);  // true
        list.add("bbb");
        list.add("ccc");
        list.add("ddd");
        list.add("eee");
        System.out.println(list);  // [aaa, bbb, ccc, ddd, eee]

        // 3.删除元素：删除指定元素 or 索引
        boolean result2 = list.remove("aaa");
        System.out.println(result2);  // true
        String result3 = list.remove(0);
        System.out.println(result3);  // bbb

        // 4.修改元素
        System.out.println(list);  // [ccc, ddd, eee]
        list.set(0, "aaa");
        System.out.println(list);  // [aaa, ddd, eee]

        // 5.查
        String temp = list.get(1);
        System.out.println(temp);  // ddd
        int len = list.size();
        System.out.println(len);  // 3
    }
}

3、集合练习

集合的遍历方式

示例代码：

import java.util.ArrayList;

public class ArrayListDemo2 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();

        list.add("hello");
        list.add("world");

        String result = "[";
        for (int i = 0; i < list.size(); i++) {
            if (i == list.size() - 1) {
                result = result + list.get(i) + "]";
                break;
            }
            result = result + list.get(i) + ",";
        }
        System.out.println(result);  // [hello,world]
    }
}

添加数字并遍历

关于基本数据类型对应的包装类：

示例代码：

在练习一的基础上改一下集合的创建和添加的元素即可。

import java.util.ArrayList;

public class ArrayListDemo3 {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();

        list.add(0);
        list.add(1);
        list.add(2);

        String result = "[";
        for (int i = 0; i < list.size(); i++) {
            if (i == list.size() - 1) {
                result = result + list.get(i) + "]";
                break;
            }
            result = result + list.get(i) + ",";
        }
        System.out.println(result);  // [0,1,2]
    }
}

添加学生对象并遍历

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

示例代码：

import java.util.ArrayList;

public class ArrayListDemo4 {
    public static void main(String[] args) {
        ArrayList<Student> list = new ArrayList<>();

        Student s1 = new Student("a", 18);
        Student s2 = new Student("b", 19);
        Student s3 = new Student("c", 20);

        list.add(s1);
        list.add(s2);
        list.add(s3);

        for (int i = 0; i < list.size(); i++) {
            Student stu = list.get(i);
            System.out.println(stu.getName() + "," + stu.getAge());
        }
    }
}

结果展示：

a,18
b,19
c,20

添加学生对象并遍历 - 升级版

• 需求：定义一个集合，添加一些学生对象并遍历
  • 学生类的属性：姓名、年龄。
• 需求2：对象的数据来自键盘录入

示例代码：

package day6.code;

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

public class ArrayListDemo5 {
    public static void main(String[] args) {
        ArrayList<Student> list = new ArrayList<>();
        Scanner sc = new Scanner(System.in);

        System.out.println("请输入需要录入的学员数量: ");
        int num = sc.nextInt();

        for(int i=0;i<num;i++){
            Student s = new Student();
            System.out.println("请输入学员姓名：");
            String name = sc.next();
            System.out.println("请输入学员年龄：");
            int age = sc.nextInt();
            s.setName(name);
            s.setAge(age);
            list.add(s);
        }

        for (int i = 0; i < list.size(); i++) {
            Student stu = list.get(i);
            System.out.println(stu.getName() + "," + stu.getAge());
        }
    }
}

结果展示：

请输入需要录入的学员数量: 
3
请输入学员姓名：
a
请输入学员年龄：
12
请输入学员姓名：
b
请输入学员年龄：
18
请输入学员姓名：
c
请输入学员年龄：
20
a,12
b,18
c,20

返回多个数据

示例代码：

package day6.code;

import java.util.ArrayList;

public class ArrayListDemo6 {
    public static void main(String[] args) {
        ArrayList<Phone> list = new ArrayList<>();

        Phone p1 = new Phone("小米", 1000);
        Phone p2 = new Phone("苹果", 8000);
        Phone p3 = new Phone("锤子", 2999);

        list.add(p1);
        list.add(p2);
        list.add(p3);

        ArrayList<Phone> result = new ArrayList<>();
        result = getPhoneInfo(list);

        for (int i = 0; i < result.size(); i++) {
            Phone p = result.get(i);
            System.out.println(p.getBrand() + "," + p.getPrice());
        }
    }

    public static ArrayList<Phone> getPhoneInfo(ArrayList<Phone> list){
        ArrayList<Phone> result = new ArrayList<>();
        for(int i = 0; i < list.size(); i++) {
            if(list.get(i).getPrice() < 3000){
                Phone p = list.get(i);
                result.add(p);
            }
        }
        return result;
    }
}

结果展示：

小米,1000.0
锤子,2999.0