黑马程序员---语句与数组

语句与数组

----------- android培训、java培训、java学习型技术博客、期待与您交流！ ------------

1.流程控制

1.1 顺序结构

顺序结构就是一直执行下去的语句结构。就是我们前面所做的那种。

1.2 判断结构

判断结构可根据不同的判断条件执行不同的语句，判断条件就是关系表达式。

判断结构包括：if条件语句和 switch语句。

1）if语句

    定义 ：在某个条件成立的情况下执行某段程序，如果条件不成立，就执行另外的语句。

If 条件语句也分为：简单的if条件语句、if…else…语句和 if .. else if … 多分支语句

if (判断条件){         复合语句...}else if(判断条件){         复合语句...}...//可以有零个或多个else if语句else//最后的else语句也可以省略{         复合语句...}

2) switch语句

语句特点：

1.switch语句选择的类型只有四种：byte,short,int,char(JDK 7 新增功能可以放下String类型).

2.case 之间与default 没有顺序。先执行第一个case,没有匹配的case 就执行default.

3.结束switch语句有两种情况，遇到break,执行到switch语句结束。

4.如果匹配的case 或者default没有对应的break,那么程序会继续向下执行，执行可能执行的语句，直到遇到break或者switch结尾结束。

switch(表达式){      case 常量表达式 1 ： 语句序列 1 ；break; //break可有可无      case 常量表达式 2 ： 语句序列 2 ；break; //break可有可无      case 常量表达式 3 ： 语句序列 3 ；break; //break可有可无     .。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。      case 常量表达式 n ： 语句序列 n ；break; //break可有可无      default            ： 语句序列 n + 1 ; break; 最后的break的确可省。 }

1.3 循环结构

循环结构：通过循环语句让同一段代码反复执行多次，执行完毕程序才会继续往后运行

1）while

while语句是“当型”循环语句，也就是条件表达式成立时，执行循环体中的内容。其语法格式为：

 while(条件表达式){            循环体}

public class TestWhile {     /**     * @param args     */    public static void main(String[] args) {        // TODO Auto-generated method stub        int count = 1 ;        //循环条件        while(count <= 10 ){                               if(count < 10)            //循环输出1~10的数                System.out.print(count + ",");              else                System.out.print(count);           //count ++ 变量自增            count ++;                                  }    }}输出：1,2,3,4,5,6,7,8,9,10 

注：若有时循环条件难以写出，可直接在“()”填写true（所谓死循环）,而后在循环体中加入判断条件，当满足条件时执行break语句就可以跳出循环。

while(true){   If (条件表达式)break;}

2) do….while 语句

    do … while先执行一次循环体，然后判断while中的表达式，如果是true继续执行，如果是false则跳出循环。

所以do …while 至少要执行循环体一次。

其语法格式为： 

do{   循环体} while(条件表达式)

3) for 语句

语法格式：

 for(表达式1; 表达式2;表达式3){      语句序列}

表达式1：该表达式用于初始化循环控制变量，它只在循环开始时执行一次。

表达式2：循环条件表达式，它的类型为boolean，如果表达式的值为true，则执行一次循环体。

表达式3：该表达式用于改变循环体变量的值。

for循环的执行过程如下：

1.执行表达式1，完成某一变量的初始化工作，如 int I = 0;

2.判断表达式2的值，如I < 100。若表达式2的值为true,则执行一次循环体，然后执行第三步，否则，退出循环体结束for循环。

3.执行表达式3，这部分通常执行循环控制变量的修改。

4. 跳转到第二步继续执行循环。

具体如下图：

4）嵌套的循环

当循环结构的循环体中又包含循环结构时，循环结构就呈嵌套的形式。三种循环语句可以相互嵌套。

代码实例：输出九九乘法表

public class TestWhile {     /**     * @param args     */    public static void main(String[] args) {        // TODO Auto-generated method stub          for(int i= 1 ; i < 10 ; i ++ ){          //输出九九乘法表的一行            for(int j = 1 ; j <= i ; j ++){                    //输出九九乘法表的一小列                          System.out.print(j + "*" + i + "=" + j * i + "   ");                              }  //第一行换一行            System.out.println();                                      }    }}输出：1*1=1   1*2=2   2*2=4   1*3=3   2*3=6   3*3=9   1*4=4   2*4=8   3*4=12   4*4=16   1*5=5   2*5=10   3*5=15   4*5=20   5*5=25   1*6=6   2*6=12   3*6=18   4*6=24   5*6=30   6*6=36   1*7=7   2*7=14   3*7=21   4*7=28   5*7=35   6*7=42   7*7=49   1*8=8   2*8=16   3*8=24   4*8=32   5*8=40   6*8=48   7*8=56   8*8=64   1*9=9   2*9=18   3*9=27   4*9=36   5*9=45   6*9=54   7*9=63   8*9=72   9*9=81  

5) 循环的跳转 

continue、break、return

continue：结束本次循环，继续执行下一次（只是不执行contine下面的内容）

break：结束循环

return：结束方法

其中continue 、break 是可以用标记来实现跳转的。

用九九乘法表看看标记的作用

public class TestWhile {/** * @param args */public static void main(String[] args) {// TODO Auto-generated method stubouter: for (int i = 1; i < 10; i++) {for (int j = 1; j <= i; j++) {if (i == 2)// 中断外循环 连空行也不输出continue outer; if (i == 3)// 中断内循环 这里是因为在这循环里i == 2 , 所以作用相当于breakcontinue; if (i == 6)// 跳出内循环 只是结束一层循环break; if (i == 8)// 跳出外循环 跳出时循环已结束break outer; // 输出九九乘法表的一列System.out.print(j + "*" + i + "=" + j * i + "   "); }// 第一循环换一行System.out.println(); }}}输出：1*1=1   1*4=4   2*4=8   3*4=12   4*4=16   1*5=5   2*5=10   3*5=15   4*5=20   5*5=25   1*7=7   2*7=14   3*7=21   4*7=28   5*7=35   6*7=42   7*7=49  

4.   函数

定义：函数就是定义在类中的具有特定功能的一段独立小代码。函数也称为方法。

格式：

[访问修饰符] [静态修饰符] 返回值类型函数名（参数类型 形式参数1，参数类型 形式参数2）{     执行语句     return 返回值;}  

参数说明：

返回值类型：函数运行后的结果的数据类型 ，不需要返回，返回值类型为 void 。

参数类型：是形式参数的数据类型。

实际参数：是一个变量，用于存储调用函数时传递函数的实际参数。

return: 用于结束函数。

返回值：该值会返回给调用者。

函数的特点

1．  定义函数可以将功能代码进行封装。

2．  全类对该功能的复用。

3．  函数只有被调用才会执行。

4．  函数的出现提高了代码的复用性。

5．  对于没有具体返回值的情况，返回值用关键字void表示，那么该函数中的return如果在最后一行可以省略不写。

注意：1.函数中只能调用函数，不可以函数内部定义函数.

      2.定义函数时，函数的结果应该返回给调用者，交由调用者处理。

      3.写代码的规范：主类只负责调用，其他功能在其他类中完成！方便后来的复用。

数组

定义：具有相同数据类型的一组数据的集合。Java中数组是被看作一个对象，程序设计中引入数组可更有效地管理和处理数据。数组分为一维与多维数组。

初始化一维数组，初始化一维数组有两种方法：

1）静态初始化int arr []  = new int []{34,65,87,41};

2）动态初始化int arr [] = new int [4]; arr[0] = 34 ; arr[1] = 68 ; arr[2] =87 ; arr[3] = 41 ;

数组的长度：数组的长度可以通过数组名.length 获得。

数组的遍历：可以通过已知的数组长度来达到遍历数组的目的，也可以通过JDK1.5的新增功能来遍历数组。

数组的下标：数组的下标由0开始，所以数据的最大下标为 (数组名.length -1);

数组常见的异常：如果访问数组时索引越界（小于0或者大于length-1），会抛出异常：ArrayIndexOutOfBoundsExcepion

如果访问数组的引用为空(null)，会抛出空指针异常：NullPointerException

public class TestWhile {/** * @param args */public static void main(String[] args) {// TODO Auto-generated method stubint[] arr = { 54, 41, 74, 96, 87, 45, 65, 41 };System.out.println("数组的长度：" + arr.length);System.out.println("数组中的元素有：");//根据数组长度遍历数组for (int i = 0; i < arr.length; i++) {if (i != arr.length -1) //根据数组下标输出数组成员System.out.print(arr[i] + ",");elseSystem.out.println(arr[i]);}}}输出：数组的长度：8数组中的元素有：54,41,74,96,87,45,65,41

多维数组：所谓多维数组就是二维和大于二维的数组。多维数组的声明其实就是用一维数组的嵌套声明实现的。拿二维数组来举例，二维数组就是一个所有元素都是一维数组的一组数组。

二维数组也有两个方法初始化：

1）  int [] [] a = new int [2][4]; 

2）  int [] [] a = new int [2] []; a[0] = new int [4] ; a [1] = new int[4];（就是分别跟N个一维数组赋值）

上述代码创建的二维数组就是两个长度为4的一维数组组成。

论坛上看到的题目：求最值和素数

/**1.输入10个数，求最值。2.求输入的10个数是中素数之和。要求： 1.使用多种方法来操作，比较方法的优缺点。 2.在每个方法的注释上写清楚编程思路。 3.一定要使程序清晰。*/import java.util.Arrays;import java.util.Scanner;public class Practice {     public static void main(String[] args)      {             Practice pra = new Practice();             pra.manager();             System.out.println("Hello World!");     }     //代理类---其实可以写在main()中，不过想想还是分开吧！     public  void manager(){        Scanner input = new Scanner(System.in);        System.out.println("请输入十个数：");    int count = 0 ;        int [] arr = new int[10];       //循环向数组输出数值        while (count  < 10)        {                System.out.print("输入第" + (count + 1 ) + "个数：" );                arr[count++] = input.nextInt();        }        System.out.println("数组中的素数之和为：" + getPrime(arr));        //比较大小的有三种方法        //1.直接比大小，最简单的方法        System.out.println("输入数最大值为：" + getMax(arr));            //2.用数组的sort()方法排序：数组中的下标最大值为最大值        System.out.println("输入数最大值为：" + getMax2(arr));         //冒泡排序法                        System.out.println("输入数最大值为：" + getMax3(arr));        //选择排序法                         System.out.println("输入数最大值为：" + getMax4(arr));                      }     //求最佳的方法1，直接遍历比较，返回最大值者     public int getMax(int [] arr){      //设第一个数为最值                                      int max = arr[0];              //循环比较                                          for ( int i = 1; i < arr.length ; i ++ )                     {         //若大于max,则将其值赋予max                     if (max < arr[i])                                                 {                             max = arr[i];                     }         }             //返回max             return max;                                          }     //直接用Arrays中的方法实现排序     public int getMax2(int [] arr){                             Arrays.sort(arr);         //返回数组的最后一位，也就是最大值了             return arr[arr.length -1];                        }     /*      *冒泡排序法：一个一个比较大小，大的向极位移动      *优点就是实现思想比较简单，让人容易了解，比较稳定      *缺点就是要经常作变量交换，比较耗时      * */     public int getMax3(int [] arr){                                   //一个中间变量，用来作变量交换                                                                                                             int temp;               //遍历数组                                              for (int i = 1 ; i < arr.length ;  i ++)                {          //比较相邻的幸免于难，较大者则往后                      for ( int j = 0 ; j < arr.length - i ; j ++ )                            {                      //若前一位数比后一位数大，则交换位置                              if (arr[j] > arr[j+1])                                                   {                                      temp = arr[j];                                      arr[j ] = arr[j + 1];                                      arr[j + 1] = temp;                              }                      }          }            //返回最后一位数组，即是最大值              return arr[arr.length -1];                        }      /*直接排序法，就是遍历数组将最大值放在最后位，次值放在后二位的做法       * 优点：算法交换的次数比冒泡排序要少，所以比较节省时间       * 缺点：比较不稳定       * */     public int getMax4(int [] arr){                               //设中间值，作数据交换之用                                                            int temp;             //遍历数组           for ( int i = 1 ; i < arr.length ; i ++)                   {          //索引变量                       int index = 0 ;                            //比较各数，排序                                                for ( int j = 1 ; j <= arr.length - i ; j ++ )                       {                       //比较两者，大者下标为index                               if (arr[j] > arr[index])                                                {                                       index = j;                               }                       }                       temp = arr[arr.length - i];                        //循环结束后再将其进入数据交换                                        arr[arr.length - i] = arr[index];                       arr[index] = temp;           }               return arr[arr.length -1];     }     //求素数的方法     public int getPrime(int [] arr ){       //获取数组中的素数之和                                    int sum = 0;             System.out.print("数组中的素数为：");             //遍历数组          for ( int i = 0; i < arr.length ; i ++ )                      {                                /*           * 用一个布尔常量表示是否是素数           * 判断数组中的每一个数是否是素数，循环条件为该数的 1 / 2 ，因为除了2外偶数都不是素数，           * 而将该数除以 它一半和之前的数就可以判断它是否为素数           * */                              boolean isPrime = true;                                                    for ( int j = 2 ;  j <=  arr[i] / 2; j ++ )                                                                                                           {                                  //如果一个数能被它一半以下的数整除，那它就不是素数                                      if ( arr[i] % j == 0)                                                           {                                      //此处的布尔值为不是素数                                              isPrime = false;                                            //一旦能整除退跳出循环，不用再判断                                                                   break;                                                                     }                              }                              if (isPrime)                              {                                    //输出素数                                      System.out.print(arr[i] + "\t");                                        //将它们的和相加                                            sum += arr[i];                                                      }                               }              System.out.println("素数之和为：" + sum);              //返回素数结果              return sum;                                                          } }

3.编程练习

3.1按输入的数字输出相应长度的菱形

import java.util.Scanner;public class Diamond {public static void main(String[] args) {Scanner input = new Scanner(System.in);System.out.print("请输入要输出的菱形的长度：");int num = input.nextInt();printDiamond(num);}public static void printDiamond(int num) {// 计算菱形的大小，若输入为双数则加一if (num % 2 == 0) num++;for (int i = 0; i < num / 2 + 1; i++) {// 输出左上角的空白for (int j = num / 2 + 1; j > i + 1; j--) {System.out.print(" ");}// 输出菱形上半部分实体for (int j = 0; j < 2 * i + 1; j++) {System.out.print("*");}System.out.println();}for (int i = num / 2 + 1; i < num; i++) { // 输出左下角的空白for (int j = 0; j < i - num / 2; j++){System.out.print(" ");}// 输出菱形下半部分实体for (int j = 0; j < 2 * num - 2 * i - 1; j++) {System.out.print("*");}System.out.println();}}}输出：请输入要输出的菱形的长度：12      *     ***    *****   *******  ********* ************************ ***********  *********   *******    *****     ***      *

3.2计算1 + 1 / 2! + 1 / 3! + ……. + 1 / 20! ;

public class Diamond {public static void main(String[] args) {manager();}private static void manager() {// TODO Auto-generated method stub//设总和为sumdouble sum = 0;//循环加1~1/20之间的和for(int i = 1; i <= 20 ; i ++ ){//每个阶乘的值double partSum = 1 ;for (int j = 1; j <= i; j++) {//j的阶乘partSum *= j;}sum += 1 / partSum;}//输出System.out.println("1 + 1 / 2! + 1 / 3! + ……. + 1 / 20! = " + sum);}}输出：1 + 1 / 2! + 1 / 3! + ……. + 1 / 20! = 1.7182818284590455

3.3打印出10行的杨辉三角;

/** * 思路：杨辉三角的定义, * 一个数前提：端点的数为1. *  1、每个数等于它上方两数之和。 *  2、每行数字左右对称，由1开始逐渐变大。 *  3、第n行的数字有n项。 *  由杨光三角的定义可知，此数列应用二维数组来做 *  且每一个一维数组的长度为其下标加一 *  由定义可知，除杨辉三角的边界为1外，其里面的元素triangle[i][j] = triangle[i-1][j] + triangle[i][j-1]; * * */public class YanghuiTriangle{    public static void main(String[] args)    {    //调用输出杨辉三角的方法        triangle();                                                               }    //输出杨辉三角的方法    public static void triangle(){    //新建一个长度为10的二维数组               int [] [] triangle = new int [10][] ;                 //按二维数组的长度来循环                                     for ( int i = 0 ;  i < triangle.length ; i ++ )                             {               //输出左边的空格                   for(int j = triangle.length -1 - i; j > 0 ; j --){                             System.out.print("  ");                   }                   //每次循环都新建一个一维数组，长度为数组元素下标加一                   triangle [i] = new int[i + 1];                                           for ( int j = 0 ; j <= i ; j ++)                   {                   //边界输出1                       if(i == 0 || j == 0 || j == i )                             triangle[i][j] = 1;                                                                 else                       //里面的元素按上面的公式定来计算                           triangle[i][j] = triangle[i - 1] [j]  + triangle[i -1][j -1];                            //输出每个值                       System.out.print(triangle[i][j] + "  ");                   }                   //第一循环换一行                   System.out.println();               }    }}输出：                  1                  1  1                1  2  1              1  3  3  1            1  4  6  4  1          1  5  10  10  5  1        1  6  15  20  15  6  1      1  7  21  35  35  21  7  1    1  8  28  56  70  56  28  8  1  1  9  36  84  126  126  84  36  9  1 

 ----------- android培训、java培训、java学习型技术博客期待与您交流！ ------------