码迷,mamicode.com
首页 > 编程语言 > 详细

流程控制与数组

时间:2016-07-08 06:48:48      阅读:262      评论:0      收藏:0      [点我收藏+]

标签:

顺序结构

如果main方法的多行代码没有任何流程控制,则程序总是从上向下依次执行。

Java提供两种常见的分支控制结构:if语句和switch语句,其中if语句使用布尔表达式或布尔值作为分支条件来进行分支控制;switch语句则用于对多个整型值进行匹配。

    //if语句三种形式
    if(){
     //第一种
        }
        
    if(){
        //第二种
        }
    else{
        
        }
    if(){
        //第三种
        }
    else if(){
        //最后的else可以省略
        }
    else(){
        
        }

if之后的括号内只能是一个逻辑表达式,即这个表达式的值只能是true或者false

注:条件语句范围应该从低到高,总是优先把包含范围小的条件放在前面处理。

switch语句由一个控制表达式和多个case标签组成。switch语句后面的控制表达式的数据类型只能是byte、short、char、int四种整数类型,枚举类型和java.lang.String类型(Java 7增强的,不能是StringBuffer或StringBuilder),不能是布尔类型。

public class SwitchTest{
    public static void main(String[] args){
        char a = ‘A‘;
        switch(a){
            //case后面跟的是冒号
        case ‘A‘:
            System.out.println("优秀");
            //如果没有break语句每行代码都会被执行,必须带break
            break;
            case ‘B‘:
            //case后面跟的是冒号
            System.out.println("良好");
            break;
            case ‘C‘:
            //case后面跟的是冒号
            System.out.println("及格");
            break;
            case ‘D‘:
            //重要的事说三遍
            System.out.println("呵呵");
            break;
                }
        }
    }
public class SwitchTest{
    public static void main(String[] args){
        String a = "春天";
        switch(a){
        case "春天":
            System.out.println("春天来了");
            break;
            case "夏天":
            System.out.println("树叶黄了");
            break;
            case "秋天":
            System.out.println("小草绿了");
            break;
            case "冬天":
            System.out.println("呵呵");
            break;
                }
        }
    }

循环结构

循环语句可以在满足一定条件下反复执行某一段代码,这段被重复执行的代码称为循环体。当反复执行这个循环体时,需要在合适的时候把循环条件改为假,从而结束循环。不然,循环体一直执行下去,就成了死循环。

循环语句包含以下四个部分:

1、初始化语句,一条或多条语句,这些语句用于完成一些初始化工作,初始化语句在循环开始之前执行;

2、循环条件;

3、循环体;

4、迭代语句:这个部分在一次循环体执行结束后,对循环条件求值之前执行,通常用于控制循环条件的变量,使得循环在合适的时候结束。

public class WhileTest{
    public static void main(String[] args){
        //初始化语句
        int count = 0;
        //循环语句
        while(count < 10){  //while后面括号内循环条件
            System.out.println(count);
            //迭代语句
            count++;
            }
        }
    }

一定要保证循环条件有false的时候,不然就成了死循环。注:while循环的循环条件后面不能紧跟一个分号,紧跟分号表明循环体是一个分号,后面的语句和循环没有任何关系。

在Java中一个单独的分号表示一个空语句。

do…while循环与while循环的区别是:while循环先执行循环条件,条件为真执行循环体;do…while先执行循环体,然后判断循环条件。

do…while循环语句,循环体至少会被执行一次。

 

do…while语句循环条件后面必须有一个分号,代表循环结束。

 

public class DoWhileTest{
    public static void main(String[] args){
        int count = 0;
        do{
            System.out.println(count);
            count++;
            //do…while语句循环条件后面必须有一个分号,代表循环结束
            }while(count < 10);
        }
    }

for循环是更简洁的循环语句:

for(初始化语句; 循环条件; 迭代){ 循环体 }:for循环线执行初始化语句,初始化语句只在循环开始前执行一次,每次执行循环体之前,先计算循环条件的值,返回true,执行循环体,循环体执行结束以后迭代语句。

for循环迭代语句没有和循环体放在一起,因此即使执行循环遇到continue语句结束本次循环,循环迭代语句也一样得到执行。

public class ForTest{
    public static void main(String[] args){
        //即使i等于5时忽略此次循环,但是迭代语句依然会得到执行
        for(int i = 0; i < 10; i++){
            if(i == 5){
                System.out.println("跳出此次循环!");
                continue;
                }
            System.out.println(i);    
            }
        }
    }

for循环的初始化语句只有一个,循环条件也只是一个简单的布尔表达式,实际上for循环允许同时制定多个初始化语句,循环条件也可以是一个包含逻辑运算符的表达式.

初始化变量可以有多个,但是声明只有一个,所以初始化表达式中声明多个变量,但要具有相同的数据类型。

public class ForTest{
    public static void main(String[] args){
        for(int i = 0, j = 0; i < 10 && j < 5; i++, j++){
            System.out.println("i = " + i + " j = " + j);    
            }
        }
    }

其中i与j的数据类型不同,编译会出错。for括号内初始化语句、循环体、迭代语句都可以省略,但是分号“;”要保留。如果没有循环条件,默认返回true,陷入死循环。

for( ; ; ){
    
}

建议不要在循环体内修改循环变量,如果需要访问、修改循环变量,建议重新定义一个临时变量,赋值给他,在对临时变量进行修改。

public class ForTest{
    public static void main(String[] args){
        for(byte i = 0; i < 10; i++){
            System.out.println(i);    
            //再次修改循环变量,会陷入死循环
            i = i * 0.1;
            }
        }
    }

for循环可以把循环初始化语句放在循环体外,这样可以扩大初始化语句中所定义变量的作用域。

public class ForTest{
    public static void main(String[] args){
        //循环初始化语句放到循环体外
        byte i = 0 ;
        for( ; i < 10; i++){
            System.out.println(i);    
            }
        }
    }

循环迭代语句放在循环体之后

public class ForTest{
    public static void main(String[] args){
        //迭代语句放在循环体之后
        for( byte i = 0; i < 10; ){
            System.out.println(i);    
            i++;
            }
        }
    }

控制循环结构

Java提供了continue和break来控制循环结构,还有return来结束整个方法,当然也可以结束一次循环。

public class BreakTest{
    public static void main(String[] args){
        for(int i = 0; i < 10; i++){
            System.out.println("i = " + i);
            if(i == 5){
                //使用break结束循环
                break;
                }
            }
        }
    }

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

Java中标签就是一个紧跟英文的冒号( : ),Java中标签只有放在循环语句之前才有作用。

public class BreakOuterTest{
    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;
                    }
                }
            }
        }
    }

break后的标签必须是一个有效标签,这个标签必须在break语句所在的循环之前定义。break默认是结束所在的循环。

使用continue忽略循环

public class ContinueTest{
    public static void main(String[] args){
        for(int i = 0; i < 10; i++){
                if(i == 5){
                    System.out.println("i等于5时跳出此次循环");
                  continue;
                }
            System.out.println("i = " + i);
            }
        }
    }

continue后也可以紧跟一个标签,用于直接跳过标签所标识循环的当次循环剩下的语句,重新下一次循环。

public class ContinueOuterTest{
    public static void main(String[] args){
        outer:
        for(int i = 0; i < 5; i++){
            for(int j = 0; j < 3; j++){
                if(j == 1){
                    continue outer;
                    }
                System.out.println("i = " + i + " j = " + j);
                }
            }
        }
    }

运行上面的程序可以看到,循环变量j无法超过1,当j等于1的时候,continue outer语句就结束外层循环的当次循环,直接开始下一循环,内层循环没有机会执行完成。

return不是专门用来执行循环的,return是用来结束一个方法的。

public class ReturnTest{
    public static void main(String[] args){
        for(int i = 0; i < 10; i++){
            System.out.println(" i = " + i);
            if(i == 5){
                System.out.println("当i等于5时,方法结束");
                return;
                }
            }
        }
    }

数组类型

Java数组要求所有数组元素具有相同的数据类型,数组的数据类型具有唯一性。

Java语言中数组必须先初始化,然后才可以使用。即为数组分配内存空间,并为每个数组元素赋初始值。

数组初始化有两种方法:

静态初始化:初始化时由程序员显示指定每个数组元素的初始值,由系统决定数组长度。

动态初始化:初始化由程序员指定数组长度,由系统为数组赋初始值。

int[] i;
i = new int[]{5, 6, 7, 8};
//定义数组

 

可以简化语法

int[] i = {5, 6, 7, 8};

动态初始化

int[] i = new int[5];
//数组的定义和初始化同时完成,初始化数组时元素的类型是定义数组时元素类型的子类
Object[] books = new String[4];

动态初始化指定初始值时,系统按如下规则分配初始值:整数类型,值为0;浮点数类型,值0.0;字符类型,值:‘\u0000‘;布尔类型,值:false;引用类型(类、接口和数组),值是null。

不要同时使用静态初始化和动态初始化,即在进行初始化时,不要即指定数组长度,又为每个数组元素分配初始值。

 访问数组时,指定的索引值小于0,或者大于等于数组长度,编译程序不会出错,但是运行时会出现异常:java.lang.ArrayIndexOutOfBoundsException:N(数组索引越界异常),N是程序员试图访问的数组索引。

所有数组都提供一个length属性,通过这个属性访问数组长度

public class ArrayTest{
    public static void main(String[] args){
        String[] str = {"zed", "劫", "影流之主"};
        for(int i = 0; i < str.length; i++){
            System.out.println(str[i]);
            }
        }
    }

foreach循环,遍历数组和集合。使用foreach循环遍历数组和集合时,无须获得数组和集合的长度,无须根据索引来访问数组元素和集合元素,foreach循环自动遍历数组和集合的每个元素。

    for(type variableName : array | Collection){
        //variableName自动迭代访问每个元素
        }

每个元素迭代一遍以后,循环会自动结束。

当使用foreach循环输出数组元素或者集合元素时,通常不要对循环变量进行赋值,这种情况在语法上是允许的,但是没有任何意义。

public class ForeachTest{
    public static void main(String[] args){
        int[] i = {5, 6, 7, 8, 9};
        for(int j : i){
            //改变了循环变量的值,极其容易引起错误
            j = 2;
            System.out.println(j);
            }
        }
    }

上面程序因为修改了循环变量的值,导致程序不能正确迭代。如果希望改变数组元素的信息,不能使用foreach循环。

使用foreach循环,不能改变数组元素的值。因此,在foreach循环中,不要对循环变量进行赋值。

深入数组

数组是一种引用数据类型,数组引用变量只是一个引用,数组元素和数组变量在内存里是分开存放的。

数组引用变量只是一个引用,这个引用变量可以指向任何有效的内存,只有当该引用指向有效内存后,才可通过该数组变量来访问数组元素。

 注:static修饰的方式都是可以通过类名调用的

 

 

 

 

 

流程控制与数组

标签:

原文地址:http://www.cnblogs.com/changzuidaerguai/p/5652098.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!