黑馬程式員_循環語句、函數和數組

黑馬程式員_循環語句、函數和數組

------Java教育訓練、Android教育訓練、iOS教育訓練、.Net教育訓練、期待與您交流！ ------- 

                                                                            循環語句部分

一，循環語句    while    ，do  while     ，for

       1、while語句的格式   while（條件表達式）{        執行語句；     }

       2、do while 語句的格式 do{  執行語句 ；}while（條件表達式）；

相比較if語句來說，while和do  while 語句是一個循環語句，在運作時候，如果條件表達式滿足條件，她就會一直執行執行語句的部分；而if語句，當滿足條件表達式的時候，隻會執行一次。

      注意：在dos見面運作無限循環時候，用ctrl+c   進行強制程式停止。

while  和do  while 語句的相同處和不同處，看下列語句

    //while  方式的循環語句

         int x =1;

        while (x<0)

       {

              System.out.println("Hello World!");

             x++;

       }

  //do  while  方式的循環語句

       int y = 1； 

       do

      {

             System.out.println("do:x="+y);

             y++；

      }

       while(y<0) ;

        相同處：while 和do while語句其實都是循環語句，隻要滿足條件表達式就會執行裡面的執行語句。

       不同處：while是先判斷條件表達式是否成立，成立即執行循環程式，不成立就會立即跳出。

              do  while是先執行一遍循環程式裡的執行語句，然後在判斷條件表達式是否成立，成立就會繼續執 行，不成立就會跳出。

       是以上述語句中，do while 會執行一次 y   ，while 一次都不會執行

注意while（）後面緊跟一個分号 即  ：while（條件表達式）； 此時語句是成立的，隻是會變成無限循環。

3、for 循環語句  格式為：for（初始化表達式；循環條件表達式；循環後操作表達式）{  執行語句  ；}

      初始化表達式是第一步，隻會執行一次，其後就會執行後面的語句，而且裡面的變量在for循環結束的時候裡面的變量就消失了。具體程式如下：

class ForDemo

{

 public static void main(String[] args)

 {

  for(int x=0;x<3;x++)

  {

   System.out.println("x="+x);

  }

  System.out.println("x===="+x);                此時，結果為空，就是說沒有變量x

  int y = 0;

  while (y<3)

  {

   System.out.println("y="+y);

  }

  System.out.println("y===="+y);  此時，結果又y 

 }

}

      相對于while語句，它的初始化語句在while循環語句外面，當while語句循環結束的時候，變量還在。

這樣就會出現一個編寫程式選擇：1）如果增量變量隻用于循環語句，定義在for語句中，隻在for語句中有效，佛for語句完成後就會釋放記憶體用for循環語句。

                                                2） 如果增變變量循環語句後可用，定義在while語句之外，就可用while語句

                                                 3）for和while語句可以進行互換，如果需要定義循環變量，for更為合适

for循環裡面條件表達式，注意是條件表達式，必須有真假。其他兩個表達式可以是其他類型的表達式，當其中含有多個表達式的時候，用逗号隔開即可。例如：for（int x=1，y=9；x<3,y<12;x++,y++)。

for語句中的初始化表達式和循環後表達式也可以不寫。

 小細節：無線循環最簡單表達式。

               （1）  for（；；）{  }             條件表達式為空，即系統會預設為true

               （2）   while（true）{  }

循環語句一定要注意，哪些語句要參與循環，哪些不需要參與循環，确定需要幾個未知參數，确定類型以及各自循環的姿态。涉及的思想：累加思想和計數器。就是就是通過一個變量來記錄住資料的變化。 

 循環嵌套語句的聯系：class ForForDemo

{

 public static void main(String[] args)

 {

  for(int x =0;x<3;x++)

  {

   for(int y=0;y<4;y++)

   {

    System.out.println("ok");

   }

   System.out.println();//隻有一個功能就是換行

  }

 }

}

打出的結果是一個有  *   好組成的長方形，内外循環相對于此處來說，就是外循環控制行數，内循環控制列數。當列數改變時，可以改變for循環内循環語句裡的初始化值或者條件表達式，使之随着外循環的變化而變化，做出相應的改變。

小技巧：在用循環語句尤其是嵌套循環語句來制作像表格一類的東西的時候，為了對齊 ，可以再輸出語句裡加入  " \t "   即制表符來進行制表。

 二，break和continue

不同點：

       1）應用範圍的不同：

       break語句應用範圍：           選擇語句（switch語句）和循環語句

      continue語句以應用範圍：   循環語句

      2）作用不同：

       break是跳出目前循環語句，注意此處跳的是它所在的循環，比如内循環

      continue是結束本次循環開始下次循環

相同點：這兩個語句離開應用範圍都是沒有意義的，在作用範圍外會編譯出錯

              這兩個語句單獨存在下面都不是不可以有語句的因為執行不到，是以兩個語句後面不跟任何語句。

是以我們當寫到無線循環的程式時，可以通過break語句來判斷使用者或者其他的資料滿足條件語句，來跳出無限循環語句。

  小細節：可以在循環語句前加上    名稱 ：循環語句    就是對循環語句做标号，相當于起名字。如w:for(;;)，此處w就是循環語句做的标号。通過此小标号，可以這樣運用，如：在内循環中加入break  w  ；就可以把外循環關閉。

                   函數

 一、函數

        函數就是定義在類中的具有特定功能的一段獨立的小程式。

        實際上就是一個可以實作固定功能的方法，隻是把這種發法裝到一個可以用于調用的程式裡，這樣我們以後需要這個特定功能，隻要調用這個函數就可以實作。函數就是方法，方法就是函數。

        對于函數調用，就是提高了程式的複用性，也友善日後的程式的使用。

        函數其實就是講一段特定功能的代碼進行封裝，隻有被調用的時候才會被執行。

        函數之間可以互相調用。

函數的格式： 修飾符  傳回值類型  函數名 （參數類型  形式參數1，參數類型 形式參數2，.....）

                          {

                                            執行語句；

                                            return 傳回值；

                           }

          在主函數中調用格式為      函數名（參數）

        注意，1）如果函數中沒有具體的傳回值情況，傳回值類型用關鍵字void表示，那沒該函數中的return如果再最後一行可以省略不寫。像是現在基礎用到的列印。

                   2）函數中隻能調用函數，不可以在函數内部定義函數。

在主函數中調用格式為      函數名（參數）

                   3）傳回值類型為void時，不能用列印語句輸出

二、重要思想：     如何定義一個函數呢

1、既然函數是一個獨立的功能，那麼該功能的運算結果是什麼先明确

     就是說有一個需求，一般是這個需求要一個結果或者其他什麼東西，那麼我這個功能就得達到這個結果或者目标，那麼我就知道該功能運算結果是什麼，是以要先明确。運算結果明确就是在明确傳回值類型。

2、在明确都在定義該功能的過程中是否需要未知的内容參與運算

      這個功能達成一個結果，裡面有未知的或者是外面輸入的，即是未知的參數，這個參數需要參與運算，那麼就定義它。未知參數明确，就是在明确參數清單和參數個數。

函數調用舉例：

class FunctionTest

{

 public static void main(String[] args)

 {

  juXing(5,6);

  kouJue();

  System.out.println("Hello World!");

 }

 //列印矩形的一個調用函數

 public static void juXing(int a,int b)

 {

  for(int x=0;x<a;x++)

  {

   for (int y=0;y<b ;y++ )

   {

    System.out.print("*");

   }

   System.out.println();

  }

 }

 //定義一個功能，列印九九乘法口訣表

 public static void kouJue()

 {

  for (int x=1;x<=9 ;x++ )

  {

   for (int y=1;y<=x ;y++ )

   {

    System.out.print(x+"*"+y+"="+x*y+"\t");

   }

   System.out.println();

  }

 }

}

兩個函數都是沒有傳回值類型，在矩形條用函數中，行列數是有使用者輸入的，是以定義在參數清單中。九九乘法表中，是要直接列印一個九九乘法表，是以并沒有需要輸入的未知參數，是以直接用for循環完成它。

注意，調用，直接調用函數，并不需要再寫列印語句，這就是因為調用的函數裡傳回類型是void型的，是以，不能再主函數裡再次寫列印語句列印結果。

 三、函數的重載

        在同一個類中，允許存在一個以上的同名函數，隻要他們的參數個數或者參數類型不同即可。

        就是說重載隻看參數清單，與其他的無關。注意，隻和參數清單有關系。

           如：

                    取和的運算    public static int  add(int x ,int y)

                                          public static int  add(int x, int y， int  z )

                                          public static double  add(double x,double）

以上三個函數重載了，1）和2）函數的名稱一樣，傳回值類型一樣，但是參數清單不一樣，個數不一樣

                                     2）和3）函數名稱一樣，參數清單的參數類型不一樣，即是重載

有上可知，當定義功能相同，但參與運算的未知内容不同，那麼此時就定義一個函數名稱以表示其功能，友善閱讀，而通過參數清單的不同來區分多個函數。

 數組部分

一、數組

       同一種類型資料的集合，數組就是一個容器。

       數組可以自動給數組中的元素開始編号，友善操作這些元素。

格式1：元素類型[ ]  數組名 =  new  元素類型[元素個數或者數組長度]；

格式2：元素類型[ ]  數組名 =  new  元素類型[ ]{元素，元素，... }；

 new會在容器中産生一個可以存儲資料的實體。數組類型資料引用資料類型。

表示數組中每個元素的具體位置格式為：數組名[位置數 ]   位置數是從零開始的

數組建立在記憶體中的流程：

      int  [ ]   x =  new   int[ ]；

      int  [ ]  x    先會在棧記憶體中建立一個x，使用數組的時候，次值存在，數組使用完成後就是釋放棧記憶體，就是說棧記憶體是一個臨時性的記憶體空間。

    小知識：所有局部變量，都定義在棧記憶體中

      new  就是建立一個實體，實體包括數組和對象。隻要運作new  就會在堆記憶體中配置設定空間。并且在其中每個元素都建立對應的角标，是從0開始的，一定要注意是從0開始的。

      每個記憶體都有一個位址值，是二進制的，此時就把數組在記憶體中的位址值賦給x ，此時是一個指派動作。

        當數組建立的是，就會在記憶體中給預設初始化值，整型類0 ，布爾型為false。

null  空    ，隻有引用類資料類型可以用這個關鍵字。如 x = null   就是把數組的位址值變為空，如果這樣在程式裡，就是得原數組沒有位址值指向，是以，此時為垃圾，無效資料。

     堆記憶體中的特點：1）位址值  2）預設初始化值 3）垃圾回收機制

 其中垃圾回收機制，就是java裡，本身會定期清理垃圾資料。

一個數組固定長度，比如3，當程式列印角标為3的時候，就會出錯，但是程式編譯的時候不會出錯，文法上也沒有錯誤。但程式一旦運作，就會顯示角标出錯。說明在編譯程式的時候，數組并沒有建立，程式開始運作的是數組才會建立起來。這個要注意。

二、數組的操作

        一般的數組操作都會用到周遊。數組中有一個屬性可以直接擷取到數組元素的個數，length，使用方法為    數組名.length    。

1、常見操作以：周遊

一下為一個周遊數組的函數：

 public static void printarr(int[] arr)     這是要擷取一個元素為int型的數組

 {

  for (int x=0;x<arr.length ;x++ )               arr.length  為數組元素個數，牢記，數組部分常用

  {

   if(x!=arr.length-1)

    System.out.print(arr[x]+",");

   else

    System.out.print(arr[x]);

  }

 }

2、常見操作二：擷取數組元素最大值

思路：1）擷取最值需要進行比較，每一次比較都會有一個比較大的值，因為該值不确定，通過一個變量進行臨時存儲。

2）讓數組中每一進制素都與這個變量中的值進行比較，如果大于變量中的值，就用該變量記錄較大的值。

3）當所有元素比較完，那麼該變量中的存儲的就是數組中的最大值了

 public static int arr(int[] arr)                      傳回值類型是int型 

 {

  int max=arr[0];

  for (int x=1;x<arr.length ;x++ )            周遊數組

  {

   if (arr[x]>max)                                    相比較，記錄最大值

   {

    max=arr[x];

   }

  }

  return max;                                         傳回最大值，這個一定要注意，出去void型不需要傳回值，其他都需

 }                                                            要

這個隻是int類型的數組，對其他類型的數組，擷取最值的方法是一樣的，隻是數組元素資料類型不一樣，是以可以建立重載函數。

3、選擇排序

思路：

1、以角标為0的元素開始，與角标為1的數組進行比較，如果1的較小，則兩者互換，再以角标為的0的元素與2角标的比較，如果小，則兩者互換，依次類推。

2、進行比較，要周遊數組

 public static void paiXuArr(int[] arr)

 {

  for (int x=0;x<arr.length-1 ;x++ )                      從0角标開始，到倒數第二個元素即可，最後一個自己不需要

  {                                                                          比較

   for (int y =x+1;y<arr.length ;y++ )                     從x+1角标開始到最後一個角标元素，每個角标與x角标比較

   {

    if (arr[y]<arr[x])

    {

     int temp =arr[x];                                                   如果小，兩者換位置（此處用第三方變量換位）

     arr[x]=arr[y];

     arr[y]=temp;

    }

   }

  }

  printarr(arr);                                                          調用列印數組的函數

 }

4、冒泡排序

思路：相鄰兩個元素進行比較 ，具體來說，就是角标0與角标1的相比，小的排在前、大的排在後，然後角标1的和角标2的比較，也是小的排在前，大的排在後，依次排序。到數組的最後一定是最大的在最後面。當第二次比較開始時，最後的元素不參與比較，照上比較後，第二大的元素就會排出來，以此類推。程式為

 public static void maoPaoArr(int[] arr)

 {

  for (int x=0;x<arr.length-1 ;x++ ) ............................. 周遊數組元素，隻需比較arr.length-1次

  {

   for (int y =0;y<arr.length-x-1 ;y++ ) ............................此處應注意y<arr.length-x-1   每次比較後比較的

   {                                                                  次數就會減少一次，就是減少x，是以-x是讓每一次元素比較減

    if (arr[y]<arr[y+1])                                       少。如果元素個數為5，當y取到arr.length-1，即5-1=4時，y+

    {                                                                 1就是5，超出最大角标數4了，是以y最大隻能取到3，是以

     int temp =arr[y];                                        y<arr.length-x-1。

     arr[y]=arr[y+1];

     arr[y+1]=temp;

    }

   }

  }

  printarr(arr);

 }

排序最快的為，希爾排序。

在以上程式中，要注意到共性的部分，比如位置置換，相對應的可以把這個功能單獨寫成一個函數，以待調用。

5、數組查找  折半查找

折半查找就是從中劈開，然後比較大小。是以，數組必須是有序的數組，注意是有序的數組。這種方法可以調高效率。具體程式例子：

public static int halfSearch(int[] arr,int key)

 {

  int min,max,mid;

  min=0;

  max=arr.length-1;

  mid=(min+max)/2;

  while(arr[mid]==key)

  {

   if (key>arr[mid])

    min=mid+1;

   else

    max=mid-1;

   if(min>max)

    return -1;

   mid=(min+max)/2;

  }

   return mid;

 }

這個程式也可以用于把一個數插入到這個有序的數組，還保證數組有序，擷取的位置就是傳回最小角标min為數值。

6、二維數組

格式     int[ ][ ]  arr = new int [3 ] [2 ];  此處定義了一個名為arr的二維數組，二維數組中有有3個一維數組，每個一維數組裡有兩個元素。兩個一維數組角标為0和1，每個一維數組裡的元素角标按一維數組來排。是以，要是想指派給第二個二維數組中最後一個元素，寫成：  arr[1][1]  = 90 

要是想初始化一個一維數組，寫成  arr[1]=new int[1];

注意：在二維數組中

System.out.println(arr);      此時列印的是二維數組的位址值

System.out.println(arr[0]);    此時列印的是二維數組中第一個一維數組的位址值

int[ ][ ]  arr = new int [3 ] [ ];      此處第二個括号裡不寫值  此時在System.out.println(arr[0]);    結果是：null 。

 因為每個數組是引用資料類型，是以預設初始化值為null。在這之後如果初始化一維數組，那麼就在記憶體中開辟空間存放一維數組，并把這個一維數組的位址值付給相對應arr[0]、arr[1]、arr[2]，實質指向一維數組七、進制轉換的聯系

class ArrayTest7

{

 public static void main(String[] args)

 {

  toBin(-6);

  System.out.println();

  toBin(6);

  System.out.println();

  toHex(-60);

  System.out.println();

  toHex(60);

  System.out.println();

 }

 public static void toBin(int num) ............//二進制轉換

 {

  trans(num,1,1);

 }

 public static void toHex(int num)...............//十六進制轉換

 {

  trans(num ,15,4);

 }

 public static void trans(int num,int base,int offset)..........................轉換進制的基本調用函數

 {

  //建表

  char[] chs = new char[]{'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};..........制表

  char[] arr= new char[32];..............................................建立一個容器

  int pos = arr.length;.....................................................建立一個指針，為倒着記錄進容器，先取最大值

  while(num!=0)

  {

   int temp = num & base;

   arr[--pos]=chs[temp];                                                 進行與運算和位移，把對應表裡的字元記錄到容器裡

   num = num>>>offset;

  }

  for(int x=pos;x<arr.length;x++)..........................................列印容器裡的元素

  {

   System.out.print(arr[x]);

  }

 }

}