Java初学笔记5

一、循环结构（下）：
1.for结构的特殊形式（续）：

   int num=1
   for(;num<=9;num++){
       sout.out.println(num+"*9="+num*9);
   }

   for(int num=1;num<=9;){
       System.out.println(num+"*9="+num*9);
       num++
   }

   for(;;){//没有条件的循环就是个死循环
       System.out.println("白熊");
   }

   for(int i=0,j=5;i<=5;i+=2,j-=2){
       System.out.println(i+","+j);
   }

2.break（续）和continue（续）
break作用：跳出循环

//break的用法
   for(int num=1;num<=9;num++){
       if(num==4){//在某种特定条件下，提前结束循环
           break;//跳出循环
       }
       System.out.println(num+"*9="+num*9);
   }
         

    /*
    执行过程：
    num=1  1*9=9
    num=2  2*9=18
    num=3  3*9=27
    num=4
    */

continue作用：跳过循环体中剩余语句而进行下一次循环

//输出9的乘法表，跳过能被3整除的

//continue的用法及可以改变条件从而不使用continue
       for(int num=1;num<=9;num++){
            if(num%3==0){
                continue;//跳过循环中剩余语句而进入到下一循环
            }
            System.out.println(num+"*9="+num*9);
        }

        for(int num=1;num<=9;num++){
            if(num%3!=0){
                System.out.println(num+"*9="+num*9);
            }
        }
       

/*执行过程
    num=1  1*9=9
    num=2  2*9=18
    num=3
    num=4  4*9=36
    num=5  5*9=45
    num=6
    num=7  7*9=63
    num=8  8*9=72
    num=9
    num=10
*/

二、嵌套循环（续）
1.循环中套循环，常常多行多列时使用，外层控制行，内层控制列
2.执行规则：外层循环走一次，内层循环走所有次
3.建议：嵌套层数越少越好，能用一层就不用两层，能用两层就不用三层
4.break默认只跳出一层循环

三、数组：数的组合（上）
一组数据类型相同、逻辑相关的数，建议放在一个数组中
1.是一种引用数据类型
2.相同数据类型元素的集合

定义：

//声明整型数组a，包含5个元素，每个元素都是int类型，默认值为0
     int[] a = new int[5];
//声明浮点型数组d，包含10个元素，每个元素都是double类型，默认值为0.0
     double[] d = new double[10];
//声明布尔型数组b，包含26个元素，每个元素都是boolean类型，默认值为false
     boolean[] b = new boolean[26]; 

初始化：初始化数组中的元素

    int[] arr1 = new int[3]; //0,0,0
    int[] arr2 = {2,5,8}; //2,5,8
    int[] arr3 = new int[]{2,5,8}; //2,5,8
    int[] arr4;
//arr4 = {2,5,8}; //编译错误，此方式只能声明同时初始化
    arr4 = new int[]{2,5,8}; //正确

访问：

int[] arr = new int[3];
System.out.println("数组的长度:"+arr.length); //3

通过下标/索引来访问元素，下标从0开始，最大到(数组的长度-1)

    int[] arr = new int[3];
    System.out.println("数组的长度:"+arr.length); //3
    System.out.println(arr[0]); //0，输出第1个元素的值
    arr[0] = 100; //给第1个元素赋值为100
    arr[1] = 200; //给第2个元素赋值为200
    arr[2] = 300; //给第3个元素赋值为300
    //arr[3] = 400; //运行时会发生数组下标越界异常
    System.out.println(arr[arr.length-1]); //300，输出最后一个元素的值

遍历/迭代：从头到尾挨个走一遍

     int[] arr = new int[10];
     for(int i=0;i<arr.length;i++){ //遍历arr数组
         arr[i] = (int)(Math.random()*100); //给每个元素赋值为0到99的随机数
         System.out.println(arr[i]); //输出每个元素的值
     }

四、补充
1.\t:水平制表

2.byte short int long默认值为-------- 0
float double默认值为--------------------0.0
boolean默认值为-------------------------false

3.ArrayIndexOutOfBoundsException：数组下标越界异常
数组下标一定在0到(数组长度-1)之间，若超出范围，在运行时会发生数组下标越界异常

常见的排序算法：
冒泡排序 选择排序 插入排序 希尔排序 快速排序等等

Arrays:数组的工具类
sort：升序
Arrays.sort(arr);//按升序排列

Random：随机生成
import java.until.Random;
Random rand = new Random();
int num = rand.nextInt(bound:100);//随机生成0-99的随机整数

package day05;
import java.util.Arrays;
import java.util.Random;
/**
 * 数组的演示
 */
public class ArrayDemo {
    public static void main(String[] args) {
       //5)数组的排序：
        Random rand = new Random();
        int[] arr = new int[10];
        for(int i=0;i<arr.length;i++){
            arr[i] = rand.nextInt(100);//随机生成0-99的整数
            //arr[i] = rand.nextInt(41)+10;//随机生成10-50的整数
            //arr[i] = rand.nextInt(61)+40;//随机生成40-100的整数
            //61:最大值-最小值+1
            //40:最小值
            System.out.println(arr[i]);
        }

        Arrays.sort(arr);//对arr数组做升序排列

        System.out.println("排序后");
        for(int i=0;i<arr.length;i++){
            System.out.println(arr[i]);
        }

        System.out.println("倒着输出");
        for(int i=arr.length-1;i>=0;i--){
            System.out.println(arr[i]);
        }
    }

}