java基础(二)：流程控制与数组

四、流程控制与数组

4.1、顺序结构：程序从上到下，一行一行执行。

4.2、分支结构：

　　4.2.1、if条件语句：

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

　　注意1：使用 if else 语句基本规则：总是优先把包含范围小的条件放在前面处理。

1）、if(){...}，
2）、if(){...}else{...}，
3）、if(age>60){
　　　　　　System.out.println("老年人");
　　　　}else if(age>40){
　　　　　　System.out.println("中年人");
　　　　}else if(age>20){
　　　　　　System.out.println("青年人");
　　　　} 
等同于：
　　　　if(age>60){
　　　　　　System.out.println("老年人");
　　　　}else if(age>40 && !(age>60)){ //else的含义是"否则"，隐含条件是：对前面的条件取反
　　　　　　System.out.println("中年人"); 
　　　　}else if(age>20 &&!(age>60) && !(age>40 && !(age>60)){ //else的含义是"否则"，隐含条件是：对前面的条件取反
　　　　　　System.out.println("青年人"); 
　　　　} 

 

　　4.2.2、switch分支语句：

　　switch语句由一个控制表达式和多个case标签组成。

　　注意1：控制表达式的数据类型只能是：byte、short、char、int 四种整数类型，枚举类型 和 String类型（从Java 7才允许)。

　　注意2：case后面的break不要省略，否则会继续执行后面的代码(不会再去判断后面的case、default条件)。

public class TestSwitch{
    public static void main(){
        char score = 'C';
        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 'E':
                System.out.println("不及格");
                break;
            default:
                System.out.println("输入有误");
        }
    }  
}        

 

 4.3、循环结构

　　4.3.1、while、do  while 循环

　　注意1：while循环，先判断循环条件，为真则执行循环体；

　　注意2： do while循环，先执行循环体，然后判断循环条件，为真则执行下一次循环，否则中止循环（至少执行一次）；

　　注意3：循环条件一定要保证有变成false的时候，否则死循环。

public class TestWhile{
    public static viod main(String[] args){

        //1、while循环，先判断循环条件，为真则执行
        int count = 0; //初始化语句
        while(count<10){ //循环条件，一定要保证有变成false的时候，否则死循环
            //循环体
            System.out.println(count); 
            count++; //迭代语句
        }
        System.out.println("while循环结束!"); 

        //2、do while循环，先执行循环体，然后判断循环条件，为真则执行下一次循环，否则中止循环
        int sum= 1; //初始化语句
        do{
            //循环体
            System.out.println(sum); 
            sum++; //迭代语句
        }
        while(sum<10);//循环条件，一定要保证有变成false的时候，否则死循环
        System.out.println("do while循环结束!"); 
    }
}        

 

　　4.3.2、for、增强for、foreach循环

　　效率：foreach(方式5) > 增强for循环(方式4) > 普通for循环

public class TestFor{

    //方式1：最普通for循环
    public static void test1(List<String> list) {
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
    }

    //方式2：稍微高级一点
    public static void test2(List<String> list) {
        for (int i = 0,lenth=list.size(); i < lenth; i++) {
            System.out.println(list.get(i));      
        }
    }

    //方式3：Iterator遍历
    public static void test3(List<String> list) {
        Iterator<String> iterator = list.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }

    //方式4：增强for循环,效率很棒
    public static void test4(List<String> list){
        for(String str:list){
            System.out.println(str);
        }
    }

    //方式5：java8以后新增forEach循环,效率最好但不方便计数(lambda表达式)
    public static void test5(List<String> list){
        //list.forEach(System.out::println);和下面的写法等价
        list.forEach(str->{
            System.out.println(str);
        });
    }

    //方式6
    public static void test6(List<String> list) {
        list.iterator().forEachRemaining(str->{
            System.out.println(str);
        });
    }

}            

 

 4.4、控制循环结构

　　4.4.1、使用 break 结束循环

　　break 用于完全结束一个循环，跳出循环体；

　　break 还能结束其所在的外层循环（这时需要在break后面紧跟一个标签，该标签必须放在循环语句前面，用于标识一个外层循环）；

public class TestBreak{
　　public static void main(String[] args){
        //1、一个简单的for循环，break结束一个循环
        for(int m=0; m<5; m++){
            System.out.println("m的值是："+ m);
            if(m==1){
                break; //执行该语句时将结束for循环
            }
        }
        /* 
　　　　 运行结果：
        m的值是：0
        m的值是：1
        */
        
        //2、break配合标签使用，可以结束一个其外层的循环
        //外层循环，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){
                    break outer; //跳出outer标识的循环
                }
            }
        }
        /* 
　　　　　与continue的区别：i>0后面的值不会执行
　　　　  运行结果：
        i的值是：0， j的值是：0
        i的值是：0， j的值是：1
        */
    }  
}

 

　　4.4.2、使用 continue 结束本次循环

　　continue 用于中止本次循环（略过本次循环剩下的语句），开始下一次循环；

　　continue 也能中止其所在的外层循环（这时需要在continue后面紧跟一个标签，该标签必须放在循环语句前面，用于标识一个外层循环）；

public class TestContinue{
    public static void main(String[] args) {
        //外层循环，outer作为一个标识符，后面是冒号(:)
        outer:
        for(int i=0; i<3; i++) {
            //内层循环
            for(int j=0; j<2; j++) {
                System.out.println("i的值为：" + i + "， j的值为：" + j);
                if(j==1) {
                    //跳出outer标签所指定的循环
                    continue outer;
                }
            }
        }
        /* 
　　　　　与break的区别：i>0后面的值也执行了
　　　　　运行结果如下：
        i的值为：0， j的值为：0
        i的值为：0， j的值为：1
        i的值为：1， j的值为：0
        i的值为：1， j的值为：1
        i的值为：2， j的值为：0
        i的值为：2， j的值为：1  
        */
    }
}

　　4.4.3、使用 return 结束方法

 

 4.5、数组

　　数组也是一种数据类型（引用类型）；

　　必须先定义、初始化数组(分配内存空间和赋初始值)，然后才能使用数组。

　　静态初始化：

　　　　int[] intArr = new int[]{ 2, 4, 6, 8, 10 }    //初始化时，只指定数组元素的初始值，不指定数组长度

　　　　Object objArr = new String[]{ "Java", "Python" }    //初始化时，元素类型可以是定义时的子类

　　动态初始化：只指定数组的长度，系统为每个数组元素赋初始值。

　　　　int[] intArr = new int[5];

　　　　Object objArr = new String[4];

　　JDK1.5提供了foreach循环(此处应该是增强的for循环)，遍历数组和集合时：无需获得数组长度，无需根据索引访问数组元素，无需循环条件，无须循环迭代语句。

public class TestForEach{
    public static void main(String[] args){
        String[] books = {"语文", "数学", "英语" };
        //使用foreach循环来遍历数组元素：无需获得数组长度，无需根据索引访问数组元素，无需循环条件，无须循环迭代语句
        for(String book : books){
            System.out.println(book);
        }
    }
}    

  

4.6、深入数组

　　4.6.1、内存中的数组

　　数组 是一种引用数据类型，数组引用变量 存储在 栈(stack)内存 中，实际的数组元素存储在 堆(heap)内存 中。

　　数组 只能通过 引用变量 访问 堆内存中的数组元素；

　　栈内存：存放数组变量

　　堆内存：存放对象，以便反复利用。

 

　　4.6.2、基本类型数组的初始化

 

　　4.6.3、引用类型数组的初始化

 

　　4.6.4、操作数组的工具类