數組和函數教程詳解

時間 2019-11-05

標籤數組函數教程詳解简体版

原文原文鏈接

1 、函數

1.1 數的概述

發現不斷進行加法運算，爲了提升代碼的複用性，就把該功能獨立封裝成一段獨立的小程序，當下次須要執行加法運算的時候，就能夠直接調用這個段小程序便可，那麼這種封裝形形式的具體表現形式則稱做函數。java

練習：把兩個整數相加：小程序

public class FunctionDemo1{

       public static void main(String[] args){

              /*

              int a = 4+5;

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

              int b = 3+9;

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

 

         */

              add(4,5)

       }

       public static int add(int a, int b){

              return a+b;    

       }

}

舉例：地鐵自動售票機，接收紙幣或硬幣，返回車票，該售票機具備獨立功能，能夠理解爲函數。有未知內容參與運算（要投幣，紙幣硬幣，多少錢）。有返回值（返回車票）數組

舉例2：手機，手機具有打電話功能，有未知內容（電話號碼），鍵盤是（形參），輸入的號碼是實際參數。數據結構

1.2 函數的格式

修飾符 返回值類型 函數名(參數類型 形式參數1，參數類型 形式參數2，…)

    {

           執行語句;

           return 返回值;

    }

返回值類型： 運行這段程序得出的一個運算結果，結果類型，若是函數沒有返回值則用void函數

來表示該函數沒有返回值。學習

函數名：僅僅是一個標識符，能夠隨意起名字。優化

形式參數：是一個變量，用於存儲調用函數傳遞進來的實際參數。spa

實際參數：傳遞給形式參數的具體數值。設計

返回值:返回給調用者。指針

定義函數：

1：是否有未知內容參與運算

2：是否有運算結果（返回值）

案例：獲取2個整數中的較大的數。

public static int getMax(int x, int y) {

        int result;

       if (x > y) {

           result= x;

       } else {

           result= y;

       }

return  result;

    }

該方法方法名爲：getMax,方法的做用是獲取找出兩個整數中較大的值。該方法有兩個int型參數，：x和y，方法返回兩個數中較大的一個。解析：getMax方法

public static 是方法的修飾符

int 是方法的返回值類型

getMax 是方法的方法名

（int x,int y）是參數列表，x和y是形式參數。

{} 花括號內的代碼是方法體

return result; result 是返回值。

方法定義完成以後，如何調用一個方法？

函數調用：

想要使用方法，必須調用它。

public static void main(String[] args) {

       int max = getMax(5, 7);

       System.out.println(max);

}

完整程序一：在main方法中調用getMax()方法，5和7就是給該方法傳遞的實際參數。若是方法有返回值，能夠定義一個變量接收返回值，變量類型和方法返回值類型一致。本例中經過int類型變量max接收了getMax方法的返回值。

這裏的getMax(i, j); i和j就是實際參數。

public class Demo6 {

    public static void main(String[] args) {

       int i=5;

       int j=7;

       int max = getMax(i, j);

       System.out.println(i+"和"+j+"的最大值是："+max);

    }

 

    public static int getMax(int x, int y) {

        int result;

       if (x > y) {

           result= x;

       } else {

           result= y;

       }

return  result;

    }

}

二：上述案例中調用getMax方法，並將結果賦值給了max變量。也能夠直接打印getMax()方法的結果。

public class Demo6 {

    public static void main(String[] args) {

       int i=5;

       int j=7;

        //打印方法的結果

       System.out.println(getMax(i, j));

    }

 

    public static int getMax(int x, int y) {

        int result;

       if (x > y) {

           result= x;

       } else {

           result= y;

       }

return  result;

    }

}

注意：main方法是程序的入口由虛擬機調用，方法和方法之間不能嵌套，方法之間經過調用來使用。

方法何時執行完畢：

當執行完return語句，或者執行到方法末尾的花括號時方法結束。

該類中包含了兩個方法，main方法和getMax方法。main方法由java虛擬機調用，而且main方法的寫法是固定的。Main方法能夠調用其餘方法。

當調用getMax方法時，變量i的值傳遞給方法中的x，j的值傳遞給方法中的y，並開始執行getMax方法中的語句，執行return，並返回運算結果。getMax方法運行完畢。

1.3 函數的特色

一、定義函數能夠將功能代碼進行封裝

二、便於對該功能進行復用

三、函數只有被調用纔會被執行

四、函數的出現提升了代碼的複用性

五、對於函數沒有具體返回值的狀況，返回值類型用關鍵字void表示，那麼該函數中的return語句若是在最後一行能夠省略不寫。

注意：

函數中只能調用函數，不能夠在函數內部定義函數。

定義函數時，函數的結果應該返回給調用者，交由調用者處理。

函數的返回值void

需求：根據學生考試成績劃分ABCD A90-100 B80-89 C70-79 D60-69 E0-59，建議成績使用double。將該程序使用函數定義。

public static void main(String[] args) {

       printGrade(90);

       printGrade(59.5);

    }

 

    public static void printGrade(double score) {

       char grade;

       if (score >= 90.0)

           System.out.println("A");

       else if (score >= 80.0)

           System.out.println("B");

       else if (score >= 70.0)

           System.out.println("C");

       else if (score >= 60.0)

           System.out.println("D");

       else

           System.out.println("E");

 

    }

public static void main(String[] args) {

       getResult(5);

    }

    public static int  getResult(int x){

        System.out.println(return x*8);  

        //調用該函數會報錯.缺乏返回值類型.

    }

    /*

     * 該方法沒有具體的返回值,那麼返回值的類型 是不能夠寫int 了

     * 可是又和函數的格式不符合了,怎麼解決？

     * 當函數運算後, 沒有具體的返回值時,這時返回值類型用一個特殊的關鍵字作標誌.

     * 該關鍵字就是void void 表示沒有具體的返回值類型.

     * 當函數的返回值類型是void 時,函數中的return語句能夠省略不寫.

     */

注意: 函數中只能調用函數，不能夠在函數內部定義函數。函數之間是平級的,相互之間是調用的關係.

錯誤寫法

public static void main(String[] args) {

       public static void getResult(int x) {

           System.out.println(x * 8);

           // 主函數，裏邊嵌套函數。錯誤！

       }

}

1.4 函數的應用

案例一：畫矩形。

/*

      爲了提升代碼的複用性

      定義一個畫矩形的函數

          一、肯定函數的運算結果的數據類型，void

          二、肯定沒有未知參數。

    */

   public static void  draw(int width , int height){

      for(int i = 0 ; i< height ; i++){

          for(int j = 0 ; j < width ; j++){

             System.out.print("*");

          }

          System.out.println();

      }

   }

案例二：兩個數字對比是否相等

  /*

       一、肯定函數的運算結果的數據類型，boolean

       二、肯定沒有未知參數。a,b

    */

   public static boolean  equlas(int a , int b){

      /**

      if(a==b){

          return true;

      }else{

          return false;

      }

      **/

      return a==b?true:false;

     

   }

案例三：比較兩個數的大小

  /*

   比較兩個整數誰大.

   */

   public static int max(int a,int b)

   {

      /*

      if(a>b)

          return a;

      else

          return b;

      */

 

      return a>b?a:b;

   }

函數的使用注意事項：

函數中只能調用函數，不能定義函數，沒有定義函數以前，不能調用函數。
輸出語句只能對有具體返回結果的函數的進行打印。
返回值類型是void的函數，是不能夠被輸出語句打印的。
函數須要實現功能，那麼函數只實現所需功能便可，不要實現不須要的功能。

1.5 函數的重載

一、函數重載的定義：在同一個類中，有一個以上的同名函數，只要函數的參數列表或參數類型不同便可，與返回值無關，這些統稱爲方法的重載。

二、函數的重載存在的緣由：爲了加強方法的閱讀性，優化了程序設計。

案例1：九九乘法表

private static void print99() {

      for(int i = 1 ; i<= 9 ; i ++){

          for(int j = 1 ; j<=i ; j++){

             System.out.print(i+"*"+j+"="+(i*j)+" ");

          }

          System.out.println();

      }

   }

練習：判斷那個方法是重載

void  show(int  w, double c, char b){}    

void show(int x, char y, double z){}   true       

 void show(int a, double c, char b){}     false  

 

void show(int a, char b){}   true

void show(double c){}   true

double show(int x, char y, double z){}   true

2 、數組

概念

同一種類型數據的集合。其實數組就是一個容器。

數組的好處

能夠自動給數組中的元素從0開始編號，方便操做這些元素。

格式1：

元素類型[] 數組名 = new 元素類型[元素個數或數組長度];

示例：int[] arr = new int[5];

格式2：

元素類型[] 數組名 = new 元素類型[]{元素，元素，……};

int[] arr = new int[]{3,5,1,7};

int[] arr = {3,5,1,7};

若是須要存儲大量的數據，例如若是須要讀取100個數，那麼就須要定義100個變量，顯然重複寫100次代碼，是沒有太大意義的。如何解決這個問題，Java語言提供了數組（array）的數據結構，是一個容器能夠存儲相同數據類型的元素，能夠將100個數存儲到數組中。

1數組的概念

同一種類型數據的集合。其實數組就是一個容器。運算的時候有不少數據參與運算,那麼首先須要作的是什麼.不是如何運算而是如何保存這些數據以便於後期的運算，那麼數組就是一種用於存儲數據的方式，能存數據的地方咱們稱之爲容器，容器裏裝的東西就是數組的元素, 數組能夠裝任意類型的數據，雖然能夠裝任意類型的數據,可是定義好的數組只能裝一種元素，也就是數組一旦定義，那麼裏邊存儲的數據類型也就肯定了。

2 數組的好處

存數據和不存數據有什麼區別嗎？數組的最大好處就是能都給存儲進來的元素自動進行編號. 注意編號是從0開始。方便操做這些數據。

例如學生的編號，使用學號就能夠找到對應的學生。

3數組的格式

元素類型[] 數組名 = new 元素類型[元素個數或數組長度];

示例：int[] arr = new int[5];

案例：

需求: 想定義一個能夠存儲3個整數的容器

實現：

1聲明數組變量

爲了使用數組必須在程序中聲明數組，並指定數組的元素類型

=左半部分：

先寫左邊明確了元素類型是int ，容器使用數組，那麼如何來標識數組？.那麼用一個特殊的符號[]中括號來表示。想要使用數組是須要給數組起一個名字的,那麼咱們在這裏給這個數組起名字爲x .接着跟上等號。

代碼體現：

int [] x

注意：int x[] 也是一種建立數組的格式。推薦使用int [] x 的形式聲明數組。

2建立數組

=右半部分：

要使用一個新的關鍵字.叫作new。new 用來在內存中產生一個容器實體，數據要存儲是須要有空間的，存儲不少數據的空間用new 操做符來開闢，new int[3]; 這個3是元素的個數。右邊這部分就是在內存中定義了一個真實存在的數組，能存儲3個元素。

new int[3] 作了兩件事情，首先使用new int[3] 建立了一個數組，而後把這個數組的引用賦值給數組變量x。

int [] x=new int[3];

x 是什麼類型？

任何一個變量都得有本身的數據類型。注意這個x 不是int 類型的。int 表明的是容器裏邊元素的類型。那麼x 是數組類型的。

數組是一種單獨的數據類型。數據類型分爲2大派，分爲基本數據類型和引用數據類型。第二大派是引用數據類型。那麼你們如今已經接觸到了引用數據類型三種當中的一種。就是數組類型 [] 中括號就表明數組。

四、int[] arr = new int[5];在內存中發生了什麼？

內存任何一個程序,運行的時候都須要在內存中開闢空間.int[] arr = new int[5]; 這個程序在內存中是什麼樣?這就涉及到了java虛擬機在執行程序時所開闢的空間,那麼java開闢啓動了多少空間呢？繼續學習java的內存結構。

1. 數組的定義

格式1：

元素類型[] 數組名 = new 元素類型[元素個數或數組長度];

示例：int[] arr = new int[5];

格式2：

元素類型[] 數組名 = new 元素類型[]{元素，元素，……};

int[] arr = new int[]{3,5,1,7};

int[] arr = {3,5,1,7};

注意：給數組分配空間時，必須指定數組可以存儲的元素個數來肯定數組大小。建立數組以後不能修改數組的大小。可使用length 屬性獲取數組的大小。

遍歷數組

2. 數組初始化

數組的格式

int[] x = new int[3];

x[0] = 1;

x[1] = 2;

另外一種定義：該形式能夠直接明確數組的長度,以及數組中元素的內容

int[] x = { 1, 2, 3 };

int[] x=new int[]{1,2,3};

初始化方式1：不使用運算符new

int[] arr = { 1, 2, 3, 4, 5 };

int[] arr2 = new int[] { 1, 2, 3, 4, 5 };

初始化方式2：

int[] arr3=new int[3];

arr3[0]=1;

arr3[1]=5;

arr3[2]=6;

若是數組初始化中不使用運算符new。須要注意：下列寫法是錯誤的。

int[] arr;

arr={1,2,3,4,5};

此時初始化數組，必須將聲明，建立，初始化都放在一條語句中個，分開會產生語法錯誤。

因此只能以下寫：

int[] arr={1,2,3,4,5};

3. 數組遍歷

public static void main(String[] args) {

int[] x = { 1, 2, 3 };

for (int y = 0; y < 3; y++) {

System.out.println(x[y]);

// System.out.println("x["+y+"]="+x[y]); 打印效果 x[0]=1;

} // 那麼這就是數組的第一個常見操做.遍歷

}

數組中有一個屬性能夠獲取到數組中元素的個數,也就是數組的長度. 數組名.length

public static void main(String[] args) {

int[] x = { 1, 2, 3 };

for (int y = 0; y < x.length; y++) {

System.out.println(x[y]);

// System.out.println("x["+y+"]="+x[y]); 打印效果 x[0]=1;

} // 那麼這就是數組的第一個常見操做.遍歷

}

4. 數組的常見異常

一數組角標越界異常:，注意：數組的角標從0開始。

public static void main(String[] args) {

int[] x = { 1, 2, 3 };

System.out.println(x[3]);

//java.lang.ArrayIndexOutOfBoundsException

}

二空指針異常:

public static void main(String[] args) {

int[] x = { 1, 2, 3 };

x = null;

System.out.println(x[1]);

// java.lang.NullPointerException

}

數組:

何時使用數組:當元素較多時爲了方便操做這些數組,會先進行來臨時存儲，所使用的容器就是數組。

特色:

數組長度是固定的。

5. 數組的內存分析

案例分析一：

案例分析二：

6. 數組的常見操做

6.1案例一個數組取出最大值

 /*定義一個獲取最大值的功能:

      一、肯定結果 ：返回值類型 int

      二、未知內容：要獲取哪一個數組的最大值沒有肯定，則是數組沒有肯定

  

   思路：

      一、定義一個變量，記錄住數組的比較大的元素。

      二、遍歷整個數組，讓數組的每個元素都和該變量進行對比便可。

      三、當變量遇到比它大的元素，則讓該變量記錄該元素的值，當循環結束時，最大        值產生了

   */

  

   public static int getMax(int[] arr)

   {

      //定義變量記錄較大的值，初始化爲數組中的任意一個元素。

      int max = arr[0];

 

      for(int x=1; x<arr.length; x++)

      {

          if(arr[x]>max)

             max = arr[x];

      }

      return max;

 

              }

6.2直接排序

案例二：使用直接排序對數組進行排序：

  /*

   選擇排序。

   以一個角標的元素和其餘元素進行比較。

   在內循環第一次結束，最值出現的頭角標位置上。

   */

   public static void selectSort(int[] arr)

   {

      for(int x=0; x<arr.length-1; x++)

      {

          for(int y=x+1; y<arr.length; y++)//爲何y的初始化值是 x+1？       由於每一次比較，

                                   //都用x角標上的元素和下一個元素進       行比較。

          {

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

             {

                int temp = arr[x];

                arr[x] = arr[y];

                arr[y] = temp;

             }

          }

      }

      }

6.3冒泡排序

案例三：冒泡排序

  /*

   冒泡排序。

   比較方式：相鄰兩個元素進行比較。若是知足條件就進行位置置換。

   原理：內循環結束一次，最值出如今尾角標位置。

   */

   public static void bubbleSort(int[] arr)

   {

      for(int x=0; x<arr.length-1; x++)

      {

          for(int y=0; y<arr.length-x-1; y++)//-x:讓每次參與比較的元減。

                                      //-1:避免角標越界。

          {

             if(arr[y]>arr[y+1])

             {

                int temp = arr[y];

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

                arr[y+1] = temp;

             }

          }

      }

}

6.4折半查找(二分法)

案例四：

/*

   爲了提升查找效率，可以使用折半查找的方式，注意：這種查找只對有序的數組有效。

   這種方式也成爲二分查找法。

   */

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

   {

      int min,mid,max;

      min = 0;

      max = arr.length-1;

      mid = (max+min)/2;

 

      while(arr[mid]!=key)

      {

          if(key>arr[mid])

             min = mid + 1;

          else if(key<arr[mid])

             max = mid - 1;

         

          if(min>max)

             return -1;

  

          mid = (max+min)/2;

      }

      return mid;

   }

案例五：數組翻轉

   /*

   反轉其實就是頭角標和尾角標的元素進行位置的置換，

   而後在讓頭角標自增。尾角標自減。

   當頭角標<尾角標時，能夠進行置換的動做。

   */

   public static void reverseArray(int[] arr)

   {

      for(int start=0,end=arr.length-1; start<end; start++,end--)

      {

          swap(arr,start,end);

      }

   }

   //對數組的元素進行位置的置換。

   public static void swap(int[] arr,int a,int b)

   {

      int temp = arr[a];

      arr[a] = arr[b];

      arr[b] = temp;

           }

3 、二維數組

Arrays的使用

遍歷： toString() 將數組的元素以字符串的形式返回

排序： sort() 將數組按照升序排列

查找： binarySearch()在指定數組中查找指定元素，返回元素的索引，若是沒有找到返回（-插入點-1）注意：使用查找的功能的時候，數組必定要先排序。

二維數組:

吸菸：

沒錢零買 1根一個變量

稍微有錢一包一維數組 20根變量

頗有錢一條 10包(二維數組) 二維數組

二維數組：實質就是存儲是一維數組。

數組定義：

數組類型[][] 數組名 = new 數組類型[一維數組的個數][每個一維數組中元素的個數];

疑問： 爲何a.length = 3, a[0].length = 4?

數組的初始化：

靜態初始化:

int [][] a = new int[][]{ {12,34,45,89},{34,56,78,10},{1,3,6,4} };

動態初始化：

二維數組常見的操做:

遍歷二維數組
對二維數組求和

class Demo3

{

// 定義一個遍歷二維數組的功能函數

public static void printArr2( int [][] a ){

// 1. 拆開二維數組

for ( int i = 0 ; i < a.length ; i++ )

{

// 2. 拆開一維數組獲取數據

for ( int j = 0 ; j < a[i].length ; j++ )

{

System.out.print( a[i][j]+" ," );

}

// 定義一個函數計算二維數組中的元素的累加和

public static long getSum( int [][] a ){

// 0. 定義一個結果變量

long sum = 0L;

// 1. 拆開二維數組

for ( int i = 0 ; i < a.length ; i++ )

{

// 2. 拆開一維數組獲取數據

for ( int j = 0 ; j < a[i].length ; j++ )

{

sum+=a[i][j];

}

return sum;

}

// 統計二維數組中元素的個數

public static int getDataCount( int [][] a ){

// 0. 記錄元素個數

int count = 0;

// 1. 拆開二維數組

for ( int i = 0 ; i < a.length ; i++ )

{

// 2. 拆開一維數組獲取數據

for ( int j = 0 ; j < a[i].length ; j++ )

{

count++;

}

return count;

}

public static void main(String[] args)

{

int [][] a = new int[][]{ {23,4,5},{2},{4,5,78,56,90} };

printArr2( a );

System.out.println();

System.out.println("累加和是： "+getSum( a ) );

System.out.println("統計元素個數： "+getDataCount( a ) );

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

}

相關標籤/搜索

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。

數組和函數教程詳解

1 、 函數

1.1 數的概述

1.2 函數的格式

1.3 函數的特色

1.4 函數的應用

1.5 函數的重載

2 、 數組

1. 數組的定義

2. 數組初始化

3. 數組遍歷

4. 數組的常見異常

5. 數組的內存分析

6. 數組的常見操做

6.1案例一個數組取出最大值

6.2直接排序

6.3冒泡排序

6.4折半查找(二分法)

3 、 二維數組

1 、函數

2 、數組

3 、二維數組