JAVA入门基础详解之四

内容：
1.循环：反复的执行一段相同或相似的代码
2.循环三要素：
  1).循环变量的初始化
  2).循环的条件（以循环变量为基础）
  3).循环变量的改变（向着循环的结束变）
  循环变量：在循环过程中有所改变的那个量
3.循环结构
  1).while结构   
  2).do...while结构   

  3).for结构 

一、while循环语句
   1.语法
     循环变量的初始化语句;
     while(boolean表达式/循环条件语句){
          循环体（反复执行的代码）;
          循环变量的改变语句;
     }
   2.执行过程
     执行初始化语句->boolean表达式判断->若为true/false->执行循环体/不执行循环->执行循环变量


改变语句
     ->再进行boolean表达式判断->若为false循环结束


二、do-while循环语句
   1.语法
     do{
          循环体（反复执行的代码）;
          循环变量的初始化语句/循环变量的改变语句;       -----do-while中第1要素与第3要素相


同，也可不同
     }while(boolean表达式/循环条件语句);
   2.执行过程
     执行循环体->执行循环变量改变语句/初始化语句
     ->进行boolean表达式判断->若为true循环继续执行循环体...
     
   ****while与do-while的区别：当初始条件不满足时，while循环一次都不执行，do-while循环不管任


何情况都至少循环一次。
       a.while循环先判断再循环
       b.do-while循环先执行一次，再判断


二、for循环语句               ------应用率最高
   1.语法
     for(循环变量的初始化语句;循环的条件;循环变量的改变){
          循环体（反复执行的代码）;
     }
   2.执行过程                          ->若为false,退出循环
     执行初始化语句->执行循环的条件语句->若为true->执行循环体->执行循环变量的改变语句
                   ->再执行循环条件语句->若为true->执行循环体...
                      ->若为false,退出循环
    for循环三个表达式特殊用法： 
     第一种：
        循环变量的初始化语句;                                                  
        for(;循环的条件;循环变量的改变){
          循环体（反复执行的代码）;
        }
     第二种：                          
        for(循环变量的初始化语句;循环的条件;){
          循环体（反复执行的代码）;
          循环变量的改变;
        }  
     第三种：   死循环                          
        for(;;){
          循环体（反复执行的代码）;
        } 
for(System.out.println(2);;System.out.println(3)){
   System.out.println(1);
}
运行结果：死循环，213131313131....
     第四种：循环变量的初始化/改变语句中，可以使用逗号表达式
        for(int i=0,j=0,k=0;i<10&&j<4&&k<10;j+=2){
           System.out.println(i++);
           System.out.println(++k+i);
           System.out.println();
}
        //结果为0  2    1  4
        for(int i=5,j=7;j<10;i-=2,j+=1){
   System.out.println("i,j="+i+","+j);
}
//结果为i,j=5,7   i,j=3,8   i,j=1,9   
三、循环中使用break语句及continue语句 
   1.break：
         循环中的break语句应用率很广，break可用于循环语句或switch语句中。
         其用于循环时，可使程序***终止循环而执行循环后面的语句***，常常与条件语句一起使用
例：
 int sum = 0;
 for(int num=1;num<=100;num++){
     if(sum>=4000){             -----总和大于等于4000时终止循环      只能跳出一层


For循环
         break;
     }
     sum+=num;
 }


   2.continue：
         continue语句只能用于循环中，它的作用为***跳过循环体中剩余语句而执行下一次循环***
例：
 int sum = 0;
 for(int num=1;num<=100;num++){
     if(num%10==3){             -----统计总和时，跳过所有个位为3的
         continue;
     }
     sum+=num;
 }
   




一、循环问题
   1.三种循环结构的更佳适用情况
     a.循环问题定义------“当”循环
       如果业务可以转换为“当……”这样的句式时，优先选择while语句来实现


     b.循环问题定义------“直到”循环
       如果业务可转换为“直到……”这样的句式时，优先选择do-while语句来实现
       第1要素和第3要素相同时，首选do-while结构


     c.循环问题定义------固定次数循环
       如果业务中可以获取到一个确切的循环次数时可以考虑使用for循环来实现


二、嵌套循环
   1.循环中套循环，一般多行多列时使用
     外层循环一般控制行，内层循环一般控制列
   2.执行原理：外层走一次，内层走所有次
   3.循环层数越少越好，能用一层就不用两层，能用两层就不用三层
     如果超三层循环来实现，说明设计有问题
   4.break只能跳出一层循环


三、数组
   程序=算法+数据结构
   算法：解决问题的流程/步骤。
      if、if-else、switch、循环解决的都是算法问题
   数据结构：简单说就是把数据按照特定的某种结构来保存。
      设计良好的数据结构会导致好的算法。
      设计合理的数据结构式解决问题的前提。


   ***数组就是最基本的最常用的一种数据结构
   1.什么是数组
     相同数据类型的元素组成的集合
     数组也是一种数据类型（引用类型）
     int a;//声明整型变量a
   2.数组的定义：声明数组时规定数组长度，new关键字分配空间时需要指定分配的空间大小
     数据类型[] 数组名 = new 数据类型[大小];（大小是指数组中元素的个数）
     int[] array = new int[5];//对数组的声明：声明整型数组array，包含5个元素，每个元素都是


int型，默认值为0（整数型、字符型）
     double[] array = new double[5];//声明浮点型数组array，包含5个元素，每个元素都是浮点型


，默认值为0.0（浮点型）
     boolean[] array = new boolean[5];//声明布尔型数组array，包含5个元素，每个元素都是


boolean型，默认值为false（布尔型）
   3.数组的初始化
     int[] arr = new int[3];//默认初始值为{0,0,0}
     int[] arr = {1,3,5};//声明的同时初始化
     int[] arr = new int[]{1,3,5};//声明同时初始化
     错误范例：
     int[] arr;                
     arr = {1,3,5};//编译错误  
     arr = new int[]{1,3,5}//对一个已经声明了的数组，进行初始化          *************
   4.数组的访问
     a.通过数组名.length来获取数组的长度
          int[] arr = new int[3];
 System.out.println(arr.length);//3  
     b.通过下标/索引来访问数组中的元素
       下标从0开始，最大到arr.length-1
        arr[0]=1;//数组的第一个元素
        arr[1]=3;//数组的第二个元素
        arr[2]=5;//数组的第三个元素
        arr[3]=100;//编译不报错，但运行后会出现数组下标越界异常
   5.数组的遍历：用for循环来实现
     int[] arr = new int[100];
     for(int i=0;i<arr.length;i++){
        arr[i]=250;//代表数组的每个元素的值都为250
System.out.println(arr[i]);
     }
     
     for(int i=arr.length-1;i>=0;i--){//反着输出数组的元素
        System.out.println(arr[i]);
     }
     ===========================================================================
     找数组元素最大值/最小值的算法：
     a.假设第1个元素为最大值、最小值
       int max/min = arr[0];
     b.遍历剩余元素，将剩余元素与max比较，符合条件则修改max的值为较大的
       for(int i=1;i<arr.length;i++){             for(int i=1;i<arr.length;i++){
           if(arr[i]>max){                            if(arr[i]<min){  
     max = arr[i];                               min = arr[i]; 
  }                                           }
       }                                           }
         
   6.数组的复制
      1).System.arraycopy方法用于数组的复制
         System.arraycopy(a,b,c,d,e);
           a:被复制的数组//源数组
           b:被复制的元素在数组的起始位置//源数组的起始下标
           c:需要复制的数组//目标数组
           d:需要复制的数组的起始位置//目标数组的起始下标
           e:要复制的元素个数
           int[]  a = {10,20,30,40,50};
  int[] a1 = new int[7];
           System.arraycopy(a,1,a1,0,3);
  for(int i=0;i<a1.length;i++){
      System.out.println(a1[i]);//{20,30,40,0,0,0,0}
  }
  复制时需保证源数组中有足够的元素能被复制，否则执行程序后会出现异常


      2).Arrays.copyOf方法可实现数组的复制    ---不灵活
        需要先import java.util.Arrays;
        int[]  a = {10,20,30,40,50};
int[]  a1 = Arrays.copyOf(a,4);//a为源数组，4代表新数组的长度
/*
生成的新数组是原始数组的副本；
        新数组长度小于源数组，则进行截取；
        新数组长度大于源数组，则用0或null进行填充
*/
        for(int i=0;i<a1.length;i++){
            System.out.println(a1[i]);//新数组长度小于源数组，进行截取，结果为{10,20,30,40}
}
      3).数组的扩容
        需要先import java.util.Arrays;
        Java语法规定，数组的长度在创建后是不可改变的，这点需要明确。
        而所谓的扩容实际上是指创建一个更大的新数组并将原有数组的内容复制到其中。
          int[]  a = {10,20,30,40,50};
 a = Arrays.copyOf(a,a.length+1);//新数组{10,20,30,40,50,0}
 或：a = Arrays.copyOf(a,a.length-1);//新数组{10,20,30,40}
  
   8.数组的排序
     需要先import java.util.Arrays;
     JDK提供了一个排序方法：Arrays.sort(array)方法，只能升序   ----效率高
     Arrays.sort(array);---独自占一行
     常用的排序算法有：插入排序、冒泡排序、快速排序
     一般情况下，通过排序过程中数组元素的交换次数来衡量排序算法的优劣：数据不同排序算法的优


劣也不同


     冒泡排序法：6句代码
      1).4个数冒三轮（以此类推）
      2).每一轮都是从第一个元素开始冒
         每一次都是和他的下一个元素比
      3).冒出来的就不再参与比较
      范例：int[] arr = {56,8,23,1};
          第一轮:
                56和8比，换，8,56,23,1
                56和23比，换，8,23,56,1
                56和1比，换，8,23,1,56------56冒出来了
          第二轮:
                8和23比，不换
                23和1比，换，8,1,23,56------23冒出来了
          第三轮:
                8和1比，换，1,8,23,56-------8冒出来了
      for(int i=0;i<arr.length-1;i++){
         for(int j=0;i<arr.length-1-i;j++){
   if(arr[j]>arr[j+1]){//升序，若前面的元素大于后面的元素就交换，保证了前数小于后


数；
           //if(arr[j]<arr[j+1]){//降序
      int t = arr[j];
      arr[j] = arr[j+1];
      arr[j+1] = t;
   }
}
      }