Java基础01 基础语法

已于 2023-02-05 00:10:38 修改
阅读量1.6k 收藏 1
点赞数
分类专栏： JAVA 文章标签： java 开发语言 面试 程序人生 经验分享
于 2023-02-04 22:54:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_55535816/article/details/128886738
版权

文章目录

视频链接：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的安装目录

image-20230120124936334

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的发展

image-20230120131421779

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

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

image-20230120131627740

3.2JAVA可以做什么

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

  • JAVA SE
  • JAVA ME
  • JAVA EE
3.2.1 JAVA SE

image-20230120133530940

3.2.2 JAVA ME

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

image-20230120133639101

3.2.3 JAVA EE

服务器开发，JAVA就是天。

image-20230120133733939

3.2.4 总结

image-20230120133911959

4、JAVA跨平台的原理

image-20230120134730603

5、JDK与JRE

5.1 JDK

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

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

5.2 JRE

JRE是Java运行环境。

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

5.3 Other

image-20230120135719475

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

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

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

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

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

02 基础语法

大纲：

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

1、注释

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

image-20230120141055073

2、关键字

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

image-20230120141305807

总结：

image-20230120141429274

3、字面量

image-20230120142620465

4、变量

image-20230120143620581

小练习：

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

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 进制

image-20230120153016572

image-20230120153118426

示例代码：

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。

image-20230120155642674

5.3 进制转换

5.3.1 任意进制转十进制

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

image-20230120160608775

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

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

image-20230120160925427

5.3.2 十进制转其他进制

image-20230120161217417

5.4 计算机的存储规则

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

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

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

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

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

image-20230120161602514

三、那汉字怎么存储呢？

Unicode编码，万国码

image-20230120161839984

5.4.2 图片

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

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

image-20230120164401465

image-20230120164413092

5.4.3 声音

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

image-20230120164755993

6、数据类型

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

基本数据类型：四类八种

image-20230120170219851

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

注意事项：

1、long

定义long类型时需注意：

image-20230120165558685

不加的话，终端会报错。

2、float与double

float需要加后缀，double不用

image-20230120165810367

小结：

image-20230120170056302

练习：输出老师信息

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、标识符

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

image-20230120172253295

image-20230120172436006

8、键盘录入

image-20230120172744882

示例代码：

// 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)

补充：

image-20230125230529819

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、运算符

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

image-20230120210408736

运算符种类：

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

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 隐式转换

image-20230120213132179

示例代码：

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
    }
}

小练习：
image-20230120213605354

小结：
image-20230120213150993

10.1.1.2 强制转换

image-20230120214219877

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

  • 程序不报错，但结果是错误的
int d = 300;
byte e = (byte) d;
System.out.println(e);  // 44

小练习：
image-20230120213924237

注意，细节决定成败：

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 字符串和字符的加操作

一、字符串的加操作

image-20230120215642680

小练习：

image-20230120215919606

二、字符 + 数字

image-20230120220432612

示例代码：

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

10.2 自增自减运算符

  • ++

image-20230120221653847

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 赋值运算符

image-20230122150504528

注意：

image-20230122150611525

10.4 关系运算符

image-20230122150710200

练习

输入两个整数（范围为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 四种逻辑运算符号

image-20230122151645789

10.5.2 短路逻辑运算符号

image-20230122152123264

应用：

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

10.6 三元运算符号

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

image-20230122152905227

练习

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

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 运算符优先级

image-20230122153651891

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

10.8 其他运算符

image-20230122161636335

例子：

image-20230122161741373

11、原码、反码、补码

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

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

11.1 原码

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

image-20230122155023323

P： 为什么是8位数呢？

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

image-20230122160025244

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

11.2 反码

image-20230122160153389

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

image-20230122160435350

总结：
image-20230122161135621

11.3 补码

image-20230122160910431

image-20230122161043033

12、流程控制语句

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

12.1 顺序结构

image-20230122162308391

12.2 分支结构

12.2.1 if

if的三种格式：

image-20230122200709888

image-20230122200721361

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的位置和省略

image-20230122201256490

二、case穿透

image-20230122201530347

三、switch新特性

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

image-20230122201907664

image-20230122202517088

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

12.3 循环结构

分类：

  • for
  • while
  • do…while

其他：

  • 无限循环
    image-20230122204332786
  • 跳转控制语句
    image-20230122204442577

13、数组

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

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

什么是数组？

image-20230122205036915

数组的定义：

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

静态初始化：

image-20230122205554642

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的内存分配

image-20230122232918961

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

image-20230122233058823

13.6.2 数组的内存图

image-20230122233714245

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

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

image-20230122234113243

13.7 二维数组

image-20230124004450012

image-20230124004519259

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 带参数的方法定义和调用

image-20230123171047233

示例代码：

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 返回值;
}

image-20230123172303865

示例代码：

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 方法的重载

看一个需求：

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

image-20230123174045048

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

在这里插入图片描述

示例：

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 方法调用的基本内存原理

先进先出

image-20230123221554928

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

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

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

从深层次区别：

image-20230123222420515

image-20230123222522367

小结：

在这里插入图片描述

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 字符串

image-20230126211127898

1、String

image-20230126165745123

1.1 API

API：应用程序编程接口

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

image-20230126165021038

1.2 String概述

String的注意点：

image-20230126170045255

小结:

image-20230126170109640

1.3 创建String对象的两种方式

在这里插入图片描述

示例代码：

String创建对象的两种方式：

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

image-20230126170650436

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

方式一、直接赋值：

image-20230126171711866

image-20230126171723123

方式二、new

较费内存

image-20230126171756892

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 遍历字符串、统计字符次数、字符串拼接和反转

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

image-20230126175222133

示例代码：

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

拼接字符串

image-20230126184328251

示例代码：

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 金额转换

思路：

image-20230126190850148

示例代码：

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

image-20230126191332048

示例代码：

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 概述

image-20230126200528824

构造函数：

image-20230126200722119

常用方法;

image-20230126200759184

示例代码：

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

拼接字符串

image-20230126204739997

示例代码：

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 概述

在这里插入图片描述

image-20230126210009613

image-20230126210033744

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、字符串原理

image-20230126211234483

前两个在前文已讲述。

4.1 字符串拼接的底层原理

两种情况：

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

在这里插入图片描述

4.1.2 等号右边有变量

image-20230126213751775

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

image-20230126213912217

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

JDK8之前

image-20230126214314008

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

在这里插入图片描述

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

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

image-20230126213511340

总结：

在这里插入图片描述

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

4.2 StringBuilder提高效率的原理图

image-20230127012653914

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

image-20230127011112570

image-20230127012219280

4.3 StringBuilder源码分析

image-20230127013951016

示例代码：

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、综合练习

总结：

image-20230127014011703

练习：转换罗马数字

image-20230127014127240

示例代码：

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
ⅠⅡⅢⅣⅤⅥⅦⅧⅨ

调整字符串

image-20230127021925542

解题思路：

image-20230127021904475

示例代码：

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、集合的基本使用

image-20230127165524737

示例代码：

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、集合练习

集合的遍历方式

image-20230127170617576

示例代码：

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]
    }
}

添加数字并遍历

image-20230127171122368

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

image-20230127171204076

示例代码：

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

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

返回多个数据

image-20230128170538141

示例代码：

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
DLNovice
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
Java基础语法.docx
05-13
Java基础语法的word版，md版本图片可能加载不出来，这个有全部的效果图，配合视频看效率更快——b站“狂神说Java”
java基础语法.xmind
09-20
个人关于java基础语法的思维导图总结。0积分下载。如果认为有帮助，请关注点赞，日后还有更多免费资源。敬请关注。
Java_基础语法部分
09-20
Java基础语法部分
Java基础语法.md
05-05
java零基础入门教学——基础语法，java基础的基础，适合任何人观看，无需掌握很多基础知识，全分段基础，从零开始也不会迷路
Java基础语法)教案
04-05
Java基础语法)教案Java开发环境搭建，HelloWorld案例，注释、关键字、标识符以及Java中的数据，但是难度都相对较低，大家只需要下去多加练习，掌握肯定没问题。 关于前两大块内容，Java开发环境待见和HelloWorld案例...
golang 接口
m0_70982551的博客
07-24 942
接口定义了一组方法，这些方法没有具体的实现。接口类型的变量可以存储任何实现了这些方法的类型的值。// 更多方法...在Go语言中，接口值是指存储了实现某个接口的具体类型值的变量。接口值由两部分组成：1.动态类型：这是接口值当前存储的实际类型。2.动态值：这是实际存储的值，该值必须实现了接口中定义的所有方法。
Swagger使用Map接受参数时，页面如何显示具体参数及说
a1058926697的博客
07-26 510
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
springboot之自动装配
weixin_50153914的博客
07-23 634
Spring Boot 通过一系列注解和条件配置实现了自动装配机制，使得开发者无需手动配置大量的 XML 文件或 Java 配置类。自动配置机制利用文件中的自动配置类，并结合条件注解和组件扫描，实现了灵活且强大的自动装配功能。这样，开发者可以专注于业务逻辑的实现，而无需处理繁琐的配置细节。
Java的@DateTimeFormat注解与@JsonFormat注解的使用对比
訾博（ZiBo）的博客
07-27 590
在Spring和Jackson框架中，日期和时间格式化是一个常见需求。注解主要用于Spring的表单绑定，而注解则用于Jackson的JSON序列化和反序列化。了解这两个注解的使用场景和方法，可以帮助开发者更高效地处理日期和时间。和是处理日期和时间格式化的两个重要注解。主要用于Spring MVC的请求参数绑定，而主要用于Jackson的JSON序列化和反序列化。了解它们的使用场景和功能，可以帮助开发者更高效地处理日期和时间格式化需求。通过本文的介绍，希望读者能够更清晰地理解和。
Java修炼 2024.7.26 0:24
2301_80011650的博客
07-26 423
问题：编写一个方法，找出一个数组中的众数（出现次数超过数组长度一半的元素）。例如，输入 [2, 2, 1, 1, 2]，输出 2。编写一个方法，找出一个整数数组中的第二大元素。例如，输入 [3, 5, 1, 8, 7]，输出 7。例如，输入 5，输出 5。问题：编写一个方法，将给定的字符串逆转。问题：使用数组实现栈，并提供基本操作（push、pop、peek、isEmpty）。问题：实现一个单向链表，并提供基本的操作（添加、删除、查找元素）。问题：编写一个方法来查找一个给定字符串的所有子串。
Java代码基础算法练习-数的特性-2024.07.25
Sakurapaid的博客
07-25 361
小A喜欢两种性质都成立的数字，小B喜欢至少符合一种性质的数字，小C喜欢不符合这两种性质的 数字。给出一个数字，请输出三个人是否喜欢这个数字。如果喜欢输出1，否则输出0，用空格分隔。输入数字 num，先定义三个整型代表三个人的喜欢与否，先默认设为 0。之后判断num对于性质1、2的条件，分别用 boolen 类型标识。对于每个整型进行判断，是否改为 1 代表喜欢。性质2：大于4且不大于12;
学习笔记---java篇（0723）
m0_70630166的博客
07-23 848
java、数据类型、循环、选择等
新建springboot项目找不到java版本8?
最新发布
weixin_74009895的博客
07-28 96
新建springboot项目找不到java版本8?
SSM框架整合——常用方式整合SSM框架（三）Spring和MyBatis整合
PAP
07-26 178
SSM框架整合——常用方式整合SSM框架（三）Spring和MyBatis整合
19.jdk源码阅读之FutureTask
前端、移动端、后端源码级底层原理分享
07-25 866
FutureTask 是 Java 并发包中的一个重要类，它实现了 RunnableFuture 接口，结合了 Future 和 Runnable 的特性。FutureTask 通常用于异步任务的执行和结果的获取。
c++ 智能指针shared_ptr与make_shared
Txwtech笛克特科
07-25 271
shared_ptr是C++11引入的一种智能指针，‌它允许多个shared_ptr实例共享同一个对象，‌通过引用计数来管理对象的生命周期。‌当最后一个持有对象的shared_ptr被销毁时，‌它会自动删除所指向的对象。‌这种智能指针主要用于解决资源管理问题，‌避免内存泄漏。make_shared是C++标准库中的一个函数，‌用于创建一个shared_ptr智能指针，‌它接受一个或多个参数来构造一个对象，‌并返回一个指向该对象的shared_ptr。类SerialModbus的成员指针。
Jvm基础（一）
G81948577的博客
07-19 1098
本地方法就是不使用java编写的，比如C++编写的程序，只是需要传递参数。
教务管理平台/高校教务管理系统的设计与实现/教务网站/学生成绩管理系统/学生课程管理系统
weixin_47958760的博客
07-27 771
本毕业设计的内容是设计并且实现一个基于JSP技术的教务管理平台。采用MYSQL为数据库开发平台，SSM框架，Tomcat网络信息服务作为应用服务器。教务管理平台的功能已基本实现，主要有学生、教师、课程信息、课程选择、教师课表、学生成绩、图书信息、考试等管理功能。 论文主要从系统的分析与设计 、数据库设计和系统的详细设计等几个方面来进行论述，系统分析与设计部分主要论述了系统的功能分析、系统的设计思路，数据库设计主要论述了数据库的设计，系统的详细设计部分主要论述了几个主要模块的详细设计过程。
android audio不同音频流，(八)music流音量APK按键调整
五味香的专栏
07-24 441
apk通过监测按键事件，再调用AudioManager函数接口，调节STREAM_MUSIC流音量调节。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

DLNovice

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值