1 函數

1.1 數的概述

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

練習：把兩個整數相加：

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

來表示該函數沒有傳回值。

函數名：僅僅是一個辨別符，可以随意起名字。

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

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

傳回值:傳回給調用者。

定義函數：

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

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

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

public static int getMax(int x, int y) {
        int result;
        if (x > y) {
            result= x;
        } else {
            result= y;
        }
return  result;
    }

解析：getMax方法

該方法方法名為：getMax,方法的作用是擷取找出兩個整數中較大的值。該方法有兩個int型參數，：x和y，方法傳回兩個數中較大的一個。

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 函數的特點

1、定義函數可以将功能代碼進行封裝

2、便于對該功能進行複用

3、函數隻有被調用才會被執行

4、函數的出現提高了代碼的複用性

5、對于函數沒有具體傳回值的情況，傳回值類型用關鍵字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 函數的應用

案例一：畫矩形。

/*
        為了提高代碼的複用性
        定義一個畫矩形的函數
            1、确定函數的運算結果的資料類型，void
            2、确定沒有未知參數。
     */
    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();
        }
    }

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

/*
        1、确定函數的運算結果的資料類型，boolean
        2、确定沒有未知參數。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、函數重載的定義：在同一個類中，有一個以上的同名函數，隻要函數的參數清單或參數類型不一樣即可，與傳回值無關，這些統稱為方法的重載。

2、函數的重載存在的原因：為了增強方法的閱讀性，優化了程式設計。

案例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();
        }
    }


    private static void print99(int num) {
        for(int i = 1 ; i<= num ; 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 數組

如果需要存儲大量的資料，例如如果需要讀取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大派，分為基本資料類型和引用資料類型。第二大派是引用資料類型。那麼大家現在已經接觸到了引用資料類型三種當中的一種。就是數組類型 [] 中括号就代表數組。

4、int[] arr = new int[5];在記憶體中發生了什麼？

記憶體任何一個程式,運作的時候都需要在記憶體中開辟空間.int[] arr = new int[5]; 這個程式在記憶體中是什麼樣?這就涉及到了java虛拟機在執行程式時所開辟的空間,那麼java開辟啟動了多少空間呢？繼續學習java的記憶體結構。

1. 數組的定義

格式1：

格式2：

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

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

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

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

周遊數組

1. 數組初始化

數組的格式

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};

數組周遊

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;
        } // 那麼這就是數組的第一個常見操作.周遊
    }

數組的常見異常

一數組角标越界異常:，注意：數組的角标從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
    }

數組:

什麼時候使用數組:當元素較多時為了友善操作這些數組,會先進行來臨時存儲，所使用的容器就是數組。

特點:

數組長度是固定的。

數組的記憶體分析

案例分析一：

案例分析二：

6. 數組的常見操作

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

/*定義一個擷取最大值的功能:
        1、确定結果 ：傳回值類型 int
        2、未知内容：要擷取哪個數組的最大值沒有确定，則是數組沒有确定
    
    思路：
        1、定義一個變量，記錄住數組的比較大的元素。
        2、周遊整個數組，讓數組的每一個元素都和該變量進行對比即可。
        3、當變量遇到比它大的元素，則讓該變量記錄該元素的值，當循環結束時，最大            值産生了
    */
    
    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!");
        
        
    }
}

java4---函數與數組1 函數6. 數組的常見操作

1 函數

1.1 數的概述

1.2 函數的格式

1.4 函數的應用

6. 數組的常見操作

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

6.2直接排序

6.3冒泡排序

6.4折半查找(二分法)

3 二維數組

周遊： toString() 将數組的元素以字元串的形式傳回

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

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

二維數組:

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

數組定義：

繼續閱讀

關于Gradle配置的小結

Java小案例——随機數猜測随機數猜測

nginx location中斜線的位置的重要性

27 Best Free Eclipse Plug-ins for Java Developer to be ProductiveCode Quality PluginsText Editor PluginsDependency ManagementVersion Control Integration PluginsFramework Development Continuous Integration Related PluginsOther Utility Plugins

Java String.format方法的簡單使用

neo4j之cypher使用文檔

GitHub連夜封殺！這份阿裡 10W 字内部 Java 字面試手冊到底有多強？

spark/scala關于【資源檔案】加載方法概述外部檔案加載方案測試資源檔案打包入jar包中小結

mybatis_入門程式Mybatis入門

AOP程式設計_Android優雅權限架構(1)概念基礎，2021金三銀四前言正文大綱正文

Effective Java 8:通用程式設計

OOM三種類型

工廠模式-三種類型

【遞歸】高效率求2的n次幂

win10本地scala和spark安裝安裝scala安裝spark

scala (3) Function 和 Method

java4---函數與數組1 函數6. 數組的常見操作

1 函數

1.1 數的概述

1.2 函數的格式

1.4 函數的應用

6. 數組的常見操作

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

6.2直接排序

6.3冒泡排序

6.4折半查找(二分法)

3 二維數組

周遊： toString() 将數組的元素以字元串的形式傳回

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

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

二維數組:

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

數組定義：

繼續閱讀

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