大数据<javaSE + Linux精英实训班>_day_04

1：基础语法->for循环
        
        最常见的循环语句. 用在循环次数已知的情况下。
        for(初始化表达式;循环条件;操作表达式){
            执行语句;
            .....
        }

/*
    for循环的编写格式：
    for(初始化表达式;循环条件;操作表达式){
            执行语句;
            .....
        }
    初始化表达式：定义变量，作用，控制循环的次数
    条件：当条件为true的时候，执行循环体，当条件为false时，结束循环
    增量：变量自增的情况
*/
public class ForDemo{
    public static void main(String[] args){
        for(int i = 0;i < 11; ++i){
            System.out.println(i);
        }
    }
}

/*
    利用for循环，计算1+4的结果
    1 + 2 + 3 + 4 = 10
    1+2的和+3
    1+2+3的和+4
*/public class ForDemo_2{
    public static void main(String[] args){
        // 定义变量，记录求和之后的结果
        int sum = 0;
        for(int i = 0; i <= 4; ++i){
            sum = sum + i;
        }
        System.out.println(sum);
    }
}

2：基础语法->循环语句do...while
        
        do...while循环语句和while循环语句类似，语法结构
        
        do{
            执行语句;
            ...
        }while(循环条件);

 

public class DoWhileDemo{
    public static void main(String[] args){
        int i = 0;
        
        do{
            System.out.println(i);
            i++;
        }while(i < 8);
    }
}

3：基础语法->无限循环
    
    格式：
        while(true){
            
        }或者
        for(;;){
            
        }
        

public class WhileDemo{
    public static void main(String[] args){
        // while形式的死循环
        /*while(true){
            System.out.println("hunter老师!");
        }
        */
        for(;;){
            
        }
    }
}

4：基础语法->嵌套for循环
    
    指一个循环语句种的循环体中再定义一个循环语句的语法.while,do...while,for
    
    外循环一次，内循环要循环完。

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

5：基础语法->跳转语句 ----break语句
    
    跳转语句用于实现循环执行过程中程序流程的跳转。属于关键字，停止的意思
    
                ->continnue关键字  继续
                
                作用：终止本次循环，开始下次循环。

public class BreakDemo{
    public static void main(String[] args){
        int i = 1;
        
        while(true){
            if(i == 3){
                break;
            }else{
                System.out.println(i);
            }
            i++;
            
        }
    }
}

public class ContinueDemo{
    public static void main(String[] args){
        for(int i = 0; i < 10; i++){
            if(i % 2 == 0){
                continue;
            }
            System.out.println(i);
        }
    }
}

 

6：基础语法->流程控制语句switch(选择)
    
    它只能针对某个表达式的值做出判断，从而决定程序执行哪段代码.
    
    case->穿透性

public class SwitchDemo{
    public static void main(String[] args){
        // 定义变量  保持星期几的整数
        int week = 5;
        
        switch(week){
            case 1:
                System.out.println("星期一");
            break;
            case 2:
                System.out.println("星期二");
            break;
            case 3:
                System.out.println("星期三");
            break;
            case 4:
                System.out.println("星期四");
            break;
            case 5:
                System.out.println("星期五");
            break;
            case 6:
                System.out.println("星期六");
            break;
            case 7:
                System.out.println("星期日");
            break;
            
            default:
                System.out.println("不存在");
            break;
        }
    }
}

 

7：基础语法->数组

    java中，数组指一组数据的集合，数组中的每一个数据称为元素，在数组中可以存放任意元素，
    在同一个数组里，存放的元素类型必须一致，数组相当于容器。
    
    数组的length属性：使用->数组名.length
    数组的最小索引是0，最大的索引length-1
    
    数组的元素赋值：
                    
    
    数组的定义：
        1->数据类型[]  变量名 = new    数据类型[]{元素1,元素2,元素3};
        
        2->数据类型[]      变量名 =  {元素1,元素2,元素3};
        
    数组的遍历：
    
    数组的异常：数组的索引越界异常
                     空指针异常
                     
    数组获取最值的原理思想：

public class ArrayDemo{
    public static void main(String[] args){
        // 定义一个数组
        // 格式：数据类型 []  变量名 = new        数据类型[存储元素的个数];
        
        int [] arr = new int[4];
        System.out.println(arr);
        
        // 通过索引的方式
        System.out.println(arr[3]);
        
        System.out.println(arr.length);
        
        // 数组的元素赋值
        arr[1] = 25;
        System.out.println(arr[1]);
    }
}

public class ArrayDemo_2{
    public static void main(String[] args){
        // 定义数组
        int[]    arr = new int[]{1,2,3,4,5};
        System.out.println(arr.length);  // 查看数组大小
        System.out.println(arr[2]);
        
        
        System.out.println("________________________________");
        int [] arr2 = {1,3,5,7,9};
        System.out.println(arr2.length);
        System.out.println(arr2[3]);
    }
}

public class ArrayDemo_3{
    public static void main(String[] args){
        int[] arr = {1,2,3,6,5};
        
        for(int i = 0;i < arr.length;++i){
            System.out.println(arr[i]);
        }
    }
}

public class ArrayDemo_4{
    public static void main(String[] args){
        int[] arr = {1,3,4,5,7};
        // 访问的第六个元素
        System.out.println(arr[3]);
        
        int[] arr2 = {1,2,8};
        System.out.println(arr2[2]);
        
        arr2 = null;
        System.out.println(arr2[2]);
    }
}

public class ArrayDemo_5{
    public static void main(String[] args){
        int[] arr = {1,2,3,5,6,7};
        int max = arr[0];
        
        for(int i = 0;i < arr.length; i++){
            // 如果max小于某个元素    取此元素的值
            if(max < arr[i]){
                max = arr[i];
            }
        }
        // 遍历完成，打印输出
        System.out.println(max);
    }
}

8：基础语法->二维数组
    
    int[][] arr = new int[3][5];

public class ArrayArray{
    public static void main(String[] args){
        // 定义一个二维数组
        int[][]    arr = new int[3][4];
        System.out.println(arr);
        System.out.println(arr[2][3]);
        
    }
}

public class ArrayArray_2{
    public static void main(String[] args){
        // 定义二维数组
        int [][] arr = {
            {1,2,3},
            {4,5,6},
            {7,8,9},
            {0}
        };
        // 测试
        System.out.println(arr[2][1]);
    }
}

public class ArrayArray_3{
    public static void main(String[] args){
        //    定义
        int [][]    arr = {{1,2,3},{4,5},{6,7,8,9},{0}};
        
        // 外循环
        for(int i = 0;i < arr.length;i++){
            // 内循环，遍历每一个一维数组
            for(int j = 0; j < arr[i].length;j++){
                System.out.print(arr[i][j]);
            }
            System.out.println();
        }
    }
}

 

转载于:https://www.cnblogs.com/guijin/p/8573158.html