4.0 疯狂java讲义 第4版 第4章 概述

本章要点

• 顺序结构
• if分支语句
• switch分支语句
• whle循环
• do while循环
• for循环
• 嵌套循环
• 控制循环结构
• 理解数组
• 数组的定义和初始化
• 使用数组元素
• 数组作为引用类型的运行机制
• 多维数组的实质
• 操作数组的工具类
• 数组的实际应用场景

流程控制结构

不论哪一种编程语言,都会提供两种基本的流程控制结构:分支结构和循环结构。其中
分支结构用于实现根据条件来选择性地执行某段代码,
循环结构则用于实现根据循环条件重复执行某段代码。

java中的流程控制语法

Java同样提供了这两种流程控制结构的语法,Java提供了if和switch两种分支语句,并提供了while、do while和for三种循环语句。除此之外,JDK 5还提供了一种新的循环:for each循环,能以更简单的方式来遍历集合、数组的元素。
Java还提供了break和continue来控制程序的循环结构。

数组

数组也是大部分编程语言都支持的数据结构,Java也不例外。Java的数组类型是一种引用类型的变量,Java程序通过数组引用变量来操作数组,包括获得数组的长度,访问数组元素的值等。本章将会详细介绍Java数组的相关知识,包括如何定义、初始化数组等基础知识,并会深入介绍数组在内存中的运行机制。

4.1 顺序结构

任何编程语言中最常见的程序结构就是顺序结构。顺序结构就是程序从上到下逐行地执行,中间没有任何判断和跳转。
如果main方法的多行代码之间没有任何流程控制,则程序总是从上向下依次执行,排在前面的代码先执行,排在后面的代码后执行。这意味着:如果没有流程控制,Java方法里的语句是一个顺序执行流,从上向下依次执行每条语句。

3.8 本章小结

本章详细介绍了Java语言的各种基础知识,包括Java代码的三种注释语法,并讲解了如何查阅JDK API文档,这是学习Java编程必须掌握的基本技能。
本章讲解了Java程序的标识符规则和数据类型的相关知识,包括基本类型的强制类型转换和自动类型转换。
除此之外,本章还详细介绍了Java语言提供的各种运算符,包括算术、位、赋值、比较、逻辑等常用运算符,并详细列出了各种运算符的结合性和优先级。

3.7.8 运算符的结合性和优先级

所有的数学运算都认为是从左向右运算的,Java语言中大部分运算符也是从左向右结合的,只有单目运算符、赋值运算符和三目运算符例外,其中,单目运算符、赋值运算符和三目运算符是从右向左结合的,也就是从右向左运算。
乘法和加法是两个可结合的运算,也就是说,这两个运算符左右两边的操作数可以互换位置而不会影响结果。
运算符有不同的优先级,所谓优先级就是在表达式运算中的运算顺序。表3.4列出了包括分隔符在内的所有运算符的优先级顺序,上一行中的运算符总是优先于下一行的。

根据表3.4中运算符的优先级,下面分析一下int a=3;int b=a+2*a;语句的执行过程。程序先执行2*a得到6,再执行a+6得到9。
如果使用()就可以改变程序的执行顺序,例如int b=(a+2)*a,则先执行a+2得到结果5,再执行5*a得到15

因为Java运算符存在这种优先级的关系,因此经常看到有些学生在做SCJP,或者某些公司的面试题,有如下Java代码:

1
2
3

int a=5;
int b=4;
int c= a++ - --b * ++a / b-- >>2 % a--;

的值是多少?这样的语句实在太恐怖了,即使多年的老程序员看到这样的语句也会眩晕。
这样的代码只能在考试中出现,源代码就是一份文档,源代码的可读性比代码运行效率更重要。因此在这里要提醒读者

• 不要把一个表达式写得过于复杂,如果一个表达式过于复杂,则把它分成几步来完成
• 不要过多地依赖运算符的优先级来控制表达式的执行顺序,这样可读性太差,尽量使用()来控制表达式的执行顺序。

3.7.7 三目运算符

三目运算符只有一个:? :,三目运算符的语法格式如下:

1

(expression) ? if-true-statement : if-false-statement;

三目运算符的规则是:先对逻辑表达式expression求值,如果逻辑表达式返回true,则返回第二个操作数的值,如果逻辑表达式返回false,则返回第三个操作数的值。

看如下代码

1
2

String str = 5 > 3 ? "5大于3" : "5不大于3";
System.out.println(str); // 输出"5大于3"

大部分时候,三目运算符都是作为if else的精简写法。因此,如果将上面代码换成if else的写法,则代码如下:

1
2
3
4
5
6

String str2 = null;
if (5 > 3) {
    str2 = "5大于3";
} else {
    str2 = "5不大于3";
}

三目运算和if else的区别

这两种代码写法的效果是完全相同的。三目运算符和if else写法的区别在于:if后的代码块可以有多个语句,但三目运算符是不支持多个语句的
三目运算符可以嵌套,嵌套后的三目运算符可以处理更复杂的情况,如下程序所示:

1
2
3
4

int a = 11;
int b = 12;
// 三目运算符支持嵌套
System.out.println(a > b ? "a大于b" : (a < b ? "a小于b" : "a等于b"));

上面程序中的输出语句是一个由三目运算符构成的表达式,这个表达式本身又被嵌套在三目运算符中。通过使用嵌套的三目运算符,即可让三目运算符处理更复杂的情况。

3.7.6 逻辑运算符

逻辑运算符用于操作两个布尔型的变量或常量。逻辑运算符主要有如下6个。

程序示例 逻辑运算符

下面代码示范了或、与、非、异或4个逻辑运算符的执行示意。

1
2
3
4
5
6
7
8

// 直接对false求非运算，将返回true
System.out.println(!false);
// 5>3返回true，'6'转换为整数54，'6'>10返回true，求与后返回true
System.out.println(5 > 3 && '6' > 10);
// 4>=5返回false，'c'>'a'返回true。求或后返回true
System.out.println(4 >= 5 || 'c' > 'a');
// 4>=5返回false，'c'>'a'返回true。两个不同的操作数求异或返回true
System.out.println(4 >= 5 ^ 'c' > 'a');

短路或和不短路或的区别

1
2
3
4
5
6
7
8

// 定义变量a,b，并为两个变量赋值
int a = 5;
int b = 10;
// 对a > 4和b++ > 10求或运算
if (a > 4 | b++ > 10) {
    // 输出a的值是5，b的值是11。
    System.out.println("a的值是:" + a + "，b的值是:" + b);
}

执行上面程序,看到输出a的值为5,b的值为11,这表明b++ > 10表达式得到了计算,但实际上没有计算的必要,因为a>4已经返回了true,则整个表达式一定返回true
再看如下代码,只是将上面示例的不短路逻辑或改成了短路逻辑或

1
2
3
4
5
6
7
8

// 定义变量c,d，并为两个变量赋值
int c = 5;
int d = 10;
// c > 4 || d++ > 10求或运算
if (c > 4 || d++ > 10) {
    // 输出c的值是5，d的值是10。
    System.out.println("c的值是:" + c + "，d的值是:" + d);
}

上面代码执行的结果是:c的值为5,而d的值为10。
对比两段代码,后面的代码仅仅将不短路或改成短路或,程序最后输出的d值不再是11,这表明表达式d++>10没有获得执行的机会。
因为对于短路逻辑或而言,如果第一个操作数返回true,短路逻辑或将不再对第二个操作数求值,直接返回true。也就是不会计算d++>10这个逻辑表达式,因而d++没有获得执行的机会。因此,最后输出的d值为10。而不短路或总是执行前后两个操作数

短路与和不短路与的区别

&&与&的区别与此类似:

• &总会计算前后两个操作数,
• &&先计算左边的操作数,如果左边的操作数为false,则直接返回false,根本不会计算右边的操作数。

3.7.5 比较运算符

比较运算符用于判断两个变量或常量的大小,比较运算的结果是一个布尔值(true或false)。Java支持的比较运算符如下。

等于运算符

对于等于运算符,

• 如果进行比较的两个操作数都是数值类型,即使它们的数据类型不相同,只要它们的值相等,也都将返回true。
  • 例如97=='a'返回true，5.0==5也返回true。

-Java也支持两个boolean类型的值进行比较,例如,true==false将返回false。

• 如果两个操作数都是引用类型,那么只有当两个引用变量的类型具有父子关系时才可以比较,而且这两个引用必须指向同一个对象才会返回true。

不能使用==比较的情况

• 基本类型的变量、值不能和引用类型的变量、值使用==进行比较;
• boolean类型的变量、值不能与其他任意类型的变量、值使用==进行比较;
• 如果两个引用类型之间没有父子继承关系,那么它们的变量也不能使用==进行比较

程序示例 比较运算符的使用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

public class ComparableOperatorTest {
    public static void main(String[] args) {
        System.out.println("5是否大于 4.0：" + (5 > 4.0)); // 输出true
        System.out.println("5和5.0是否相等：" + (5 == 5.0)); // 输出true
        System.out.println("97和'a'是否相等：" + (97 == 'a')); // 输出true
        System.out.println("true和false是否相等：" + (true == false)); // 输出false
        
        // 创建2个ComparableOperatorTest对象，分别赋给t1和t2两个引用
        ComparableOperatorTest t1 = new ComparableOperatorTest();
        ComparableOperatorTest t2 = new ComparableOperatorTest();
        // t1和t2是同一个类的两个实例的引用，所以可以比较，
        // 但t1和t2引用不同的对象，所以返回false
        System.out.println("t1是否等于t2：" + (t1 == t2));
        // 直接将t1的值赋给t3，即让t3指向t1指向的对象
        ComparableOperatorTest t3 = t1;
        // t1和t3指向同一个对象，所以返回true
        System.out.println("t1是否等于t3：" + (t1 == t3));
    }
}

3.7.4 扩展后的赋值运算符

赋值运算符可与算术运算符、位移运算符结合,扩展成功能更加强大的运算符。扩展后的赋值运算符如下

只要能使用这种扩展后的赋值运算符,通常都推荐使用它们。因为这种运算符不仅具有更好的性能,而且程序会更加健壮。

程序示例 +=运算符的用法

下面程序示范了+=运算符的用法。

1
2
3
4
5
6
7
8
9
10
11
12
13

public class EnhanceAssignTest {
    public static void main(String[] args) {
        // 定义一个byte类型的变量
        byte a = 5;
        // 下面语句出错，因为5默认是int类型，a + 5就是int类型。
        // 把int类型赋给byte类型的变量，所以出错
        // a = a + 5;
        // 定义一个byte类型的变量
        byte b = 5;
        // 下面语句不会出现错误
        b += 5;
    }
}

+=不会自动类型提升

运行上面程序,不难发现a=a+5和a+=5虽然运行结果相同,但底层的运行机制还是存在一定差异的。因此,如果可以使用这种扩展后的运算符,则推荐使用它们

3.7.3 位运算符

Java支持的位运算符有如下7个

一般来说,位运算符只能操作整数类型的变量或值。

按位与 按位或 按位异或 的运算法则如表3.3所示。

按位非只需要一个操作数,这个运算符将把操作数在计算机底层的二进制码按位(包括符号位)取反。

程序示例 安慰与 按位或

如下代码测试了按位与和按位或运算的运行结果。

1
2

System.out.println(5 & 9); // 将输出1
System.out.println(5 | 9); // 将输出13

5的二进制码是000_0101(省略了前面的24个0),而9的二进制码是0000_1001(省略了前面的24个0)。运算过程如图3.12所示

程序示例 按位异或 按位取反

下面是按位异或和按位取反的执行代码

1
2

System.out.println(~-5); // 将输出4
System.out.println(5 ^ 9); // 将输出12

下面通过图3.13来介绍运算原理:

而5^9的运算过程如图3.14所示:

程序示例 左移运算

左移运算符是**将操作数的二进制码整体左移指定位数,左移后右边空出来的位以0填充**。例如如下代码

1
2

System.out.println(5 << 2); // 输出20
System.out.println(-5 << 2); // 输出-20

下面以-5为例来介绍左移运算的运算过程,如图3.15所示。

在图3.15中,上面的32位数是5的补码,左移两位后得到一个二进制补码,这个二进制补码的最高位是1,表明是一个负数,换算成十进制数就是20。

右移运算符 无符号右移运算符

Java的右移运算符有两个:>>和>>>。

右移运算符 以符号位填充

对于右移运算符>>而言,把第一个操作数的二进制码右移指定位数后,左边空出来的位以原来的符号位填充,即
如果第一个操作数原来是正数,则左边补0;
如果第个操作数是负数,则左边补1。

无符号右移运算符 以0填充

>>>是无符号右移运算符,它把第一个操作数的二进制码右移指定位数后,左边空出来的位总是以0填充

1
2

System.out.println(-5 >> 2); // 输出-2
System.out.println(-5 >>> 2); // 输出1073741822

下面用示意图来说明>>和>>>运算符的运算过程

右移不改变正负符号

从图3.16来看,-5右移2位后左边空出2位,空出来的2位以符号位补充。从图中可以看出,右移运算后得到的结果的正负与第一个操作数的正负相同。右移后的结果依然是一个负数,这是一个二进制补码,换算成十进制数就是-2。

无符号右移总是得到正数

从图3.17来看,-5无符号右移2位后左边空出2位,空出来的2位以0补充。从图中可以看出,无符号右移运算后的结果总是得到一个正数。图3.17中下面的正数是1073741822(2^30-2)。
进行移位运算时还要遵循如下规则。

• 对于低于int类型(如byte、short和char)的操作数总是先自动类型转换为int类型后再移位
• 对于int类型的整数移位a>>b,因为int类型是32位,所以当b>32时,所以系统先用b对32求余,得到的结果才是真正移位的位数。例如,a>>33和a>>1的结果完全一样,而a>>32的结果和a本身相同。
• 对于long类型的整数移位a>>b,因为long类型是64位,所以当b>64时,总是先用b对64求余,得到的结果才是真正移位的位数。

左移相当于乘以2的n次方 右移相当于除以2的n次方

当进行移位运算时,只要被移位的二进制码没有发生有效位的数字丢失,不难发现左移n位就相当于乘以2的n次方,右移n位则是除以2的n次方。不仅如此,进行移位运算不会改变操作数本身,只是得到了一个新的运算结果,而原来的操作数本身是不会改变的

3.7.2 赋值运算符

赋值运算符用于为变量指定变量值,与C类似,Java也使用=作为赋值运算符。

直接量赋值给变量

通常,使用赋值运算符将一个直接量值赋给变量。例如如下代码

1
2
3

String str = "Java"; // 为变量str赋值为Java
double pi = 3.14; // 为变量pi赋值为3.14
boolean visited = true; // 为变量visited赋值为true

变量赋值给变量

除此之外,也可使用赋值运算符将一个变量的值赋给另一个变量。如下代码是正确的

1

String str2 = str; // 将变量str的值赋给str2

赋值运算符左边只能是变量

按前面关于变量的介绍,可以把变量当成一个可盛装数据的容器。而赋值运算就是将被赋的值“装入”变量的过程。赋值运算符是从右向左执行计算的,程序先计算得到=右边的值,然后将该值“装入”ˉ左边的变量,因此赋值运算符(=)左边只能是变量。

赋值表达式的值 连续赋值

值得指出的是,赋值表达式是有值的,赋值表达式的值就是右边被赋的值。例如String str2=str这个语句中,表达式str2=str的值就是str。因此,赋值运算符支持连续赋值,通过使用多个赋值运算符,可以一次为多个变量赋值。如下代码是正确的:

1
2
3
4
5
6
7

int a;
int b;
int c;
// 通过为a, b , c赋值，三个变量的值都是7
a = b = c = 7;
// 输出三个变量的值。
System.out.println(a + "\n" + b + "\n" + c);

虽然Java支持这种一次为多个变量赋值的写法,但这种写法导致程序的可读性降低,此不推荐这样写.

将表达式的值赋值给变量

赋值运算符还可用于将表达式的值赋给变量。如下代码是正确的。

1
2
3

double d1 = 12.34;
double d2 = d1 + 5; // 将表达式的值赋给d2
System.out.println(d2); // 输出d2的值，将输出17.34

3.7 运算符

运算符是一种特殊的符号,用以表示数据的运算、赋值和比较等。Java语言使用运算符将一个或多个操作数连缀成执行性语句,用以实现特定功能

java运算符分类

Java语言中的运算符可分为如下几种。

• 算术运算符
• 赋值运算符
• 比较运算符
• 逻辑运算符
• 位运算符
• 类型相关运算符

3.7.1 算术运算符

Java支持所有的基本算术运算符,这些算术运算符用于执行基本的数学运算:加、减、乘、除和求余等。下面是7个基本的算术运算符。

加法运算符

加法运算符为:+。例如如下代码:

1
2
3
4
5

double a = 5.2;
double b = 3.1;
double sum = a + b;
//sum的值为8.3
System.out.println(sum);

除此之外,+还可以作为字符串的连接运算符。

减法运算符

减法运算符为:-。例如如下代码:

1
2
3
4
5

double a = 5.2;
double b = 3.1;
double sub = a-b;
//sub的值为2.1
System.out.println(sub);

乘法运算符

乘法运算符为:*。例如如下代码:

1
2
3
4
5

double a = 5.2;
double b = 3.1;
double multiply = a* b;
//multiply的值为16.12
System.out.println(multiply);

除法运算符

除法运算符为:/。被除数/除数

整数除法

除法运算符有些特殊,如果除法运算符的两个操作数都是整数类型,则计算结果也是整数,就是将自然除法结果的小数部分丢弃,例如19/4的结果是4,而不是5。

整数除法除数不能为零

如果除法运算符的两个操作数都是整数类型,则除数不可以是0,否则将引发除以零异常。

浮点数除法

但如果除法运算符的两个操作数有一个是浮点数,或者两个都是浮点数,则计算结果也是浮点数,这个结果就是自然除法的结果。

浮点数除法的除数可以为零 结果为无穷大

浮点数除法允许除数是0,或者0.0,如果除数是0或者0.0,则得到结果是正无穷大或负无穷大。看下面代码。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

public class DivTest {
    public static void main(String[] args) {
        double a = 5.2;
        double b = 3.1;
        double div = a / b;
        // div的值将是1.6774193548387097
        System.out.println(div);
        // 输出正无穷大：Infinity
        System.out.println("5除以0.0的结果是:" + 5 / 0.0);
        // 输出负无穷大：-Infinity
        System.out.println("-5除以0.0的结果是:" + -5 / 0.0);
        // 下面代码将出现异常
        // java.lang.ArithmeticException: / by zero
        System.out.println("-5除以0的结果是::" + -5 / 0);
    }
}

运行结果:

1
2
3
4
5

1.6774193548387097
5除以0.0的结果是:Infinity
-5除以0.0的结果是:-Infinity
Exception in thread "main" java.lang.ArithmeticException: / by zero
        at DivTest.main(DivTest.java:14)

求余运算

求余运算符为:%。求余运算的结果不一定总是整数,它的计算结果是使用第一个操作数除以第二个操作数,得到一个整除的结果后剩下的值就是余数。

整数求余运算第二个操作数不能为零

由于求余运算也需要进行除法运算,因此如果求余运算的两个操作数都是整数类型,则求余运算的第二个操作数不能是0,否则将引发除以零异常。

浮点数求余运算第二个操作数为零得到非数

如果求余运算的两个操作数中有一个或者两个都是浮点数,则允许第二个操作数是0或0.0。**如果求余运算第二个操作数为零,求余运算的结果是非数:NaN**。

浮点数求余运算第一个操作数为零得到零

0或0.0对零以外的任何数求余都将得到0或0.0。

程序示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

public class ModTest {
    public static void main(String[] args) {
        double a = 5.2;
        double b = 3.1;
        double mod = a % b;

        System.out.println("5.2  对3.1 求余的结果是:" + mod); // mod的值为2.1
        System.out.println("5    对0.0 求余的结果是:" + 5 % 0.0); // 输出非数:NaN
        System.out.println("-5.0 对0   求余的结果是:" + -5.0 % 0); // 输出非数:NaN
        System.out.println("0    对5.0 求余的结果是:" + 0 % 5.0); // 输出0.0
        System.out.println("0    对0.0 求余的结果是:" + 0 % 0.0); // 输出非数:NaN
        // 下面代码将出现异常：java.lang.ArithmeticException: / by zero
        System.out.println("-5   对0   求余的结果是:" + -5 % 0);
    }
}

自加运算

自加运算符为:++,该运算符有两个要点:

1. 自加是单目运算符,只能操作一个操作数;
2. 自加运算符只能操作单个数值型(整型、浮点型都行)的变量,不能操作常量或表达式。

运算符既可以出现在操作数的左边,也可以出现在操作数的右边。但出现在左边和右边的效果是不一样的。

左加加 先加一再取值

如果把++放在左边,则先把操作数加1,然后才把操作数放入表达式中运算;

右加加 先取值再加一

如果把++放在右边,则先把操作数放入表达式中运算,然后才把操作数加1。

程序示例 右加加

看如下代码:

1
2
3
4
5

int a= 5;
// 让a先执行算术运算,然后自加
int b= a++ +6;
//输出a的值为6,b的值为11
System.out.println(a + "\n"+ b);

执行完后,a的值为6,而b的值为11。
当++在操作数右边时,先执行a+6的运算(此时a的值为5),然后对a加1。

程序示例 左加加

对比下面代码

1
2
3
4
5

int a = 5;
//让a先自加,然后执行算术运算
int b = ++a +6;
//输出a的值为6,b的值为12
System.out.println(a +"\n"+ b);

执行的结果是a的值为6,b的值为12。当++在操作数左边时,先对a加1,然后执行a+6的运算(此时a的值为6),因此b为12。

自减运算符

自减运算符为:--。也是单目运算符,用法与++基本相似,只是将操作数的值减1

更加复杂的运算

Java并没有提供其他更复杂的运算符,如果需要完成乘方、开方等运算,则可借助于java.lang.Math类,Math类下包含了丰富的静态方法,用于完成各种复杂的数学运算

程序示例 乘方 开方 三角

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

public class MathTest {
    public static void main(String[] args) {
        double a = 3.2; // 定义变量a为3.2
        // 求a的5次方，并将计算结果赋为b。
        double b = Math.pow(a, 5);
        System.out.println(a + "^" + "5=" + b); // 输出b的值。
        // 求a的平方根，并将结果赋给c
        double c = Math.sqrt(a);
        System.out.println(c); // 输出c的值。
        // 计算随机数,返回一个0～1之间的伪随机数。
        double d = Math.random();
        System.out.println(d); // 输出随机数d的值
        // 求1.57的sin函数值：1.57被当成弧度数
        double e = Math.sin(1.57);
        System.out.println(e); // 输出接近1
    }
}

负数运算符

+除可以作为数学的加法运算符之外,还可以作为字符串的连接运算符。

-除可以作为减法运算符之外,还可以作为求负的运算符

1
2
3

//定义 double变量x,其值为-5.0
double x=-5.0;
x=-x;//将x求负,其值变成5.0