day05

回顾:
1.分支结构:
  3)if...else if:多
  4)switch...case:多
    优点:效率高、结构清晰
    缺点:整数(JDK1.7后支持String)、相等
    break:跳出switch
2.循环:反复执行一段相同或相似的代码
3.三要素:
  1)循环变量的初始化
  2)循环的条件(以循环变量为基础)
  3)循环变量的改变(向着循环的结束变)
  循环变量:在循环过程中所反复改变的那个数
4.循环结构:
  1)while:先判断后执行，有可能一次都不执行
  2)do...whille:先执行后判断，至少执行一次
                要素1与要素3相同时，首选do...while










笔记:
1.循环结构:
  3)for:固定次数循环
2.break:跳出循环
  continue:跳过循环体中剩余语句而进入下一次循环
3.三种循环结构的更佳适用情况:
  1)while:"当..."循环
          要素1与要素3不同时首选while
  2)do...while:"直到..."循环
               要素1与要素3相同时首选do...while
  3)for:固定次数循环，应用率最高
4.嵌套循环:
  1)循环中套循环，一般多行多列时使用，常常外层控制行，内层控制列
  2)执行规则:外层循环走一次，内层循环走所有次
  3)建议:嵌套层数越少越好，能用一层就不用两层，能用两层就不用三层
    若业务必须通过三层以上的循环才能解决，说明设计有问题
  4)break只能跳出一层循环
5.程序=算法+数据结构
  1)算法:解决问题的流程/步骤(顺序、分支、循环)
  2)数据结构:将数据按照某种特定的结构来保存
             数怎么存
    设计良好的/合理的数据结构会导致好的算法
6.数组:
  1)是一种数据类型(引用类型)
  2)相同数据类型元素的集合
  3)数组的定义:
      int[] arr = new int[10];
  4)数组的初始化:
      int[] arr = new int[3]; //0,0,0
      int[] arr = {2,5,8}; //2,5,8
      int[] arr = new int[]{2,5,8}; //2,5,8
      int[] arr;
      arr = {2,5,8}; //编译错误
      arr = new int[]{2,5,8}; //正确
  5)数组的访问:
    5.1)通过(数组名.length)可以获取数组的长度(元素的个数)
          int[] arr = new int[4];
  System.out.println(arr.length); //4
    5.2)通过下标/索引来访问数组中的元素
        下标从0开始，最大到(数组的长度-1)
  int[] arr = new int[3];
  arr[0] = 100; //给arr中第1个元素赋值为100
  arr[1] = 200; //给arr中第2个元素赋值为200
  arr[2] = 300; //给arr中第3个元素赋值为300
  arr[3] = 400; //数组下标越界异常
  System.out.println(arr[arr.length-1]); //输出最后一个元素的值
  6)数组的遍历:
      int[] arr = new int[10];
      for(int i=0;i<arr.length;i++){
        arr[i] = (int)(Math.random()*100);
      }
      for(int i=0;i<arr.length;i++){
        System.out.println(arr[i]);
      }
      for(int i=arr.length-1;i>=0;i--){
        System.out.println(arr[i]);
      }




练习:
1.完成经典案例:------------每人至少两次
  1)随机加法运算器
  2)九九乘法表
  3)求数组元素的最大值
2.完成课后作业




当日事当日毕






















int[] arr = {45,67,78,4};


找最大值算法:
1)假设第1个元素为最大值
    int max = arr[0];
2)遍历剩余元素，将剩余元素与max做对比，
  若剩余元素大于max，则修改max的值为较大的
    for(int i=1;i<arr.length;i++){
      if(arr[i]>max){
        max = arr[i];
      }
    }
max=45/67/78






















0
'0'--------48


























int[] arr = new int[10];
for(int i=0;i<arr.length;i++){
  arr[i] = 100;
}


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






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


System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
System.out.println(arr[3]);
System.out.println(arr[4]);
System.out.println(arr[5]);
System.out.println(arr[6]);
System.out.println(arr[7]);
System.out.println(arr[8]);
System.out.println(arr[9]);












arr[0] = 100;
arr[1] = 100;
arr[2] = 100;
arr[3] = 100;
arr[4] = 100;
arr[5] = 100;
arr[6] = 100;
arr[7] = 100;
arr[8] = 100;
arr[9] = 100;












































int[] arr = new int[3]; //0,0,0
//给arr中的第2个数赋值为100
arr[1] = 100;


















arr[0]----------代表arr中的第1个元素
arr[1]----------代表arr中的第2个元素
arr[2]----------代表arr中的第3个元素
























int a=0;
int b=0;
int c=0;
b=100;


























//声明整型数组a，包含4个元素
//每个元素都是int类型，默认值为0
int[] a = new int[4];






//声明浮点型数组d，包含10个元素
//每个元素都是double型，默认值为0.0
double[] d = new double[10];






//声明布尔型数组b，包含26个元素
//每个元素为boolean型，默认值为false
boolean[] b = new boolean[26];




























int   a; //声明整型变量a
int[] a; //声明整型数组变量a


double[] d;
char[] c;
boolean[] b;






































出版社分类存储---------java编程思想(算法不简单)
图片类别分类存储-------java编程思想(算法简单)




















在某种条件下跳出多层循环，只是你自己想当然的想法


























6000000
for(int i=1;i<=100;i++){
  for(int j=1;j<=200;j++){
    for(int k=1;k<=300;k++){
      if(???){
        break; //跳出k层
      }
      System.out.println("aaa");
    }
  }
}


i=1
  j=1
    k走30次
  j=2
    k走30次
  ...
  j=20
    k走30次












i=1
  j走20次
i=2
  j走20次
...
i=10
  j走20次




















\t:水平制表位(固定占8位)





























循环的选择:
1)先看固定次数还是不固定次数:
  1.1)固定次数，直接上for
  1.2)不固定次数，再看要素1与要素3是否相同:
      1.2.1)相同时，上do...while
      1.2.2)不同时，上while




int score = 0; //总分
for(int i=1;i<=10;i++){ //10次
  //1)出题  2)答题  3)判题
}
System.out.println("总分为:"+score);














Addition














0到99


Math.random()--------------0.0到0.999999999999...
*100-----------------------0.0到99.99999999999...
(int)----------------------0到99






(1)15+25=?
算吧!
40
答对了
























(2)45+67=?
算吧!
101
答错了


(3)15+25=?
算吧!
40
答对了


(4)45+67=?
算吧!
101
答错了


(5)15+25=?
算吧!
40
答对了


(6)45+67=?
算吧!
101
答错了


(7)15+25=?
算吧!
40
答对了


(8)45+67=?
算吧!
101
答错了


(9)15+25=?
算吧!
40
答对了


(10)45+67=?
算吧!
101
答错了
总分为:50






















































//      1            2           3
for(int times=0 ; times<10 ; times++){
  System.out.println("行动是成功的阶梯"); //4
}


12432432432432432432432
12432432432432432432432


int times=0;      //1
while(times<10){  //2
  System.out.println("行动是成功的阶梯"); //4
  times++;        //3
}


































1/3/5/7/8/10/12-------------31天
4/6/9/11--------------------30天
2---------------------------28天/29天