Java极速入门-第三章Java运算符、流程控制（循环）、数组

已于 2022-04-20 11:48:08 修改
阅读量276 收藏
点赞数
分类专栏： JAVA入门 文章标签： java
于 2022-04-19 23:49:56 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dc_12138/article/details/124286747
版权

Java极速入门系列文章目录

第一章Java概述、Java环境、IDEA开发工具
第二章Java编码规范、注释、关键字、变量、数据类型及转换

文章目录

1.运算符

运算符优先级：! > 算术运算符 > 关系运算符 > && > ||

1.1赋值运算符

用来做赋值运算，给变量赋值，语法：

数据类型 变量名=数值/变量;

//将10赋给num
int num = 10;
//将num的值赋给num2
int num2 = num;

1.2基本算术运算符

用来完成 Java 程序中的基本数学运算，只适用于数值类型的运算（+ 除外，可以用在字符串的拼接）

包括：+、-、*、/、%、++、–

操作数 运算符 操作数

操作数的类型会转换：10/3 输出结果是3

​ 10.0/3 或 10/3.0 输出结果3.3333333（由低字节向高字节转换）

++、-- ：针对变量操作

A++和++A ：A++ 先使用 A 的值，再进行运算，++A 先进行运算，再使用 A 的值。

1.3复合算术运算符

基于基本算术运算符，进一步简化代码，包括：+=、-=、*=、/=、%=

操作数 运算符 操作数

A+=B : A=A+B

1.4关系运算符

用来计算一个表达式是否成立，true/false，包括：

  • ==、!=、>、<、>=、<=

  • >、<、>=、<= 只能用作数值类型的比较

  • ==、!= 除了比较数值类型，也可以用来判断两个对象是否相等

    A == B：判断 A 和 B 是否相等，返回 true/false
    A != B：判断 A 和 B 是否不相等，返回 true/false

    int num1 = 10; int num2 = 11; boolean flag = num1 == num2; System.out.println(flag);

    结果为：false

1.5逻辑运算符

只能用于 boolean 类型的数据判断，boolean 数据之间的逻辑关系，与、或、非

基本语法：变量 A 逻辑运算符 变量 B

与：&、&&（短路与）
或：| 、||（短路或）
非：!

A & B：A 和 B 都为 true ，结果为 true，否则为 false

A | B：A 和 B 只要有一个为 true，结果为 true，否则为false

!A：A 为 true，结果为 false，A 为 false，结果为 true

1.& 和 && 运算结果完全相同，但是运算效率不同，&& 运算效率可能更高。

​ A运算 & B运算：如果使用 &，A 运算和 B 运算都需要进行计算，两次运算。
​ A运算 && B运算：如果使用 &&，假设 A 运算的结果为false，结果一定为 false，此时 B 运算就可以不进行计算了，只进行了一次运算，效率更高。

​ 如果 A 运算的结果为 true，则一定要进行 B 运算，此时和 &效率一样。

2.A运算 || B运算：如果使用 ||，假设 A 运算结果为 true，结果一定为 true，此时 B 运算就可以不进行计算了，只进行了一次运算，效率更高。

​ 如果 A 运算的结果为 false，则一定要进行 B 运算，此时和 |
效率一样。

3.例子

int num1 = 10;
int num2 = 11;
System.out.println((++num1 == num2) &&
(++num1!=num2));
System.out.println(num1);
输出结果：ture
        12

1.6条件运算符

条件运算符也叫三元表达式，用来给变量赋值，根据不同的条件给变量赋不同的值。

基本语法：变量 = 条件?值1:值2

条件为 true，变量 = 值1，条件为 false，变量 = 值2

public class Test {
    public static void main(String[] args) {
        String str=2>1?"2大于1":"2不小于1";
        System.out.println(str);
        String str1=2<1?"2大于1":"2不小于1";
        System.out.println(str1);
    }
}
结果：2大于1
     2不小于1

1.7位运算符

对表达式以二进制的形式进行运算，A&B，A 和 B 转为二进制，再进行运算。

十进制和二进制的转换

10 转 2:目标数除以 2，如果能除尽，则该位记作 0，如果除不尽，则该位记作 1，再对商继续除以 2，重复上述操作，以此类推，直到商为 0，将每一位的值进行反序组合就是二进制的值。

在这里插入图片描述

10转2: 1010

17 转 2：10001

2 转 10：从最低位（最右）算起，该位上的数字乘以本位的权重（2 的第几位的位数减一次方，第 2 位就是 2 的 2-1 次方，第 8 位就是 2 的 8-1 次方），将乘积相加就是对应的十进制。

在这里插入图片描述

位运算符：&（按位与）、|（按位或）、^（按位异或）、<<（左移）、>>（右移）

根据操作数判断是逻辑运算（true和false）还是位运算（数值）

  • A & B：每一位的数字一一对应，若都为 1，则该位记作 1，否则为 0

  • A | B：每一位的数字一一对应，只要有一个 1，该位记作1，否则为 0

  • A ^ B：每一位的数字一一对应，相同记作 0，否则记作 1

  • A << B：A 乘以 2 的 B 次方，2 << 3，2*8

  • A >> B：A 除以 2 的 B 次方，2 >> 3，2/8

    例子：

    10&5=0

    10|5=15

2.流程控制

2.1 if-else

基本语法：

if(判断条件){
//条件成立执行的代码
}else{
//条件不成立执行的代码
}

运算符优先级：! > 算术运算符 > 关系运算符 > && > ||

2.2 多重if

int java = 66;
if(java > 80){
System.out.println("良好");
}else if(java >= 60){
System.out.println("中等");
} else {
System.out.println("差");
}

if-else 使用很灵活，可以根据不同情况选择不同的组合方式，需要注意：

  • if 后面必须跟(条件)
  • else 后面不能跟(条件)
  • else 后面可以直接跟 {}，也可以根据 if 语句

2.3 if嵌套

例子：参加比赛，预赛成绩 80 分以上可以进入决赛，根据年龄分为 A 组(20岁以上)和 B 组（18-20岁），程序实现。

int score = 71;
int age = 19;
if(score > 80){
if(age >= 20){
System.out.println("成功晋级A组");
}else if(age >= 18){
System.out.println("成功晋级B组");
}
}else{
System.out.println("很遗憾，没有进入决赛");
}

2.4 switch-case

switch-case 只能完成等值判断，switch 支持的数据类型包括 int、short、byte、char、枚举、String，不支持boolean。

基本语法：

switch(变量){
	case 值1:
		代码1;
		break;
	case 值2:
		代码2;
		break;
	case 值3:
		代码3;
	break;
...
	default:
		代码n;
}

用 if-else 类比

if(变量==值1){
	代码1;
}else if(变量==值2){
	代码2;
}else if(变量==值3){
	代码3;
}
...
else{
	代码n;
}

每个 case 语句后面都要跟 break，表示结束当前的代码，如果不跟 break，则从当前的 case 语句开始，后面所有的case 判断都失效，直接执行代码而不进行判断。

2.5 循环

2.5.1 while 循环

基本语法：

while(循环条件){
	//循环体
}

循环四要素：

  • ​ 初始化循环变量

  • ​ 循环条件

  • ​ 循环体

  • ​ 更新循环变量

    int i = 0;
while(i<10){
System.out.println("Hello World");
i++;
}

2.5.2 do-while 循环

while 先判断再执行，do-while 先执行一次循环体，再进行判断

如果循环条件不成立，do-while 会执行一次，while 一次都不会执行

基本语法：

do{
	循环体
}while(循环条件)
 
int i = 0;
do{
	System.out.println("Hello World");
	i++;
}while(i<10);

2.5.3 for 循环

基本语法：

for(初始化循环变量;循环条件;更新循环变量){
	循环体
}

for (int i=0;i<10;i++){
	System.out.println("Hello World");
}
//快捷键 fori

2.5.4 while、do-while、for 的区别

相同点：都要遵循循环四要素

不同点：

  1. while 和 do-while 适用于循环次数不确定的场景，for 循环适用于循环次数确定的场景。
  2. while 和 for 先判断循环条件，再执行循环体，do-while先执行一次循环条，再判断循环条件。

例子1：学生成绩查询系统，输入学生编号，查询学生的成绩，输入“yes” 表示继续查询，输入 “no” 表示结束查询。

System.out.println("学生成绩查询系统");
Scanner scanner = new Scanner(System.in);
String str = "yes";
int num = 0;
while(str.equals("yes")){
	System.out.print("请输入学生编号:");
	num = scanner.nextInt();
	switch (num){
		case 1:
			System.out.println("张三的成绩是90");
			break;
		case 2:
			System.out.println("李四的成绩是96");
			break;
		case 3:
			System.out.println("王五的成绩是88");
			break;
		}
	System.out.print("是否继续?yes/no");
	str = scanner.next();
}
System.out.println("查询结束");

例子2：分别使用 while、do-while、for 循环计算 1-100 的所有整数之和。

//while
        int num = 1;
        int sum = 0;
        while(num <= 100){
            sum += num;
            num++;
        }
        System.out.println(sum);
//do-while
        int num2 = 1;
        int sum2 = 0;
        do{
            sum2 += num2;
            num2++;
        }while(num2 <= 100);
        System.out.println(sum2);
//for
        int sum3 = 0;
        for (int i = 1; i <= 100; i++) {
            sum3 += i;
        }
		System.out.println(sum3);

2.5.5 双重循环

public static void main(String[] args) {
	for (int j = 0; j < 3; j++) {
	for (int i = 0; i < 6; i++) {
		System.out.print("*");
	}
		System.out.println();
	}
}

******
******
******

用双重循环打印 99 乘法口诀表

public class Test {
    public static void main(String[] args) {
        for (int i = 1; i < 10; i++) {
            for(int j=1;j<=i;j++){
                System.out.print(i+"*"+j+"="+i*j+"\t");
            }
            System.out.println();
        }

    }
}

2.5.6 终止循环

break、continue

计算 1-100 的整数之和，当总和大于 50 的时候跳出循环。

break

public static void main(String[] args) {
        int sum = 0;
        for (int i = 1; i <= 100; i++) {
            sum += i;
            if(sum>50) break;
        }
        System.out.println(sum);
    }
//结果为：55

continue

public static void main(String[] args) {
        int sum = 0;
        for (int i = 1; i <= 100; i++) {
            sum += i;
            if(sum>50) continue; //跳出本次循环进入下次循环，本就是最后一行代码，本就应该进入下一次循环
        }
        System.out.println(sum);
    }
//结果为 5050

3.数组

3.1 什么是数组

数组就是一种可以存储大量数据类型相同的变量的数据结构，具有相同数据类型的数据集合。

数组基本要素

一个数组由 4 个基本元素构成：

  • 数组名称
  • 数组元素
  • 元素下标
  • 数据类型

在这里插入图片描述

3.2 如何使用数组

1.声明数组： 数据类型 数组名[] int array[];

数据类型[] 数组名 int[] array;

2.分配内存空间，指定数组长度，数组一旦创建，长度不能修改。

array = new int[3];

3.给数组赋值：通过下标找到数组中的位置，进行赋值。

array[0] = 50;
array[1] = 60;
array[2] = 70;

4.使用数组：通过下标取出数组中的具体数值。

System.out.print(array[0]);

例子：张三 90 分，李四 86 分、王五 79 分、小明 93 分，创建数组保存成绩，同时求出平均分。

public static void main(String[] args) {
        int[] array = new int[4];//声明数值，开辟空间
        array[0] = 90;
        array[1] = 86;
        array[2] = 79;
        array[3] = 93;
        int sum = 0;
        for (int i = 0; i < array.length; i++) {
            sum += array[i];
        }
        System.out.println("平均分是：" + sum /
                array.length);
    }

边声明边赋值

int[] array1 = {50,60,70};
int[] array2 = new int[]{50,60,70};

基本数据类型的变量和值都存储在栈内存中。

在这里插入图片描述

数组属于引用类型的存储，变量保存在栈内存中，变量的值保存在堆内存中，通过地址的引用进行关联。

引用类型：只要通过 new 关键字创建的变量都是引用类型。

在这里插入图片描述

3.3 常见错误

1.数据类型不匹配

在这里插入图片描述

2.边声明边赋值必须写在同一行

在这里插入图片描述

3.数组下标越界

在这里插入图片描述

下标最大是2，取5，下标越界。

3.4 实际应用

学员成绩 {96,93,87,80,73,62}，增加一个学员成绩83，将它插入数组并且数组继续降序排列。

public static void main(String[] args) {
        int[] array = {96, 93, 87, 80, 73, 62};
        int score = 83;
        int[] array2 = new int[array.length + 1];
        int index = 0;
        for (int i = 0; i < array.length; i++) {
            if (array[i] < score) {
                index = i;
                break;
            }
        }
        for (int i = 0; i < index; i++) {
            array2[i] = array[i];
        }
        for (int i = index + 1; i < array2.length;
             i++) {
            array2[i] = array[i - 1];
        }
        array2[index] = score;
        System.out.println(Arrays.toString(array2));
    }
//结果：[96, 93, 90, 87, 80, 73, 62]

3.5 二维数组

二维数组：一维数组中保存的值也是一个一维数组

在这里插入图片描述

如果一维数组中保存的值是其他数组的内存地址，那么这种结构的数组就是二维数组。

使用：

1.声明

2.开辟内存空间

3.赋值

//声明
    int[][] array;
//开辟内存空间
    array = new int[3][3];
//array = new int[3][]; 第二个的数值可以不是固定的
//赋值
    array[0][0] = 1;
    array[0][1] = 2;
    array[0][2] = 3;
    array[1][0] = 4;
    array[1][1] = 5;
    array[1][2] = 6;
    array[2][0] = 7;
    array[2][1] = 8;
    array[2][2] = 9;

在这里插入图片描述

二维数组也支持边声明边赋值的方式

int[][] array = {{1,2,3},{4,5,6},{7,8,9}};
int[][] array2 = new int[][]{{1,2,3},{4,5,6},
{7,8,9}};

例子：货架有三层，每层有依次6盒子，每个盒子的鸡蛋个数是货架的层号*盒号，求总鸡蛋个数

int[] array2 = new int[array.length + 1];
        int index = 0;
        int[][] array = new int[3][6];
        int sum = 0;
        for (int i = 0; i < array.length; i++) {
            System.out.println("------第" + (i + 1) + "层货架------");
            for (int j = 0; j < array[i].length; j++) {
                int num = (i+1)*(j+1);
                System.out.println("第" + (j + 1) + "盒子格挡的鸡蛋个数：" + num);
                        sum += num;
            }
        }
        System.out.println("鸡蛋总数量是：" + sum);

例子：货架有三层，每层有依次6盒子，每个盒子的鸡蛋个数是货架的层号*盒号，求总鸡蛋个数

int[] array2 = new int[array.length + 1];
        int index = 0;
        int[][] array = new int[3][6];
        int sum = 0;
        for (int i = 0; i < array.length; i++) {
            System.out.println("------第" + (i + 1) + "层货架------");
            for (int j = 0; j < array[i].length; j++) {
                int num = (i+1)*(j+1);
                System.out.println("第" + (j + 1) + "盒子格挡的鸡蛋个数：" + num);
                        sum += num;
            }
        }
        System.out.println("鸡蛋总数量是：" + sum);
你我有猿
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
java程序设计-第3章-数据运算、流控制和数组
03-12
Java程序设计中的第三章主要涵盖了数据运算、流控制和数组这三个核心概念，它们是编程的基础。首先，我们从数据类型开始。 数据类型是Java中定义变量的类别，它决定了变量可以存储的数据种类以及如何处理这些数据。...
Educoder题目：Java入门 - 运算符和表达式答案解析.md
10-26
Educoder题目：Java入门 - 运算符和表达式答案解析
Java编程入门第1章测验Java开发Java经验技巧共2
12-01
本资源包"Java编程入门第1章测验Java开发Java经验技巧共2"聚焦于Java编程的基础学习，特别关注初学者如何掌握Java开发的初步知识和实践经验。其中包含的"Java编程入门第1章测验"部分，旨在帮助学习者检验和巩固他们...
深入讲解Java中的流程控制与运算符
09-03
在Java编程语言中，流程控制和运算符是构建程序逻辑的基础元素。流程控制允许程序员决定程序执行的顺序，而运算符则用于操作变量和值。接下来我们将深入探讨这两个主题。 首先，我们来看Java中的流程控制。流程控制...
Java SE-基础篇-运算符、随机数（Random）、方法、数组-入门级讲解
08-14
本文将介绍Java SE中的基础概念，包括运算符、随机数生成、方法以及数组，这些都是初学者入门Java编程需要掌握的关键知识点。 1. 运算符： - 转义字符：在Java中，`\`是一个转义字符，可以用于创建特殊字符，如`\n...
12. Hibernate 模板设计模式
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
07-22 1077
如何运用模板设计模式重构 Hibernate 操作流程；持久化对象与序列化接口；OOP中有一个编码原则 ：写仅写一次。翻译过来就是，不要重复，要重用。答案是：使用模板设计模式进一步封装Hibernate的操作。在真实项目中，Hibernate仅仅只是完成项目中的一部分工作，需要和其它，如Spring等框架联合工作，一起承担整体项目的开发。Spring框架中就提供的有Hibernate模板对象。一个常规的、频繁的操作代码中，大部分代码不需要变动，只有小部分代码需要根据需求变动。
Java内存模型
weixin_44267758的博客
07-19 761
此处的变量不是指java编程中的变量，它包括了实例字段，静态字段和构成数值对象的元素，但不包括局部变量和方法参数。JMM规定所有变量都存储在主内存中。每条线程有自己的工作内存，工作内存中保留了该线程使用到变量的主内存的副本。线程对变量的所有操作都必须在工作内存中进行，不能直接读写主内存的变量，不同的线程间也无法直接访问对方工作内存的变量，线程之间的变量值传递需要通过主内存来完成。
Promise 详解（原理篇）
山重水复疑无路，柳暗花明又一村。
07-20 736
Promise 是一种异步编程的解决方案。在异步操作中，callback 会导致回调地狱的问题，Promise 解决了这个问题。一个 Promise对象有以下三种状态:pending：初始状态，既不是成功，也不是失败状态。：意味着操作成功完成。rejected：意味着操作失败。当 new Promise() 被实例化后，即表示 Promise 进入 pending 初始化状态，准备就绪，等待运行。
接口防刷！利用redisson快速实现自定义限流注解
架构师小吴的博客
07-18 1293
如登录接口，当用户使用手机号+验证码登录时，一般我们会生成6位数的随机验证码，并将验证码有效期设置为1-3分钟，如果对登录接口不加以限制，理论上，通过技术手段，快速重试100000次，即可将验证码穷举出来。解决思路：对登录接口加上限流操作，如限制一分钟内最多登录5次，登录次数过多，就返回失败提示，或者将账号锁定一段时间。在日常开发中，一些重要的对外接口，需要加上访问频率限制，以免造成资��损失。ok，通过以上两步，即可完成我们的限流注解了，下面通过一个接口验证下效果。
java算法day19
TOMOT77的博客
07-20 293
我第一时间想到的方法是遍历二叉树+哈希。哈希用来统计数字出现的次数。之后遍历map收集结果。利用了BST的性质，即BST的中序序列是有序序列。
springboot之自动装配
weixin_50153914的博客
07-23 210
Spring Boot 通过一系列注解和条件配置实现了自动装配机制，使得开发者无需手动配置大量的 XML 文件或 Java 配置类。自动配置机制利用文件中的自动配置类，并结合条件注解和组件扫描，实现了灵活且强大的自动装配功能。这样，开发者可以专注于业务逻辑的实现，而无需处理繁琐的配置细节。
【Java算法】前缀和 下
2302_79806056的博客
07-18 1178
这段代码实现了一个寻找数组中具有相等数量的0和1的最长子数组长度的算法。具体来说，它使用了前缀和（prefix sum）的概念以及哈希映射（HashMap）来优化查找过程。初始化哈希映射：计算前缀和：检查相等数量的0和1：更新哈希映射：返回结果：这种方法的时间复杂度为O(n)，因为我们只遍历数组一次，并且对每个元素执行常数时间的操作。空间复杂度也是O(n)，最坏情况下需要存储n个前缀和值。 初始化阶段:开始遍历数组:继续
华为OD机试 - 分披萨 - 递归（Java 2024 D卷 200分）
学Java，找哪吒
07-21 946
递归算法通过函数调用自身解决问题，每次递归调用都处理问题的一个子部分，直到达到基准条件，从而构建最终解。
[Jenkins]jenkins-cli.jar调用用户token启动任务
最新发布
China_Yanhy的博客
07-23 518
jenkins-cli.jar调用用户token启动任务
【Java并发编程之美 | 第三篇】Java 并发包中锁原理剖析之AQS、ReentrantLock独占可重入锁
踢桃的成长之路
07-21 791
Java 并发包中锁原理剖析之AQS、ReentrantLock独占可重入锁
javaScrip的学习（一）
weixin_65450681的博客
07-19 1301
这篇文章让我们简单来了解一下js，那么什么是js?JavaScript（简称JS）是一种高级编程语言，主要用于为网页添加交互功能。它可以嵌入到HTML页面中，通过对DOM（文档对象模型）的操作来实现动态效果和用户交互。JavaScript由Netscape公司的Brendan Eich于1995年创造，最初是为了增强HTML页面的功能性。随着时间的推移，JavaScript逐渐演变成一种通用的编程语言，可以在浏览器以外的环境中运行，例如服务器端的Node.js。
每 日练 习
m0_67187271的博客
07-19 1052
正确答案：C 解析：是正确的，这是最基本的类定义形式，没有继承任何类，也没有实现任何接口。也是正确的，这里定义了一个名为x的类，它继承了名为y的类。同样是正确的，这里定义了一个公共类x，它继承了Applet类，这在Java中是合法的，尤其是在创建GUI应用程序时常见。是不正确的，因为在Java中，我们不能使用static关键字来修饰一个类的定义。static关键字只能用于类的方法、变量或者是内部类（即嵌套类），但不能用于顶级类（非嵌套类）。所以，这个选项是错误的。因此，正确答案是C。
10.jdk源码阅读之ReentrantLock
前端、移动端、后端源码级底层原理分享
07-19 969
AQS 是 ReentrantLock 的底层实现基础。它维护了一个 FIFO 队列，用于管理等待线程，并提供了获取和释放锁的基本操作。
对androidTestDebug 产物进行重新签名
shuizhizhiyin的专栏
07-19 573
在运行 gradle assembleAndroidTestDebug 任务后，自定义的 reSignAndroidTestDebug 任务将会被执行，并对子模块的 androidTestDebug 产物进行重新签名。your_keystore_path.jks、your_keystore_password、your_key_alias 和 your_key_password 需要替换为你的实际路径和密码。如果需要对其他子模块的产物进行重新签名，可以根据需要创建不同的自定义任务。// 设置密钥库密码。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

你我有猿

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

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

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

打赏作者

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

抵扣说明：

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

余额充值