【03-流程控制与数组】

流程控制与数组

顺序结构

　　•顺序结构就是程序从上到下一行一行地执行，中间没有任何判断和跳转。

　　•如果main方法多行代码之间没有任何流程控制，则程序总是从上向下依次执行，排在前面的代码先执行，排在后

面的代码后执行。

分支结构

•Java提供了两种常见的分支控制结构：

–if语句：使用布尔表达式或布尔值作为分支条件来进行分支控制。

–switch语句：用于对多个整型值进行匹配，从而实现分支控制。

if条件语句

•if条件语句的3种形式：

• ▲ if (logic expression) { statements…}

• else { statements…}

• ▲ if (logic expression) { statements…}

• else if (logic expression) { statements…}

• …//可以有0个或多个else if 语句

• else { statements…} //最后的else语句也可以省略

•注意：if、else、else if 后条件执行体要么是一个花括号括起来的语句块，则这个语句块整体作为条件执行体；

要么是以分号为结束符的一行语句，甚至可能是一个空语句（空语句就是一个分号）。

If语句常见的错误

•如果if、else、else if后的执行体只有一行语句时，则可以省略花括号，但我们最好不要省略花括号，因为保留花

括号会有更好的可读性，且还可以减少发生错误的可能。

•对于if 语句，还有一个很容易出现的逻辑错误，这个逻辑错误并不属于语法问题，但引起错误的可能性更大。如

后面程序TestIfError.java我们想打印的是中年人，但打印出来的结果是青年人。

• 对于任何的if else 语句，表面上看起来else后没有任何条件，或者else if后只有一个条件，但这不是真相：因为

else的含义是“否则”，else本身就是一个条件！else 的隐含条件就是对前面条件取反。

switch分支语句

•可以省略case后代码块的花括号

◆使用break;语句，防止case穿透

◆default可以省略，但不推荐省略

◆switch语句中控制表达式的类型只能是byte、short、char、int、String（JDK7新增）和枚举

Switch语句容易导致的错误

•switch语句后的expression表达式的数据类型只能是byte、short、char、int、String类型和枚举；

•小心省略了case后代码块的break;时所引入的陷阱。

循环结构

•Java支持3种基本的循环语句：

–while 循环语句

–do while 循环语句

– for 循环语句

while & do while 循环语句

★ while 循环的语法格式如下：

[init_statements]

while (test_expression)

{ statements;

[iteration_statements]

}

★ 执行过程：先判断逻辑表达式的值，若为true

则执行其后面的语句，然后再次判断条件并反复

执行，直到条件不成立为止。

★ do while 循环的语法格式如下：

[init_statements]

{ 　　statements;

[iteration_statements]

}while (test_expression);

※注意：do while 循环的循环条件必须有一个分

号，这个分号表明循环结束。

★ 执行过程：先执行语句，再判断逻辑表达式的

值，若为true，再执行语句，否则结束循环

控制循环条件

•使用循环时，一定要保证循环条件有变成false的时候，如果循环条件永远为true，那就是死循环。使用while循

　　环时还有一个陷阱，while循环条件后紧跟一个分号。

•do while 循环语句里，即使test_expression循环条件的值开始是假，do while循环也会执行循环体。因此，

　　do while循环的循环体至少执行一次。

本文原创作者：pipi-changing

本文原创出处：http://www.cnblogs.com/pipi-changing/

for 循环语句

•for ([inint_statements] ; [test_expression] ; [iteration_statements]){ statements }

•★ 执行过程：首先计算表达式1，即init_statements，接着执行表达式2，即test_expression，若表达式2的

值为true，则执行语句（statements），接着执行表达式3，即iteration_statements，再判断表达式2的值；

依次重复下去，直到表达式的值=false，则结束for循环。因此，for循环的循环条件（表达式2）比循环体（语

句）要多执行一次。

•注意：for循环的循环迭代语句并没有与循环体放在一起，因此即使在执行循环体时遇到continue语句结束本次

循环，循环迭代语句一样会得到执行。

for循环指定多个初始化语句

•for 循环允许同时指定多个初始化语句，循环条件也可以是一个包含逻辑运算符的表达式。但只能有一个声明语

　　句，因此如果需要在初始化表达式中声明多个变量，那么这些变量应该有相同的数据类型。

•初学者使用for循环时也容易犯一个错误，他们以为只要在for后的括号内控制了循环循环迭代语句就万无一失，

　　但实际情况则不是这样的。

for循环的分号

•for 循环圆括号中只有两个分号是必须的，初始化语句、循环条件、迭代语句部分都可以省略，如果省略了循环

　　条件，则这个循环条件默认是true，将会产生一个死循环。

•使用for循环时，还可以把初始化条件定义在循环体之外，把循环迭代语句放在循环体内，这种做法将非常类似前

　　面的while循环。

嵌套循环

•各种基本类型的循环都可以作为外层循环，各种基本类型的循环也可以作为内层循环。

•假设外层循环的循环次数为n次，内层循环的循环次数为m次，那么内层循环的循环体实际上需要执行n*m次。

•实际上，嵌套循环不仅可以是两层嵌套，还可以是三层嵌套，四层嵌套……

break语句

•break用于完全结束一个循环，跳出循环体。不管是哪种循环，一旦在循环体中遇到break，系统将完全结束循

　　环，开始执行循环之后的代码。

•break不仅可以结束其所在的循环，还可结束其外层循环。此时需要在break后紧跟一个标签，这个标签用于标

识一个外层循环。Java中的标签就是一个紧跟着英文冒号（:）的标识符。且它必须放在循环语句之前才有作用。

continue 语句

•continue的功能和break有点类似，区别是continue只是中止本次循环，接着开始下一次循环。而break则是

完全中止循环。

return语句

• return关键字并不是专门用于跳出循环的，return的功能是结束一个方法。

•一旦在循环体内执行到一个return语句，return语句将会结束该方法，循环自然也随之结束。与continue和

break不同的是，return直接结束整个方法，不管这个return处于多少层循环之内。

数组类型

•在任何已有类型后加上方括号[ ]，又变成一种新类型，这种类型统称为数组类型，所有的数组类型又称为引用类

型，所以又称引用类型。

•Java的数组要求所有数组元素具有相同的数据类型。因此，在一个数组中，数组元素的类型是唯一的，即一个数

组里只能存储一种数据类型的数据，而不能存储多种数据类型的数据。

•一旦数组的初始化完成，数组在内存中所占的空间将被固定下来，因此数组的长度将不可改变。即使把某个数组

元素的数据清空，但它所占的空间依然被保留，依然属于该数组，数组的长度依然不变。

•Java的数组既可以存储基本类型的数据，也可以存储引用类型的数据。

•值得指出的是：数组也是一种数据类型，它本身是一种引用类型。

定义数组

•Java语言支持两种语法格式来定义数组：

–type[ ] arrayName;

–type arrayName[ ];

•对于这两种语法格式，一般推荐使用第一种格式。因为第一种格式不仅具有更好的语意，也具有更好的可读性。

•数组是一种引用类型的变量，因此使用它定义一个变量时，仅仅表示定义了一个引用变量（也就是定义了一个指

　　针），这个引用变量还未指向任何有效的内存，因此定义数组时不能指定数组的长度。

•※注意：定义数组时不能指定数组的长度。

数组的初始化

•静态初始化：初始化时由程序员显式指定每个数组的初始值，由系统决定需要的数组长度。

•动态初始化：初始化时程序员指定数组长度，由系统为数组元素分配初始值

动态初始化

•arrayName = new type[ length];

在上面的语法中，需要指定一个int整型的length参数，这个参数指定了数组的长度，也就是可以容纳数组元素的

个数。

使用数组

•数组最常用的用法就是访问数组元素，包括对数组元素赋值和访问数组元素的值，访问数组元素是通过在数组引用变

量后紧跟一个方括号（[ ]），方括号里是数组元素的索引值。

•Java语言的数组索引是从0开始的，也就是说，第一个数组元素的索引值为0，最后一个数组元素的索引为数组长度

减1。

•如果访问数组元素进指定的索引小于0，或者大于等于数组的长度，编译程序不会出现任何错误，但运行时出现异

常：java.lang.ArrayIndexOutOfBoundsException:2（数组索引越界异常），在这个异常提示信息后有一个int

整数，这个整数就是程序员试图访问的数组索引。

•所有数组都提供了一个length属性，通过这个属性可以访问到数组的长度，一旦获得了数组的长度后，就可以通过循

环来遍历该数组的每个数组元素。

JDK1.5 提供了foreach循环

•从JDK1.5 之后，Java提供了一种更简单的循环：foreach循环，这种循环遍历数组和集合更加简洁。使用

foreach循环遍历数组和集合元素时，无须获得数组和集合长度，无须根据索引来访问数组元素和集合元素，

foreach循环自动遍历数组和集合的每个元素。

•当使用foreach循环来迭代输出数组元素或集合时，通常不要对循环变量进行赋值，虽然这种赋值在语法上是允

许的，但没有太大的意义，而且极容易引起错误。

深入数组

•数组元素和数组变量在内存里是分开存放的。

实际的数组元素是存储在堆（heap）内存中；数组引用变量是一个引用类型的变量，被存储在栈（stack）内存

中。

•如果堆内存中数组不再有任何引用变量指向自己，则这个数组将成为垃圾，该数组所占的内存将会被系统的垃圾

回收机制回收。因此，为了让垃圾回收机制回收一个数组所占的内存空间，则可以将该数组变量赋为null，也就切

断了数组引用变量和实际数组之间的引用关系，实际数组也就成了垃圾。

数组长度不可变

•只要类型相互兼容，可以让一个数组变量指向另一个实际的数组，这种操作会产生数组的长度可变的错觉。

•但由于数组变量整体赋值导致的数组的长度可以改变，只是一个假相。

基本类型数组的初始化

•对于基本类型数组而言，数组元素的值直接存储在对应的数组元素中，因此，初始化数组时，先为该数组分配内

存空间，然后直接将数组元素的值存入对应数组元素中，

public class TestPrimitiveArray

{

    public static void main(String[] args)

    {

        // 定义一个int[ ]类型的数组变量

        int[] iArr;

        // 动态初始化数组，数组长度为5

        iArr = new int[5];

        // 采用循环方式为每个数组元素赋值

        for (int i = 0; i < iArr.length; i++)

        {

            iArr[i] = i + 10;

            System.out.println(iArr[i]);

        }

    }

}

TestPrimitiveArray

引用类型数组的初始化

引用类型数组的数组元素是引用，因此情况变得更加复杂：每个数组元素里存储的还是引用，它指向另一块内存，

这块内存里存储了有效数据。

没有多维数组

•Java语言提供了多维数组的语法，但多维数组实质上还是一维数组。

Java语言里的数组类型是引用类型，因此，数组变量其实是一个引用，这个引用指向真实的数组内存。数组元素

的类型也可以是引用，如果数组元素的引用再次指向真实的数组内存，这种情形看上去很像多维数组。

•定义二维数组的语法：

•type[ ] [ ] arrName;

public class TestTwoDimension {
    public static void main(String[] args) {
        // 定义一个二维数组
        int[][] a;
        // 把a当成一维数组进行初始化，初始化a是一个长度为3的整数
        // a数组的数组元素又是引用类型
        a = new int[3][];
        // 把a数组当成一维数组，遍历a数组的每个元素
        for (int i = 0; i < a.length; i++) {
            System.out.println(a[i]);
        }
        // 初始化a数组的第一个元素
        a[0] = new int[2];
        // 访问a数组的第一个元素所指数组的第二个元素
        a[0][1] = 6;
        // a数组的第一个元素是一个一维数组，遍历这个一维数组
        for (int i = 0; i < a[0].length; i++) {
            System.out.println(a[0][i]);
        }
    }
//    null
//    null
//    null
//    0
//    6

}

TestTwoDimension

我们可以得到一个结论：

二维数组是一维数组，其数组元素是一维数组；三维数组也是一维数组，其数组元素是二维数组；四维数组还是一维数

组，其数组元素是三维数组……从这个角度来看，Java语言里没有多维数组。

Java 8增强的Arrays工具类

•Arrays类里包含的一些static修饰的方法可以直接操作数组。

•Java 8增强了Arrays类的功能，Java 8为Arrays类增加了一些工具方法，这些工具方法可以充分利用多CPU并

行的能力来提高设值、排序的性能。

代码区：

public class IfCorrectTest {
    public static void main(String[] args) {
        int age = 45;
        if (age > 60) {
            System.out.println("老年人");
        } else if (age > 40) {
            System.out.println("中年人");
        } else if (age > 20) {
            System.out.println("青年人");
        }
    }
//    中年人

}

IfCorrectTest

public class IfCorrectTest2 {
    public static void main(String[] args) {
        int age = 45;
        if (age > 60) {
            System.out.println("老年人");
        }
        // 在原本的if条件中增加了else的隐含条件
        if (age > 40 && !(age > 60)) {
            System.out.println("中年人");
        }
        // 在原本的if条件中增加了else的隐含条件
        if (age > 20 && !(age > 60) && !(age > 40 && !(age > 60))) {
            System.out.println("青年人");
        }
    }
//    中年人

}

IfCorrectTest2

public class IfErrorTest {
    public static void main(String[] args) {
        int age = 45;
        if (age > 20) {
            System.out.println("青年人");
        } else if (age > 40) {
            System.out.println("中年人");
        } else if (age > 60) {
            System.out.println("老年人");
        }
    }
//    青年人

}

IfErrorTest

public class IfErrorTest2 {
    public static void main(String[] args) {
        int age = 45;
        if (age > 20) {
            System.out.println("青年人");
        }
        // 在原本的if条件中增加了else的隐含条件
        if (age > 40 && !(age > 20)) {
            System.out.println("中年人");
        }
        // 在原本的if条件中增加了else的隐含条件
        if (age > 60 && !(age > 20) && !(age > 40 && !(age > 20))) {
            System.out.println("老年人");
        }
    }
//    青年人

}

IfErrorTest2

public class IfTest {
    public static void main(String[] args) {
        int age = 30;
        if (age > 20)
        // 只有当age > 20时，下面花括号括起来的语句块才会执行
        // 花括号括起来的语句是一个整体，要么一起执行，要么一起不会执行
        {
            System.out.println("年龄已经大于20岁了");
            System.out.println("20岁以上的人应该学会承担责任...");
        }

        // 定义变量a ，并为其赋值
        int a = 5;
        if (a > 4)
            // 如果a>4，执行下面的执行体，只有一行代码作为代码块
            System.out.println("a大于4");
        else
            // 否则，执行下面的执行体，只有一行代码作为代码块
            System.out.println("a不大于4");

        // 定义变量b ，并为其赋值
        int b = 5;
        if (b > 4)
            // 如果b>4，执行下面的执行体，只有一行代码作为代码块
            System.out.println("b大于4");
        else
            // 否则，执行下面的执行体，只有一行代码作为代码块
            b--;
        // 对于下面代码而言，它已经不再是条件执行体的一部分，因此总会执行。
        System.out.println("b不大于4");

        // 定义变量c ，并为其赋值
        int c = 5;
        if (c > 4)
            // 如果b>4，执行下面的执行体，将只有c--;一行代码为条件体
            c--;
        // 下面是一行普通代码，不属于条件体
        System.out.println("c大于4");
        // 此处的else将没有if语句，因此编译出错。
        // else
        // 否则，执行下面的执行体，只有一行代码作为代码块
        System.out.println("c不大于4");

    }
//    年龄已经大于20岁了
//    20岁以上的人应该学会承担责任...
//    a大于4
//    b大于4
//    b不大于4
//    c大于4
//    c不大于4

}

IfTest

public class StringSwitchTest {
    public static void main(String[] args) {
        // 声明变量season
        String season = "夏天";
        // 执行swicth分支语句
        switch (season) {
        case "春天":
            System.out.println("春暖花开.");
            break;
        case "夏天":
            System.out.println("夏日炎炎.");
            break;
        case "秋天":
            System.out.println("秋高气爽.");
            break;
        case "冬天":
            System.out.println("冬雪皑皑.");
            break;
        default:
            System.out.println("季节输入错误");
        }
    }
//    夏日炎炎.

}

StringSwitchTest

public class SwitchTest {
    public static void main(String[] args) {
        // 声明变量score，并为其赋值为‘C‘
        char score = ‘C‘;
        // 执行swicth分支语句
        switch (score) {
        case ‘A‘:
            System.out.println("优秀");
            break;
        case ‘B‘:
            System.out.println("良好");
            break;
        case ‘C‘:
            System.out.println("中");
            break;
        case ‘D‘:
            System.out.println("及格");
            break;
        case ‘F‘:
            System.out.println("不及格");
            break;
        default:
            System.out.println("成绩输入错误");
        }
    }
//    中

}

SwitchTest

public class WhileTest {
    public static void main(String[] args) {
        // // 循环的初始化条件
        // int count = 0;
        // // 当count小于10时，执行循环体
        // while (count < 10)
        // {
        // System.out.println(count);
        // // 迭代语句
        // count++;
        // }
        // System.out.println("循环结束!");

        // // 下面是一个死循环
        // int count = 0;
        // while (count < 10)
        // {
        // System.out.println("不停执行的死循环 " + count);
        // count--;
        // }
        // System.out.println("永远无法跳出的循环体");

        int count = 0;
        // while后紧跟一个分号，表明循环体是一个分号（空语句）
        while (count < 10)
            ;
        // 下面的代码块与while循环已经没有任何关系
        {
            System.out.println("------" + count);
            count++;
        }

    }
}

WhileTest

public class DoWhileTest {
    public static void main(String[] args) {
        // 定义变量count
        int count = 1;
        // 执行do while循环
        do {
            System.out.println(count);
            // 循环迭代语句
            count++;
            // 循环条件紧跟while关键字
        } while (count < 10);
        System.out.println("循环结束!");

        // 定义变量count2
        int count2 = 20;
        // 执行do while循环
        do
            // 这行代码把循环体和迭代部分合并成了一行代码
            System.out.println(count2++);
        while (count2 < 10);
        System.out.println("循环结束!");
    }
//    1
//    2
//    3
//    4
//    5
//    6
//    7
//    8
//    9
//    循环结束!
//    20
//    循环结束!

}

DoWhileTest

public class ForErrorTest {
    public static void main(String[] args) {
        // 循环的初始化条件,循环条件，循环迭代语句都在下面一行
        for (int count = 0; count < 10; count++) {
            System.out.println(count);
            // 再次修改了循环变量
            count *= 0.1;
        }
        System.out.println("循环结束!");
    }
}

ForErrorTest

public class ForInsteadWhile {
    public static void main(String[] args) {
        // 把for循环的初始化条件提出来独立定义
        int count = 0;
        // for循环里只放循环条件
        for (; count < 10;) {
            System.out.println(count);
            // 把循环迭代部分放在循环体之后定义
            count++;
        }
        System.out.println("循环结束!");
        // 此处将还可以访问count变量
    }
//    0
//    1
//    2
//    3
//    4
//    5
//    6
//    7
//    8
//    9
//    循环结束!

}

ForInsteadWhile

public class ForTest {
    public static void main(String[] args) {
        // 循环的初始化条件,循环条件，循环迭代语句都在下面一行
        for (int count = 0; count < 10; count++) {
            System.out.println(count);
        }
        System.out.println("循环结束!");
    }
//    0
//    1
//    2
//    3
//    4
//    5
//    6
//    7
//    8
//    9
//    循环结束!

}

ForTest

public class ForTest2 {
    public static void main(String[] args) {
        // 同时定义了三个初始化变量，使用&&来组合多个boolean表达式
        for (int b = 0, s = 0, p = 0; b < 10 && s < 4 && p < 10; p++) {
            System.out.println(b++);
            System.out.println(++s + p);
        }
    }
//    0
//    1
//    1
//    3
//    2
//    5
//    3
//    7

}

ForTest2

public class NestedLoopTest {
    public static void main(String[] args) {
        // 外层循环
        for (int i = 0; i < 5; i++) {
            // 内层循环
            for (int j = 0; j < 3; j++) {
                System.out.println("i的值为:" + i + "  j的值为:" + j);
            }
        }
    }
//    i的值为:0  j的值为:0
//    i的值为:0  j的值为:1
//    i的值为:0  j的值为:2
//    i的值为:1  j的值为:0
//    i的值为:1  j的值为:1
//    i的值为:1  j的值为:2
//    i的值为:2  j的值为:0
//    i的值为:2  j的值为:1
//    i的值为:2  j的值为:2
//    i的值为:3  j的值为:0
//    i的值为:3  j的值为:1
//    i的值为:3  j的值为:2
//    i的值为:4  j的值为:0
//    i的值为:4  j的值为:1
//    i的值为:4  j的值为:2

}

NestedLoopTest

public class WhileTest {
    public static void main(String[] args) {
        // // 循环的初始化条件
        // int count = 0;
        // // 当count小于10时，执行循环体
        // while (count < 10)
        // {
        // System.out.println(count);
        // // 迭代语句
        // count++;
        // }
        // System.out.println("循环结束!");

        // // 下面是一个死循环
        // int count = 0;
        // while (count < 10)
        // {
        // System.out.println("不停执行的死循环 " + count);
        // count--;
        // }
        // System.out.println("永远无法跳出的循环体");

        int count = 0;
        // while后紧跟一个分号，表明循环体是一个分号（空语句）
        while (count < 10)
            ;
        // 下面的代码块与while循环已经没有任何关系
        {
            System.out.println("------" + count);
            count++;
        }

    }
}

WhileTest

public class BreakTest {
    public static void main(String[] args) {
        // 一个简单的for循环
        for (int i = 0; i < 10; i++) {
            System.out.println("i的值是" + i);
            if (i == 2) {
                // 执行该语句时将结束循环
                break;
            }
        }
    }
//    i的值是0
//    i的值是1
//    i的值是2

}

BreakTest

public class BreakTest2 {
    public static void main(String[] args) {
        // 外层循环，outer作为标识符
        outer: for (int i = 0; i < 5; i++) {
            // 内层循环
            for (int j = 0; j < 3; j++) {
                System.out.println("i的值为:" + i + "  j的值为:" + j);
                if (j == 1) {
                    // 跳出outer标签所标识的循环。
                    break outer;
                }
            }
        }
    }
//    i的值为:0  j的值为:0
//    i的值为:0  j的值为:1

}

BreakTest2

public class ContinueTest {
    public static void main(String[] args) {
        // 一个简单的for循环
        for (int i = 0; i < 3; i++) {
            System.out.println("i的值是" + i);
            if (i == 1) {
                // 忽略本次循环的剩下语句
                continue;
            }
            System.out.println("continue后的输出语句");
        }
    }
//    i的值是0
//    continue后的输出语句
//    i的值是1
//    i的值是2
//    continue后的输出语句

}

ContinueTest

public class ContinueTest2 {
    public static void main(String[] args) {
        // 外层循环
        outer: for (int i = 0; i < 5; i++) {
            // 内层循环
            for (int j = 0; j < 3; j++) {
                System.out.println("i的值为:" + i + "  j的值为:" + j);
                if (j == 1) {
                    // 忽略outer标签所指定的循环中本次循环所剩下语句。
                    continue outer;
                }
            }
        }
    }
//    i的值为:0  j的值为:0
//    i的值为:0  j的值为:1
//    i的值为:1  j的值为:0
//    i的值为:1  j的值为:1
//    i的值为:2  j的值为:0
//    i的值为:2  j的值为:1
//    i的值为:3  j的值为:0
//    i的值为:3  j的值为:1
//    i的值为:4  j的值为:0
//    i的值为:4  j的值为:1

}

ContinueTest2

public class ReturnTest {
    public static void main(String[] args) {
        // 一个简单的for循环
        for (int i = 0; i < 3; i++) {
            System.out.println("i的值是" + i);
            if (i == 1) {
                return;
            }
            System.out.println("return后的输出语句");
        }
    }
//    i的值是0
//    return后的输出语句
//    i的值是1

}

ReturnTest

public class ArrayTest {
    public static void main(String[] args) {
        // 定义一个int数组类型的变量，变量名为intArr.
        int[] intArr;
        // 使用静态初始化，初始化数组时只指定数组元素的初始值，不指定数组长度。
        intArr = new int[] { 5, 6, 8, 20 };
        // 定义一个Object数组类型的变量，变量名为objArr.
        Object[] objArr;
        // 使用静态初始化，初始化数组时数组元素的类型是
        // 定义数组时所指定的数组元素类型的子类
        objArr = new String[] { "Java", "李" };
        Object[] objArr2;
        // 使用静态初始化
        objArr2 = new Object[] { "Java", "李" };

        // 数组的定义和初始化同时完成，使用简化的静态初始化写法
        int[] a = { 5, 6, 7, 9 };

        // 数组的定义和初始化同时完成，使用动态初始化语法
        int[] prices = new int[5];
        // 数组的定义和初始化同时完成，初始化数组时元素的类型是定义数组时元素类型的子类
        Object[] books = new String[4];

        // 输出objArr数组的第二个元素，将输出字符串"李"
        System.out.println(objArr[1]);
        // 为objArr2的第一个数组元素赋值
        objArr2[0] = "Spring";

        // 访问数组元素指定的索引等于数组长度，所以下面代码将在运行时出现异常
        // System.out.println(objArr2[2]);

        // 使用循环输出prices数组的每个数组元素的值
        for (int i = 0; i < prices.length; i++) {
            System.out.println(prices[i]);
        }

        // 对动态初始化后的数组元素进行赋值
        books[0] = "Java讲义";
        books[1] = "轻量级Java EE企业应用实战";
        // 使用循环输出books数组的每个数组元素的值
        for (int i = 0; i < books.length; i++) {
            System.out.println(books[i]);
        }
    }

//    李
//    0
//    0
//    0
//    0
//    0
//    Java讲义
//    轻量级Java EE企业应用实战
//    null
//    null

}

ArrayTest

public class ForEachErrorTest {
    public static void main(String[] args) {
        String[] books = { "轻量级Java EE企业应用实战", "疯狂Java讲义", "疯狂Android讲义" };
        // 使用foreach循环来遍历数组元素，其中book将会自动迭代每个数组元素
        for (String book : books) {
            book = "疯狂Ajax讲义";
            System.out.println(book);
        }
        System.out.println(books[0]);
    }
//    疯狂Ajax讲义
//    疯狂Ajax讲义
//    疯狂Ajax讲义
//    轻量级Java EE企业应用实战

}

ForEachErrorTest

public class ForEachTest {
    public static void main(String[] args) {
        String[] books = { "轻量级Java EE企业应用实战", "疯狂Java讲义", "疯狂Android讲义" };
        // 使用foreach循环来遍历数组元素，
        // 其中book将会自动迭代每个数组元素
        for (String book : books) {
            System.out.println(book);
        }
    }
//    轻量级Java EE企业应用实战
//    疯狂Java讲义
//    疯狂Android讲义

}

ForEachTest

public class ArrayInRam {
    public static void main(String[] args) {
        // 定义并初始化数组，使用静态初始化
        int[] a = { 5, 7, 20 };
        // 定义并初始化数组，使用动态初始化
        int[] b = new int[4];
        // 输出b数组的长度
        System.out.println("b数组的长度为：" + b.length);
        // 循环输出a数组的元素
        for (int i = 0, len = a.length; i < len; i++) {
            System.out.println(a[i]);
        }
        // 循环输出b数组的元素
        for (int i = 0, len = b.length; i < len; i++) {
            System.out.println(b[i]);
        }
        // 因为a是int[]类型，b也是int[]类型，所以可以将a的值赋给b。
        // 也就是让b引用指向a引用指向的数组
        b = a;
        // 再次输出b数组的长度
        System.out.println("b数组的长度为：" + b.length);
    }
//    b数组的长度为：4
//    5
//    7
//    20
//    0
//    0
//    0
//    0
//    b数组的长度为：3

}

ArrayInRam

public class ArraysTest {
    public static void main(String[] args) {
        // 定义一个a数组
        int[] a = new int[] { 3, 4, 5, 6 };
        // 定义一个a2数组
        int[] a2 = new int[] { 3, 4, 5, 6 };
        // a数组和a2数组的长度相等，每个元素依次相等，将输出true
        System.out.println("a数组和a2数组是否相等：" + Arrays.equals(a, a2));
        // 通过复制a数组，生成一个新的b数组
        int[] b = Arrays.copyOf(a, 6);
        System.out.println("a数组和b数组是否相等：" + Arrays.equals(a, b));
        // 输出b数组的元素，将输出[3, 4, 5, 6, 0, 0]
        System.out.println("b数组的元素为：" + Arrays.toString(b));
        // 将b数组的第3个元素（包括）到第5个元素（不包括）赋为1
        Arrays.fill(b, 2, 4, 1);
        // 输出b数组的元素，将输出[3, 4, 1, 1, 0, 0]
        System.out.println("b数组的元素为：" + Arrays.toString(b));
        // 对b数组进行排序
        Arrays.sort(b);
        // 输出b数组的元素，将输出[0, 0, 1, 1, 3, 4]
        System.out.println("b数组的元素为：" + Arrays.toString(b));
    }
//    a数组和a2数组是否相等：true
//    a数组和b数组是否相等：false
//    b数组的元素为：[3, 4, 5, 6, 0, 0]
//    b数组的元素为：[3, 4, 1, 1, 0, 0]
//    b数组的元素为：[0, 0, 1, 1, 3, 4]

}

ArraysTest

public class ArraysTest2 {
    public static void main(String[] args) {
        int[] arr1 = new int[] { 3, -4, 25, 16, 30, 18 };
        // 对数组arr1进行并发排序
        Arrays.parallelSort(arr1);
        System.out.println(Arrays.toString(arr1));
        int[] arr2 = new int[] { 3, -4, 25, 16, 30, 18 };
        Arrays.parallelPrefix(arr2, new IntBinaryOperator() {
            // left代表数组中前一个所索引处的元素，计算第一个元素时，left为1
            // right代表数组中当前索引处的元素
            public int applyAsInt(int left, int right) {
                return left * right;
            }
        });
        System.out.println(Arrays.toString(arr2));
        int[] arr3 = new int[5];
        Arrays.parallelSetAll(arr3, new IntUnaryOperator() {
            // operand代表正在计算的元素索引
            public int applyAsInt(int operand) {
                return operand * 5;
            }
        });
        System.out.println(Arrays.toString(arr3));
    }
}

ArraysTest2

public class Gobang {
    // 定义棋盘的大小
    private static int BOARD_SIZE = 15;
    // 定义一个二维数组来充当棋盘
    private String[][] board;

    public void initBoard() {
        // 初始化棋盘数组
        board = new String[BOARD_SIZE][BOARD_SIZE];
        // 把每个元素赋为"╋"，用于在控制台画出棋盘
        for (int i = 0; i < BOARD_SIZE; i++) {
            for (int j = 0; j < BOARD_SIZE; j++) {
                board[i][j] = "╋";
            }
        }
    }

    // 在控制台输出棋盘的方法
    public void printBoard() {
        // 打印每个数组元素
        for (int i = 0; i < BOARD_SIZE; i++) {
            for (int j = 0; j < BOARD_SIZE; j++) {
                // 打印数组元素后不换行
                System.out.print(board[i][j]);
            }
            // 每打印完一行数组元素后输出一个换行符
            System.out.print("\n");
        }
    }

    public static void main(String[] args) throws Exception {
        Gobang gb = new Gobang();
        gb.initBoard();
        gb.printBoard();
        // 这是用于获取键盘输入的方法
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String inputStr = null;
        // br.readLine()：每当在键盘上输入一行内容按回车，用户刚输入的内容将被br读取到。
        while ((inputStr = br.readLine()) != null) {
            // 将用户输入的字符串以逗号（,）作为分隔符，分隔成2个字符串
            String[] posStrArr = inputStr.split(",");

            // 将2个字符串转换成用户下棋的座标
            int xPos = Integer.parseInt(posStrArr[0]);
            int yPos = Integer.parseInt(posStrArr[1]);
            // 把对应的数组元素赋为"●"。
            gb.board[yPos - 1][xPos - 1] = "●";
            /*
             * 电脑随机生成2个整数，作为电脑下棋的座标，赋给board数组。 还涉及 1.座标的有效性，只能是数字，不能超出棋盘范围
             * 2.如果下的棋的点，不能重复下棋。 3.每次下棋后，需要扫描谁赢了
             */
            gb.printBoard();
            System.out.println("请输入您下棋的座标，应以x,y的格式：");
        }
    }
//    ╋╋╋╋╋╋╋╋╋╋╋╋╋╋╋
//    ╋╋╋╋╋╋╋╋╋╋╋╋╋╋╋
//    ╋╋╋╋╋╋╋╋╋╋╋╋╋╋╋
//    ╋╋╋╋╋╋╋╋╋╋╋╋╋╋╋
//    ╋╋╋╋╋╋╋╋╋╋╋╋╋╋╋
//    ╋╋╋╋╋╋╋╋╋╋╋╋╋╋╋
//    ╋╋╋╋╋╋╋╋╋╋╋╋╋╋╋
//    ╋╋╋╋╋╋╋╋╋╋╋╋╋╋╋
//    ╋╋╋╋╋╋╋╋╋╋╋╋╋╋╋
//    ╋╋╋╋╋╋╋╋╋╋╋╋╋╋╋
//    ╋╋╋╋╋╋╋╋╋╋╋╋╋╋╋
//    ╋╋╋╋╋╋╋╋╋╋╋╋╋╋╋
//    ╋╋╋╋╋╋╋╋╋╋╋╋╋╋╋
//    ╋╋╋╋╋╋╋╋╋╋╋╋╋╋╋
//    ╋╋╋╋╋╋╋╋╋╋╋╋╋╋╋

}

Gobang

public class Num2Rmb {
    private String[] hanArr = { "零", "壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌",
            "玖" };
    private String[] unitArr = { "十", "百", "千" };

    /**
     * 把一个浮点数分解成整数部分和小数部分字符串
     *
     * @param num
     *            需要被分解的浮点数
     * @return 分解出来的整数部分和小数部分。第一个数组元素是整数部分，第二个数组元素是小数部分。
     */
    private String[] divide(double num) {
        // 将一个浮点数强制类型转换为long，即得到它的整数部分
        long zheng = (long) num;
        // 浮点数减去整数部分，得到小数部分，小数部分乘以100后再取整得到2位小数
        long xiao = Math.round((num - zheng) * 100);
        // 下面用了2种方法把整数转换为字符串
        return new String[] { zheng + "", String.valueOf(xiao) };
    }

    /**
     * 把一个四位的数字字符串变成汉字字符串
     *
     * @param numStr
     *            需要被转换的四位的数字字符串
     * @return 四位的数字字符串被转换成的汉字字符串。
     */
    private String toHanStr(String numStr) {
        String result = "";
        int numLen = numStr.length();
        // 依次遍历数字字符串的每一位数字
        for (int i = 0; i < numLen; i++) {
            // 把char型数字转换成的int型数字，因为它们的ASCII码值恰好相差48
            // 因此把char型数字减去48得到int型数字，例如‘4‘被转换成4。
            int num = numStr.charAt(i) - 48;
            // 如果不是最后一位数字，而且数字不是零，则需要添加单位（千、百、十）
            if (i != numLen - 1 && num != 0) {
                result += hanArr[num] + unitArr[numLen - 2 - i];
            }
            // 否则不要添加单位
            else {
                result += hanArr[num];
            }
        }
        return result;
    }

    public static void main(String[] args) {
        Num2Rmb nr = new Num2Rmb();
        // 测试把一个浮点数分解成整数部分和小数部分
        System.out.println(Arrays.toString(nr.divide(236711125.123)));
        // 测试把一个四位的数字字符串变成汉字字符串
        System.out.println(nr.toHanStr("609"));
    }
//    [236711125, 12]
//            陆百零玖

}

Num2Rmb

public class Num2Rmb {
    private String[] hanArr = { "零", "壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌",
            "玖" };
    private String[] unitArr = { "十", "百", "千" };

    /**
     * 把一个浮点数分解成整数部分和小数部分字符串
     *
     * @param num
     *            需要被分解的浮点数
     * @return 分解出来的整数部分和小数部分。第一个数组元素是整数部分，第二个数组元素是小数部分。
     */
    private String[] divide(double num) {
        // 将一个浮点数强制类型转换为long，即得到它的整数部分
        long zheng = (long) num;
        // 浮点数减去整数部分，得到小数部分，小数部分乘以100后再取整得到2位小数
        long xiao = Math.round((num - zheng) * 100);
        // 下面用了2种方法把整数转换为字符串
        return new String[] { zheng + "", String.valueOf(xiao) };
    }

    /**
     * 把一个四位的数字字符串变成汉字字符串
     *
     * @param numStr
     *            需要被转换的四位的数字字符串
     * @return 四位的数字字符串被转换成的汉字字符串。
     */
    private String toHanStr(String numStr) {
        String result = "";
        int numLen = numStr.length();
        // 依次遍历数字字符串的每一位数字
        for (int i = 0; i < numLen; i++) {
            // 把char型数字转换成的int型数字，因为它们的ASCII码值恰好相差48
            // 因此把char型数字减去48得到int型数字，例如‘4‘被转换成4。
            int num = numStr.charAt(i) - 48;
            // 如果不是最后一位数字，而且数字不是零，则需要添加单位（千、百、十）
            if (i != numLen - 1 && num != 0) {
                result += hanArr[num] + unitArr[numLen - 2 - i];
            }
            // 否则不要添加单位
            else {
                result += hanArr[num];
            }
        }
        return result;
    }

    public static void main(String[] args) {
        Num2Rmb nr = new Num2Rmb();
        // 测试把一个浮点数分解成整数部分和小数部分
        System.out.println(Arrays.toString(nr.divide(236711125.123)));
        // 测试把一个四位的数字字符串变成汉字字符串
        System.out.println(nr.toHanStr("609"));
    }
//    [236711125, 12]
//            陆百零玖

}

Num2Rmb

public class PrimitiveArrayTest {
    public static void main(String[] args) {
        // 定义一个int[]类型的数组变量
        int[] iArr;
        // 动态初始化数组，数组长度为5
        iArr = new int[5];
        // 采用循环方式为每个数组元素赋值。
        for (int i = 0; i < iArr.length; i++) {
            iArr[i] = i + 10;
        }
    }
}

PrimitiveArrayTest

class Person {
    public int age; // 年龄
    public double height; // 身高

    // 定义一个info方法
    public void info() {
        System.out.println("我的年龄是：" + age + "，我的身高是：" + height);
    }

    // 我的年龄是：16，我的身高是：161.0
    // 我的年龄是：16，我的身高是：161.0

}

public class ReferenceArrayTest {
    public static void main(String[] args) {
        // 定义一个students数组变量，其类型是Person[]
        Person[] students;
        // 执行动态初始化
        students = new Person[2];
        // 创建一个Person实例，并将这个Person实例赋给zhang变量
        Person zhang = new Person();
        // 为zhang所引用的Person对象的age、height赋值
        zhang.age = 15;
        zhang.height = 158;
        // 创建一个Person实例，并将这个Person实例赋给lee变量
        Person lee = new Person();
        // 为lee所引用的Person对象的age、height赋值
        lee.age = 16;
        lee.height = 161;
        // 将zhang变量的值赋给第一个数组元素
        students[0] = zhang;
        // 将lee变量的值赋给第二个数组元素
        students[1] = lee;
        // 下面两行代码的结果完全一样，因为lee
        // 和students[1]指向的是同一个Person实例。
        lee.info();
        students[1].info();
    }
}

Person

public class TwoDimensionTest {
    public static void main(String[] args) {
        // 定义一个二维数组
        int[][] a;
        // 把a当成一维数组进行初始化，初始化a是一个长度为4的数组
        // a数组的数组元素又是引用类型
        a = new int[4][];
        // 把a数组当成一维数组，遍历a数组的每个数组元素
        for (int i = 0, len = a.length; i < len; i++) {
            System.out.println(a[i]);
        }
        // 初始化a数组的第一个元素
        a[0] = new int[2];
        // 访问a数组的第一个元素所指数组的第二个元素
        a[0][1] = 6;
        // a数组的第一个元素是一个一维数组，遍历这个一维数组
        for (int i = 0, len = a[0].length; i < len; i++) {
            System.out.println(a[0][i]);
        }

        // 同时初始化二维数组的2个维数
        int[][] b = new int[3][4];

        // 使用静态初始化的语法来初始化一个二维数组
        String[][] str1 = new String[][] { new String[3],
                new String[] { "hello" } };
        // 使用简化的静态初始化语法来初始化二维数组
        String[][] str2 = { new String[3], new String[] { "hello" } };
        System.out.println(str1[1][0]);
        System.out.println(str2[1][0]);
    }
//    null
//    null
//    null
//    null
//    0
//    6
//    hello
//    hello

}

TwoDimensionTest

时间： 2024-11-07 12:08:59

【03-流程控制与数组】的相关文章

Java图式（第三章流程控制、数组）

Java图式(第三章流程控制.数组) 1.分支语句 1)if-else语句 2)switch语句 2.循环语句 1)while语句 while返回值不是1/0,必须是布尔表达式 2)do-while语句 3)for语句 4)continue/break语句标号是对语句块/循环命名.eg:A:循环 continue A:直接终止标记的外循环 3.数组(引用类型) 1)声明时不确定大小 2)引用:下标引用,无指针 3)实例化(存储单元分配)语句:new 4)数组初始化:不要求每一维一样大 4.字

05 Java 流程控制与数组

作者:thoughtInShare 出处:http://www.cnblogs.com/thoughtInShare 欢迎转载,也请保留这段声明.谢谢! 1,流程控制=顺序结构+分支结构+循环结构 (1)分支结构=if+switch (2)循环结构=while+do while ()+for (3)控制循环结构=break(结束整个循环)+continue (结束本次循环)+return(结束整个方法) (4)return并不是专门用来控制循环结构的,return的功能是结束一个方法;而不管re

Java基础（二）流程控制和数组

流程控制 break结束多重循环 public static void main(String[] args) { outer: for(int i = 0; i < 5; i++) { for(int j = 0; j < 3; j++) { System.out.println("i的值为:" + i + " j的值为:" + j); if(j == 1) { break outer; } } } } //输出: //i的值为:0 j的值为:0 //

03 流程控制

流程控制 if 和 switch 1 <!DOCTYPE html> 2 <html lang="en"> 3 <head> 4 <meta charset="UTF-8"> 5 <meta http-equiv="X-U-Compatible" content="IE-edge"> 6 <meta name="viewport" conte

流程控制和数组

不管是哪种编程语言,都有两种流程控制结构:分支结构和循环结构.分支结构用于实现根据条件来选择性的执行某段代码,循环结构则用于实现根据循环条件重复执行某段代码.Java也提供了这两种流程控制结构,Java提供了if和switch两种分支语句:提供了while.do while和for三种循环语句.还有一种用于遍历的循环,使用foreach循环可以遍历集合.数组的元素. 一.分支结构 1.1if条件语句 if语句使用布尔表达式或布尔值作为分支条件来进行分支控制. 使用if...else语句时,一定

【iOS开发基础】【C语言】03 - 流程控制

一.流程控制结构 (1)顺序结构:按照书写顺序执行每一条语句. (2)选择结构:对给定的条件进行判断,根据判断结果来决定执行哪一段代码. (3)循环结构:在给定条件成立的情况下,反复执行某一段代码. 二.选择结构 - if (一)if简单使用 1) 第一种结构: 如果条件为真,就执行后面的语句,否则不执行. if(条件) { 语句1: 语句2: …… } 2) 第二种结构: 如果条件成立就执行语句1,否则执行语句2. if(条件) { 语句1: } else { 语句2: } 3) 第三种结构:

流程控制与数组、集合

1.流程图流程图中的形状: (椭圆形)开始和结束:表示程序的开始或结束,一个流程图中,只能出现一个开始和一个结束 (矩形)步骤:表示功能中的每一个步骤 (平行四边形)输入和输出:表示输入和输出 (菱形)判断:表示判断,将产生两种判断结果,真或假 (箭头):连接其他图形,表示程序的流向 2.流程控制语句: ①if判断 ②switch选择 ③循环:while循环 do while循环 for循环 foreach循环 3.数组默认值: 数字类型,默认值为0b

第四章.流程控制与数组

流程控制结构: 分支结构根据分支条件来选择性的执行某段代码. if: switch: case语句后面只能是byte.short.char.int四种整型类型,枚举类型和Java.lang.String类型(从Java 7才允许). default语句不省略. break: break语句可以结束switch语句.while.do while.for语句但是结束不了if语句. Java中海油一种break标签,可以结束外层循环: 1 public class BreakTest2{ 2 pub

流程控制、数组与集合

今天来写写这两天学习的一些比较重要的内容.首先让我们进入流程图,流程图顾名思义就是画流程的图,它是使用标准化的图形方案,分析某些复杂功能的实现步骤.标准化的意思就是用特定的图像,它的形状有:椭圆(代表开始或结束,只能有一个开始和结束).长方形(代表功能中的每一个步骤).四边形(代表输入和输出).菱形(代表判断,将产生两种结果,真和假).箭头符号(连接其他图形,表示程序的流向).使用它的工具有很多,最好还是手绘就行了,方便又快捷. 接着学习了if判断语句,它的格式:

疯狂JAVA——第四章流程控制与数组

4.5 数组类型数组也是一种类型.它本身是引用类型.例如int是一种基本类型,int[]就是引用类型. 两种定义数组的方式: 1.type[] arrayName; 2.type arrayName[]; 通常推荐第一种写法,这种方法既容易理解,也符合定义变量的语法. 如果访问数组元素时指定的索引值小于0,或者大于等于数组的长度,编译程序不会出现任何错误,但运行时会抛出异常 4.5.5foreach循环 String[] books={"三国演义","西游记",&