我的JAVA学习 基础(2)

六 Java分支结构

   分支结构就是控制程序根据不同的条件走不同的顺序执行不同的语句
   Java语言有两种分支结构
   if结构：
   (1)if(条件表达式){
         语句块;
      }
 满足条件执行语句，不满足不执行，1条路。
   (2)if(条件表达式){
         语句块;
       }else{
    语句块;
       }
 满足条件执行语句，不满足执行另一条语句，两条路。
   (3)if(条件表达式){
         语句块;
 }else if{
    语句块;  
 }else if{
    语句块;
 }......
 满足不同的条件执行不同的语句，多条路。
switch-case结构：
是一种特殊的分支结构，只能用于判断整数，可以根据整数表达式的不同值，执行相应case值的语句。需要使用break，作用是执行完相应的语句后则退出switch块，不执行下面的语句。如果不加break，则会在满足条件后，将该条件下面的其他条件的语句块一起按顺序输出，直到遇到break或switch-case结束停止。还可以加上default选项，作用:默认匹配完所有条件后不匹配的情况下才会执行default语句，default可以不写break，也不是必须放在后一个,但是建议规范代码写在最后。
    switch(判断整数){
      case 1:语句块1;break;
      case 2:语句块2;break;
      case 3:语句块3;break;
 .......
      default:语句块n;break;
    }
switch-case相比if-else，优点是执行效率更高，结构也简单清晰易懂。且从JDK7.0开始，switch语句支持字符串表达式。如下例子：
    public class Test {
      public static void main(String[] args){
        String sng = "B";
          switch(sng){
           case "A":System.out.println("A");break;
           case "B":System.out.println("B"); break;
           default:System.out.println("C"); break;
          }
      } 
    }
但是switch-case缺点是判断条件太单一，不满足大多情况下需要的判断，而if-else判断条件更加灵活。

七 Java循环结构

     Java顺序结构的程序语句只能被执行一次。如果想要同样的操作执行多次,，就需要使用到循环结构。
     Java中有三种主要的循环结构：
      while() 循环
     do…while() 循环
     for() 循环
     后来在Java5中还加入了一种主要用于数组的增强型for循环。

     while() 循环 while是最基本的循环，它的结构为：

     while( 条件表达式 ) {
           //循环内容
     }
     只要条件表达式满足，循环体会一直执行下去，直到不满足为止。
     例如：
     int x = 10;
     while( x < 20 ) {
         System.out.println( x );
         x++;
     }
     会输出10至19。到20时不满足条件了便跳出循环，循环便结束。

     do…while() 循环

     对于while循环而言，如果不满足条件，则不能进入循环。但有时候我们需要即使不满足条件，也至少执行一次。do…while循环和while循环相似，不同的是，do…while循环至少会执行一次。
     do {
       //代码语句
     }while(条件表达式);
条件表达式在循环体的后面，所以语句块在检测表达式之前已经执行了一次。 如果满足表达式，则语句块一直执行，直到不满足表达式。
     例如：
int x = 20;
     do{
         System.out.println( x );
         x++;
     }while( x < 20 );
会输出20，然后不满足条件跳出循环。

for()循环

     虽然所有循环结构都可以用while()或者do...while()表示，但Java 提供了另一种语句——for()循环，使一些循环结构变得更加简单。
     for(循环变量的声明和初始化;循环条件;循环变量的改变) {
        //代码语句
     }
     最先是循环变量的声明和初始化。
     然后循环条件。如果满足，循环体被执行。如果不满足，循环终止，开始执行循环体后面的语句。
     执行一次循环后，循环变量的改变。
     再次检测循环条件。循环执行上面的过程。
     例如：
for(int x = 10; x < 20; x = x+1) {
         System.out.print( x );
         }
     会输出10至19，当循环变量x增加到20时不满足条件便跳出循环结构。

     Java增强for循环

     Java5引入了一种主要用于数组的增强型 for 循环。
for(声明类型一样的变量 : 要循环的数组){
        //代码句子
     }

逻辑其实就是自动控制一次遍历数组中的每一个元素，然后将它赋值给一个临时变量，然后在循环体中可直接对此临时变量进行操作。也可以遍历集合。

八 Java数组

     所谓数组，是无序的元素序列。 若将有限个类型相同的变量的集合命名，那么这个名称为数组名。组成数组的各个变量称为数组的分量，也称为数组的元素，有时也称为下标变量。用于区分数组的各个元素的数字编号称为下标。数组是在程序设计中，为了处理方便， 把具有相同类型的若干元素按无序的形式组织起来的一种形式。 这些无序排列的同类数据元素的集合称为数组。
     数组：引用类型，一堆相同类型的数据的集合。
1.数组的声明：数据类型名[]  变量名;
2.数组的初始化：
(1)静态初始化：直接赋值
reg:
int[] a = {1,2,3,4,5};
静态的变量不能再被赋值新的静态值。
(2)动态初始化： 
1) int[] a = new int[length];
会有length个默认值
整型:0
浮点数：0.0
字符：'\u0000'
布尔类型：false
引用类型：null
2) int[] a = new int[]{1,2,3,4,5};
动态的变量也只能赋值为新的动态值。
3.数组的元素：元素是指里面的数据
4.数组的下标：元素的位置，从0到length-1;
  数组的长度(元素的个数)，int num = 变量名.length;
5.数组元素的访问(存取)，变量名[下标]
6.数组的遍历（从头到尾全部查看）
int[] a = {1,3,4,5,7};
for(int i=0;i<a.length;i++){
System.out.print(a[i]);
}
Arrays:数组工具类
        Arrays.toString(变量名)：
        功能：把数组的里的元素拼接成如下字符串
系统数组复制法
System.arraycopy(p1,p2,p3,p4,p5);
p1:源数组，表示你要复制的数组
                p2:从源数组开始复制元素的下标
                p3:目标数组，表示要复制到的那个数组
p4:表示目标数组从哪个下标开始进行
p5:表示要复制的长度
         数组的扩容，缩容
Arrays.copyOf(p1,p2);
p1：源数组，要复制的那个数组
p2：表示扩容或者是缩容到多少长度
         会产生一个新的数组对象

         数组的排序

冒泡排序：
两个紧挨着的元素进行比较，
如果前面的大于后面的，应该进行交换
然后拿后面的较大，在与紧挨着的下一个去比较
int[] a1 = {7,4,3,6,1};
//外层控制的是轮数
for(int i =0;i<a1.length-1;i++){
//每轮比较的次数
for(int j=0;j<a1.length-i-1;j++){
if(a1[j]<a1[j+1]){
//临时变量，备份数据
int temp = a1[j];
a1[j]=a1[j+1];
a1[j+1]=temp;
}
}
}