JAVA小白的成長（基礎篇）5

今天，咋們來聊一聊數組

數組

1.數組的定義

數組主要解決多變量多數據的存儲問題，方便程序後期統一維護操作數據

數組的本質：數組就是一系列空間大小相等且地址連續的一片存儲空間

數組的空間大小是相同的，爲了方便統一維護我們的數據，必須得保證數據之間的類型是一樣的。

數組是多個同類型的變量空間連在一起組成的結構。

數組的變量空間的地址是連續的，爲了方便統一操作我們的數據。

數組當中變量的地址遵循的就是我們高中數學的等差公式 An=A1+（n-1）*d,其中（n-1）表示的是角標

數組變量存的是什麼？存的是首元素的地址，然後根據等差公式就可以算出其他元素的地址了；

2.默認值

數組存在於堆內存中，但凡在堆中存儲的數據都稱之爲 對象，但凡在堆內存中創建的對象都會有默認初始值

數組創建的對象都會有默認初始值

整數類型默認0

浮點類型默認0.0

布爾類型默認false

引用數據類型（對象）默認null

class Test2{
             public static void main(String[] args){
                 int[] arr=new int[10];
                  System.out.println(arr(0));
        
             }
         }

因爲你沒有定義數組，所以他的輸出就是他的初始值0；

3.創建數組

創建數組時必須明確規定大小或內容

數據類型[ ] 數組名=new 數據類型[長度]； 創建數組只指定長度但不指定內容。

數據類型[ ] 數組名=new 數據類型[ ]{1,2,3,4,5}；創建數組指定內容(指定長度)。

數據類型[ ] 數組名={1,2,3,4,5};  創建數組指定內容(指定長度)。

其中：[ ]表示是一維數組；[ ][ ]表示二維數組。

舉例說明

int[] arr=new int[10];// 創建數組只指定長度但不指定內容。
int[] arr={1,2,3,4,5};//創建數組指定內容(指定長度)。

4.數組常見的錯誤

/*
創建數組
數組錯誤示範
*/
class Test2{
    public static void main(String[] args){
        //需求1：創建長度爲5的int型數組(一維)  矩陣(二維)
        int[] arr=new int[5];
        //需求2：訪問arr數組中第4個元素
        System.out.println(arr[3]);//1000+3*4
        System.out.println(arr[0]);
        System.out.println(arr[2]);
        //創建長度爲5的String型數組
        String[] strArr=new String[5];
        System.out.println(strArr[0]);
        //System.out.println(arr[10]);
        //ArrayIndexOutOfBoundsException 角標越界
        int[] arr2=arr;
        //此時此刻 數組還是那個數組對象 
        //只不多有兩個變量引用到了而已
        arr2[0]=10;
       System.out.println(arr[0]);
        arr2=null;
        //System.out.println(arr2[0]);
        //NullPointerException 空指針異常
        arr=null;
        //此時此刻 數組對象沒有任何變量引用它
        //數組對象在堆內存中就沒有存在的意義了
        //所以該對象變成垃圾，由【垃圾回收器gc】處理
        //【垃圾回收期】是JVM中的一個程序 專門用於負責處理堆內存中垃圾數據的
       //垃圾的處理並不是及時的，有【gc】來控制，當垃圾堆攢到一定程度時由【gc】來處理
       //特殊的 在C/C++中 如果出現對象垃圾 必須由程序員手動處理 free()及時處理
    }
}

ArrayIndexOutOfBoundsException 角標越界，他之所以會角標越界是因爲他要找的角標超出了，自己所賦給數組的長度；

NullPointerException 空指針異常；

5.常見的數組操作

遍歷   對數組遍歷輸入輸出。

賦值  對數組賦值。

最大值/最小值   計算數組中最大值、最小值。

遍歷：

import java.util.Scanner;
class Test3{
    public static void main(String[] args){
        int[] arr={1,2,3,4,5,6,7,8,9};//[0,8]
        //數組只有一個唯一的屬性 length 數組的長度
        System.out.println(arr.length);
        for(int i=0;i<arr.length;i++){
            System.out.println(arr[i]);
        }
    }
}

賦值：

import java.util.Scanner;
class Test4{
    public static void main(String[] args){
        Scanner scanner=new Scanner(System.in);
        // System.out.print("請輸入10個數字：");
        int[] arr2=new int[10];
        for(int i=0;i<arr2.length;i++){
            System.out.print("請輸入1個數字：");
            arr2[i]=scanner.nextInt();
        }
        for(int i=0;i<arr2.length;i++){
            System.out.print(arr2[i]+" ")；
        }
    }
}
   

最大最小值：

import java.util.Scanner;
class Test5{
    public static void main(String[] args){
        //最大值/最小值
        maxormin();
    }
    //最大值/最小值
    public static void maxormin(){
        //計算最大值或最小值的 值
       //計算最大值或最小值的 角標
        //需求 獲取最大的值10 獲取最小值的角標4
        int[] arr={10,2,8,3,1,6,4,7,9,5};
        int max=arr[0];
        int min_index=0;
        for(int i=0;i<arr.length;i++){
            if(arr[i]>max){
                max=arr[i];
            }
            if(arr[i]<arr[min_index]){
                min_index=i;
            }
        }
        System.out.println("最大值"+max);
        System.out.println("最小值角標"+min_index);
    }
}

6.查找（二分查找法和線性查找）

對於二分查找法，說的通俗易懂一點就是，一直/2，每除一次都會與自己的那個數字進行比較，看他在哪個範圍，然後繼續除2縮小範圍

class Test6{
    public static void main(String[] args){
        //線性查找
        linearSearch();
        //二分查找
        binarySearch();
    }
   public static void binarySearch(){
        //二分查找有個前提 數組必須有序
        /* 
        最好情況 查46 1次就出來了
        最壞情況 查12/60 O(logn)
       */
        int[] arr={12,17,21,32,38,41,46,49,50,50,51,59,60};
        int key=46;
        int index=-1;
        int min_index=0;                           //最左邊下標值：0
        int max_index=arr.length-1;                //最右邊下標值：數組長度-1
        int mid_index=(min_index+max_index)/2;    //尋找中間數
        while(arr[mid_index]!=key){                //循環中間數是要找的數k結束
            if(key<arr[mid_index]){                //k小於中間數時最右邊下標爲中間數下標-1  
               max_index=mid_index-1;
            }
            if(arr[mid_index]<key){                //k大於中間數時最左邊下標爲中間數下標+1  
                min_index=mid_index+1;
            }
            if(min_index>max_index){                //數組找完時還沒找到
                index=-1;
                break;
            }
           mid_index=(min_index+max_index)/2;      //尋找中間數
        }
        System.out.println(mid_index);
    }
    public static void linearSearch(){
        /* 
        最好情況 查10 1次就出來了
        最壞情況 查5  10次纔出來
        當數組的長度越大的話 最壞情況越差
        時間複雜度(最壞情況) O(n) 線性階
        */
        int[] arr={10,2,8,3,1,6,4,7,9,5};
        int key=11;
        int index=-1;   //key元素不存在
        for(int i=0;i<arr.length;i++){
            if(arr[i]==key){
                index=i;
                break;
            }
        }
       System.out.println(index);
    }
}

實戰演練

數組長度不固定 需要讀取一個數據 數組擴容 填入數據數據填入之後進行排序 然後遍歷數組依次判斷數據的個數連續相等

步驟：1.獲取用戶輸入的數據 動態的擴容數組填充數據

2.按照輸出結果 將數據中的數據進行排序

3.輸出連續相等的數字

import java.util.*;
class Demo05_01{
    public static void main(String[] args){
        /*
        思路1：數組長度不固定 需要讀取一個數據 數組擴容 填入數據
        數據填入之後進行排序 然後遍歷數組依次判斷數據的個數
        連續相等
        */
        //1.獲取用戶輸入的數據 動態的擴容數組填充數據
        Scanner scanner = new Scanner(System.in);
        int[] arr=new int[0];
        System.out.print("Enter numbers:");
        while(true){
            int num=scanner.nextInt();
            if(num==0){
                break;
            }
            //驗證用戶輸入數據的正確性
            if(num<1||num>100){
                System.out.println("有非法數據！");
                return;
            }
            arr=copyOf(arr,arr.length+1);
            arr[arr.length-1]=num;
        }
        //2.按照輸出結果 將數據中的數據進行排序
        insertSort(arr);
        //3.輸出連續相等的數字
        show(arr);
    }
    public static int[] copyOf(int[] arr,int newLen){
        int[] newArr=new int[newLen];
        for(int i=0;i<arr.length;i++){
            newArr[i]=arr[i];
        }
        return newArr;
    }
    public static void insertSort(int[] arr){
        for(int i=1;i<arr.length;i++){
            int e=arr[i];
            int j;
            for(j=i;j>0&&arr[j-1]>e;j--){
                arr[j]=arr[j-1];
            }
            arr[j]=e;
        }
    }
    /*
    Arrays Math都是屬於工具類
    Arrays 特殊的是數組的工具類
        toString(arr) 就是將數據的每個元素進行拼接 並返回拼接後的字符串數據
        "[1,2,3,4]"
    */
    public static void show(int[] arr){
        System.out.println(Arrays.toString(arr));
        //此時就將問題轉成了如何判斷連續相等的數據分別出現多少次
        //[1, 1, 1, 2, 2, 2, 3, 3, 3, 3, 3, 4, 4, 5, 5, 6]
        for(int i=0;i<arr.length;){
            int count=1;
            for(int j=i+1;j<arr.length;j++){
                if(arr[j]==arr[i]){
                    count++;
                }else{
                    break;
                }
            }
            System.out.println(arr[i]+" occurs "+count+(count>1?" times":" time"));
            i+=count;
        }
    }
}

5.2

讀題的時候，是不是發現有一些像計數排序啊

咋們有兩個思路：1.在全部輸入之後去重複

2.邊輸入邊去重複

import java.util.*;
class Demo05_02{
    public static void main(String[] args){
        /*
        思路1
            在全部輸入之後去重複 func1
        思路2
            邊輸入邊去重複 func2
        */
        // func1();
        func2();
    }
    public static void func2(){
        int[] arr=new int[0];
        Scanner scanner = new Scanner(System.in);
        System.out.print("Enter numbers:");
        for(int i=0;i<10;i++){
            int num=scanner.nextInt();
            if(!contains(arr,num)){
                arr=copyOf(arr,arr.length+1);
                arr[arr.length-1]=num;
            }
        }
        System.out.println(Arrays.toString(arr));
    }
    public static void func1(){
        //1.循環遍歷數組進行賦值
        Scanner scanner = new Scanner(System.in);
        System.out.print("Enter numbers:");
        int[] arr = new int[10];
        for(int i = 0;i < arr.length;i++){
            arr[i] = scanner.nextInt();
        }
        //2.開始對已有的數據進行去重複操作
        // 1 2 3 3 2 4 3 2 4 1
        // 1 2 3 4
        // method1(arr);        //空間S(n) 時間O(nm)
        // method2(arr);        //空間S(1) 時間O(n^2)
        // method3(arr);
    }
    public static void method3(int[] arr){
        //不創建額外空間 不許改變原先的順序
        int i=0;
        int size=arr.length;
        while(i<size){
            for(int j=i+1;j<size;){
                if(arr[j]==arr[i]){
                    for(int k=j+1;k<size;k++){
                        arr[k-1]=arr[k];
                    }
                    size--;
                }else{
                    j++;
                }
            }
            i++;
        }
        for(i=0;i<size;i++){
            System.out.print(arr[i]+" ");
        }
    }
    public static void method2(int[] arr){
        //插入排序
        for(int i=1;i<arr.length;i++){
            int e=arr[i];
            int j;
            for(j=i;j>0&&arr[j-1]>e;j--){
                arr[j]=arr[j-1];
            }
            arr[j]=e;
        }
        //連續相等
        for(int i=0;i<arr.length;){ //O(n)
            System.out.print(arr[i]+" ");
            int count=1;
            for(int j=i+1;j<arr.length;j++){
                if(arr[j]==arr[i]){
                    count++;
                }else{
                    break;
                }
            }
            i+=count;
        }
    }
    public static void method1(int[] arr){
        int[] newArr=new int[0];
        for(int i=0;i<arr.length;i++){ //O(n)
            if(!contains(newArr,arr[i])){ //O(m)
                newArr=copyOf(newArr,newArr.length+1);
                newArr[newArr.length-1]=arr[i];
            }
        }
        System.out.println(Arrays.toString(newArr));
    }
    public static boolean contains(int[] arr,int key){
        for(int i=0;i<arr.length;i++){
            if(arr[i]==key){
                return true;
            }
        }
        return false;
    }
    public static int[] copyOf(int[] arr,int newLen){
        int[] newArr=new int[newLen];
        for(int i=0;i<arr.length;i++){
            newArr[i]=arr[i];
        }
        return newArr;
    }

}

5.3

步驟：1.獲取用戶的輸入 只不過第一個輸入的數據時數據的個數(數組的長度)

2.對數組進行有序的判斷

import java.util.*;
class Demo05_03{
    public static void main(String[] args){
        //1.獲取用戶的輸入 只不過第一個輸入的數據時數據的個數(數組的長度)
        Scanner scanner=new Scanner(System.in);
        System.out.print("Enter a list:");
        int len=scanner.nextInt();//獲取的第一個數值就是數組的長度
        int[] arr=new int[len];
        for(int i=0;i<arr.length;i++){
            arr[i]=scanner.nextInt();
        }
        //2.對數組進行有序的判斷
        if(isSorted(arr)){
            System.out.println("The list is already sorted.");
        }else{
            System.out.println("The list is not sorted.");
        }
    }
    public static boolean isSorted(int[] list){
        //如果不是升序排列 那麼勢必會出現有一組數據 左大右小的情況
        for(int i=1;i<list.length;i++){
            if(list[i-1]>list[i]){
                return false;
            }
        }
        return true;
    }

}

5.4

哇，這個題看着好難啊，上面那個豆機咋們打遊戲的時候是不是經常見到啊，咋們先來說一說思路

 輸入的數據：槽子的個數 球的個數=路徑的個數
               創建槽子的具體的容器int[]
               每一個小球下落的路徑L R 字符串
               對於每一個小球而言其路徑中的步驟是隨機產生L R
    1.提示用戶輸入槽子的個數和小球的個數
    2.根據已有的槽子的個數去創建槽子容器
    3.根據已有的球和槽子的個數去隨機創建一個小球下落的路徑
    4.路徑中經過幾個釘子？路徑的步驟有幾步 和槽子的個數有關
    5.如何通過路徑的經過得知最終所落入的槽子？

import java.util.*;
class Demo05_04{
    public static void main(String[] args){
        //1.
        Scanner scanner=new Scanner(System.in);
        System.out.print("Enter the number of balls to drop:");
        int balls=scanner.nextInt();
        System.out.print("Enter the number of slots in the bean machine:");
        int slots=scanner.nextInt();
        //2.
        int[] arr=new int[slots];
        //3.幾個球幾個路徑path
        for(int i=0;i<balls;i++){
            String path=getPath(slots);
            System.out.println(path);
            //5.只要看當前路徑中R的個數即可
            arr[getR(path)]++;
        }
        //6.輸出
        System.out.println(Arrays.toString(arr));
        show(arr);
    }
    public static void show(int[] arr){
        int w=arr.length;
        int h=0;
        for(int i=0;i<arr.length;i++){
            if(arr[i]>h){
                h=arr[i];
            }
        }
        for(int i=h-1;i>=0;i--){
            for(int j=0;j<w;j++){
                if(i<arr[j]){
                    System.out.print("O");
                }else{
                    System.out.print(" ");
                }
            }
            System.out.println();
        }

    }
    public static int getR(String path){
        int count=0;
        for(int i=0;i<path.length();i++){
            if(path.charAt(i)=='R'){
                count++;
            }
        }
        return count;
    }
    public static String getPath(int slots){
        //4.根據槽子的個數計算每一個球下落的路徑
        Random random=new Random();
        String path="";
        for(int j=0;j<slots-1;j++){
            if(random.nextInt(2)==0){   //向左
                path+="L";
            }else{  //向右
                path+="R";
            }
        }
        return path;
    }
}

5.5

步驟：1.先判斷長度

2.再依次判斷元素大小

class Demo05_05{
    public static void main(String[] args){
        int[] list1={1,2,3,4,5,6,7};
        int[] list2={1,2,3,4,5,7,6};
        System.out.println(equals(list1,list2));
    }
    public static boolean equals(int[] list1,int[] list2){
        //判斷兩個數組是否完全相同
        //1.先判斷長度
        if(list1.length!=list2.length){
            return false;
        }
        //2.再依次判斷元素大小
        for(int i=0;i<list1.length;i++){
            if(list1[i]!=list2[i]){
                return false;
            }
        }
        return true;
    }
}

5.6

這就是在計數排序的基礎上加個限定條件，輸出就好

class Demo05_06{
    public static void main(String[] args){
        int[] arr={1,1,1,1,2,2,2,2,2,3,3,3,3,3,4};
        for(int i=0;i<arr.length;){
            int count=1;
            for(int j=i+1;j<arr.length;j++){
                if(arr[i]==arr[j]){
                    count++;
                }else{
                    break;
                }
            }
            if(count>=4){
                System.out.println(arr[i]);
                return;
            }
            i+=count;
        }
        System.out.println("沒有！");
    }
}

5.7

這個題你需要判斷兩個有序列表的長度相等否，不相等，在判斷哪個長，在短的那個進行+

 

 

import java.util.*;
class Demo05_07{
    public static void main(String[] args){
        int[] list1={1,3,5,7,9};
        int[] list2={2,4,6,8,10};
        System.out.println(Arrays.toString(merge(list1,list2)));
    }
    /*
    有序數組的合併
    最主要的問題在於 數組之間有長有短
    */
    public static int[] merge(int[] list1,int[] list2){
        if(list1==null&&list2==null){
            return null;
        }
        if(list1==null){
            return list2;
        }
        if(list2==null){
            return list1;
        }
        //只有兩個都不是null的情況再考慮具體操作
        int[] list3=new int[list1.length+list2.length];
        int p1=0;
        int p2=0;
        int p3=0;
        while(true){
            if(p1==list1.length&&p2==list2.length){
                break;
            }
            if(p1<list1.length&&p2==list2.length){
                list3[p3++]=list1[p1++];
            }else if(p1==list1.length&&p2<list2.length){
                list3[p3++]=list2[p2++];
            }else{
                if(list1[p1]<=list2[p2]){
                    list3[p3++]=list1[p1++];
                }else{
                    list3[p3++]=list2[p2++];
                }
            }
        }
        return list3;
    }
}

5.8遊戲：猜字遊戲，編寫一個猜字遊戲。隨機產生一個單詞，提示用戶一次猜測一個字母

import java.util.*;
class Demo05_08{
    /*
    數據 一組單詞的明文  單詞的密文  單詞的狀態
    program
    1000000 r r
    pr**r**
    */
    public static void main(String[] args){
        Scanner scanner=new Scanner(System.in);
        Random random=new Random();
        //1.創建一個單詞表
        String[] words={"naruto","kakashi","sasuke","banana","java","program"};
        //10.最後再去做多單詞猜測
        while(true){
            //2.隨機從單詞表中抽取一個單詞
            String word=words[random.nextInt(words.length)];
            //3.創建一個該單詞的狀態表 默認值是false(密文)
            boolean[] status=new boolean[word.length()];
            int miss=0; //猜錯的個數
            //4.開始猜一個單詞
            while(true){
                //5.根據單詞和狀態表 決定密文形式
                String ciphertext=getCipherText(word,status);
                //6.輸出密文並提示用戶輸入字母
                System.out.print("Enter a letter in word "+ciphertext+" >");
                char letter=scanner.nextLine().charAt(0);//"p".charAt(0)
                //7.判斷單詞中是否有該字母
                if(isContainsLetter(word,letter)){
                    //8.改變單詞狀態表 已修改/未修改 
                    //true 表示從未修改 第一次來的
                    //false 表示已修改  不是第一次來 提示已經存在
                    if(!changeWordStatus(word,status,letter)){
                        System.out.println("\t "+letter+" is already in the word");
                    }
                }else{
                    System.out.println("\t "+letter+" is not in the word");
                    miss++;
                }
                //9.是否結束
                if(isFinish(status)){
                    System.out.println("The word is "+word+". You miss "+miss+" time");
                    break;
                }
            }
            System.out.print("Do you want to guess another word?Enter y or n:");
            String choice=scanner.nextLine();
            if(choice.equals("n")){
                System.out.println("Welcome!Thank you! FUCK PROGRAM!");
                break;
            }
        }
    }
    public static boolean isFinish(boolean[] status){
        for(int i=0;i<status.length;i++){
            if(!status[i]){
                return false;
            }
        }
        return true;
    }
    public static boolean changeWordStatus(String word,boolean[] status,char letter){
        for(int i=0;i<word.length();i++){
            if(word.charAt(i)==letter){
                if(status[i]){
                    return false;   //說明已經修改
                }else{
                    status[i]=true;
                }
            }
        }
        return true;
    }
    public static boolean isContainsLetter(String word,char letter){
        for(int i=0;i<word.length();i++){
            if(word.charAt(i)==letter){
                return true;
            }
        }
        return false;
    }
    public static String getCipherText(String word,boolean[] status){
        String ciphertext="";
        for(int i=0;i<status.length;i++){
            if(status[i]){
                ciphertext+=word.charAt(i);
            }else{
                ciphertext+="*";
            }
        }
        return ciphertext;
    }
}

5.9編寫一個方法，求整數矩陣中特定列的所有元素的和，使用下面的方法頭：

步驟：1.這是一個二維矩陣，輸入是兩個[]

2.你先輸出行，在行不變的基礎上輸出列

import java.util.*;
class Demo05_09{
    public static void main(String[] args){
        /*
            累加行的時候 行不動 列動
            累加列的時候 列不動 行動
        */
        //1.輸入一個3*4的矩陣
        Scanner scanner=new Scanner(System.in);
        System.out.println("Enter numbers:");
        double[][] matrix=new double[3][4];
        for(int i=0;i<matrix.length;i++){
            for(int j=0;j<matrix[i].length;j++){
                matrix[i][j]=scanner.nextDouble();
            }
        }
        //2.打印每列的和
        for(int col=0;col<matrix[0].length;col++){
            System.out.println(sumColumn(matrix,col));
        }
    }
    public static double sumColumn(double[][] m,int col){
        double sum=0;
        for(int row=0;row<m.length;row++){
            sum+=m[row][col];
        }
        return sum;
    }
}

5.10編寫一個方法，求N*N的Double類型矩陣中主對角線上所有數字的和

主對角線上的元素，行列角標是相等的

主對角線是m[i][i];而復對角線是m[i][m.length-1-i]

class Demo05_10{
    public static void main(String[] args){
        /*
            主對角線上的元素 行列角標是相等的
        */
        int[][] m={
            {1, 2, 3, 4},
            {5, 6, 7, 8},
            {9, 10,11,12},
            {13,14,15,16}
        };
        //主對角線
        int sum=0;
        for(int i=0;i<m.length;i++){
            sum+=m[i][i];
        }
        System.out.println(sum);
        //副對角線
        int subsum=0;
        for(int i=0;i<m.length;i++){
            subsum+=m[i][m.length-1-i];
        }
        System.out.println(subsum);
        /*
        for(int i=0;i<m.length;i++){
            for(int j=0;j<m[i].length;j++){
                if(i==j){
                    sum+=m[i][j];
                }
            }
        }
        */
    }
}

5.11兩個矩陣相乘，編寫兩個矩陣相乘的方法

1 2 3        1 2    1*1+2*3+3*5   1*2+2*4+3*6
                ×    3 4  = 
        4 5 6        5 6    4*1+5*3+6*5   4*2+5*4+6*6
        對於數學上的一些運算公式 如果直接通過看計算流程還是比較麻煩的
        此時推薦使用已知公式計算！

你首先得知道他們是怎麼相乘的，兩個矩陣相乘比如，2*3的矩陣和3*3的矩陣相乘他們最後的矩陣就是2*3的

相當於取前一個矩陣的行第二個矩陣的列

class Demo05_11{
    public static void main(String[] args){
        //m*n n*p m*p 矩陣相乘 前者的列 必須等於 後者的行
        /*
      class Demo05_11{
    public static void main(String[] args){
        //m*n n*p m*p 矩陣相乘 前者的列 必須等於 後者的行
        /*
        1 2 3        1 2    1*1+2*3+3*5   1*2+2*4+3*6
                ×    3 4  = 
        4 5 6        5 6    4*1+5*3+6*5   4*2+5*4+6*6
        對於數學上的一些運算公式 如果直接通過看計算流程還是比較麻煩的
        此時推薦使用已知公式計算！
        */
        double[][] A={ //m*p
            {1,2,3},
            {4,5,6},
            {7,8,9}
        };
        double[][] B={ //p*n
            {0,2.0,4.0},
            {1,4.5,2.2},
            {1.1,4.3,5.2}
        };
        double[][] C=new double[A.length][B[0].length];//m*n
        for(int i=0;i<C.length;i++){
            for(int j=0;j<C[i].length;j++){
                double sum=0;
                for(int k=0;k<B.length;k++){
                    sum+=A[i][k]*B[k][j];
                }
                C[i][j]=sum;
                System.out.print(C[i][j]+"　");
            }
            System.out.println();
        }
    }
}
        */
        double[][] A={ //m*p
            {1,2,3},
            {4,5,6},
            {7,8,9}
        };
        double[][] B={ //p*n
            {0,2.0,4.0},
            {1,4.5,2.2},
            {1.1,4.3,5.2}
        };
        double[][] C=new double[A.length][B[0].length];//m*n
        for(int i=0;i<C.length;i++){
            for(int j=0;j<C[i].length;j++){
                double sum=0;
                for(int k=0;k<B.length;k++){
                    sum+=A[i][k]*B[k][j];
                }
                C[i][j]=sum;
                System.out.print(C[i][j]+"　");
            }
            System.out.println();
        }
    }
}

5.12

編寫程序，提示用戶輸入一個方陣的長度，隨機地在矩陣中填入0和1，打印這個矩陣，然後找出整行，整列或者對角線都是0/1的行，列，對角線

步驟：1.輸入方針的尺寸 創建方陣

2.隨機的給方陣中填入0或1

3.讓行，列，對角線累加 sum==0 sum==size 表示全相等

import java.util.*;
class Demo05_12{
    public static void main(String[] args){
        //1.輸入方針的尺寸 創建方陣
        Scanner scanner=new Scanner(System.in);
        System.out.print("Enter size:");
        int size=scanner.nextInt();
        int[][] m=new int[size][size];
        //2.隨機的給方陣中填入0或1
        Random random=new Random();
        for(int i=0;i<size;i++){
            for(int j=0;j<size;j++){
                m[i][j]=random.nextInt(2);
                System.out.print(m[i][j]+" ");
            }
            System.out.println();
        }
        //
        checkRow(m);
        checkCol(m);
        checkDiagonal(m);
        checkSubDiagonal(m);
    }
    public static void checkSubDiagonal(int[][] m){
        int sum=0;
        for(int i=0;i<m.length;i++){
            sum+=m[i][m.length-1-i];
        }
        if(sum==m.length||sum==0){
            System.out.printf("副主對角線全相等且是%d\n",sum==0?0:1);
        }
    }
    public static void checkDiagonal(int[][] m){
        int sum=0;
        for(int i=0;i<m.length;i++){
            sum+=m[i][i];
        }
        if(sum==m.length||sum==0){
            System.out.printf("主對角線全相等且是%d\n",sum==0?0:1);
        }
    }
    public static void checkRow(int[][] m){
        for(int i=0;i<m.length;i++){
            int sum=0;
            for(int j=0;j<m[i].length;j++){
                sum+=m[i][j];
            }
            if(sum==m.length||sum==0){
                System.out.printf("第%d行全相等且是%d\n",i+1,sum==0?0:1);
            }
        }
    }

5.13編寫下面的方法，測試一個二維數組是否有四個連續的數字具有相同的值，這四個數可以是水平方向

先讀題，可以知道到3那個位置，所以咋們要-4，所以這個-4只是針對本題的，他並不是固定的

import java.util.*;
class Demo05_13{
    public static void main(String[] args){
        Scanner scanner=new Scanner(System.in);
        System.out.print("Enter row ,col:");
        int row=scanner.nextInt();
        int col=scanner.nextInt();
        int[][] m=new int[row][col];
        for(int i=0;i<row;i++){
            for(int j=0;j<col;j++){
                m[i][j]=scanner.nextInt();
            }
        }
        System.out.println(isConsecutiveFour(m));
    }
    public static boolean isConsecutiveFour(int[][] m){
        for(int i=0;i<m.length;i++){
            for(int j=0;j<m[i].length;j++){
                //向右
                if(j<=m[i].length-4){
                    boolean flag=true;
                    for(int c=j+1;c<=j+3;c++){
                        if(m[i][j]!=m[i][c]){
                            flag=false;
                            break;
                        }
                    }
                    if(flag){
                        return true;
                    }
                }
                //向下
                if(i<=m.length-4){
                    boolean flag=true;
                    for(int r=i+1;r<=i+3;r++){
                        if(m[i][j]!=m[r][j]){
                            flag=false;
                            break;
                        }
                    }
                    if(flag){
                        return true;
                    }
                }
                //向右下
                if(i<=m.length-4&&j<=m[0].length-4){
                    boolean flag=true;
                    for(int r=i+1,c=j+1;r<=i+3;r++,c++){
                        if(m[i][j]!=m[r][c]){
                            flag=false;
                            break;
                        }
                    }
                    if(flag){
                        return true;
                    }
                }
                //向右上
                if(i>=3&&j<=m[0].length-4){
                    boolean flag=true;
                    for(int r=i-1,c=j+1;c<=j+3;r--,c++){
                        if(m[i][j]!=m[r][c]){
                            flag=false;
                            break;
                        }
                    }
                    if(flag){
                        return true;
                    }
                }
            }
        }
        return false;//四個方向都沒有連續的
    }
}

5.15五子棋

咋們來做一個簡單的五子棋

import java.util.*;
class Demo05_15{
    /* 
    五子棋 黑白棋 誰先連成5個子 誰就贏
    棋盤 我們用什麼去表示棋盤
    +++++++
    +++++++
    +++++++
    那也就是說我們需要創建一個String的二維數組來表示棋盤
    如何下棋呢？
    目前我們的程序是控制檯程序，不能說是用點擊的方式進行下棋
    只能是輸入棋子的座標進行下棋
    輸入 1,1 指的就是在(0,0)處下一個棋子
    
    初始化棋盤 initBoard()
    打印棋盤   printBoard()
    開始遊戲   startGame()
    下棋(黑白) putDownChess()
    判斷輸贏   isGameOver()
    上述方法都會去調用棋盤board數據 
    如果每次講board當做參數傳遞個函數的時候 會顯得比較麻煩
    我們可以將board數據定義爲全局變量 任何函數都可以訪問的變量
    全局變量定義在函數的外面 類的裏面 必須public static開頭
    */

    //全局變量 棋盤 方便函數直接調用 而不需要依次傳參
    public static String[][] board; //定義爲是15*15的棋盤
    public static String BLACK_CHESS="O";   //黑棋
    public static String WHITE_CHESS="X";   //白棋
    public static Scanner scanner=new Scanner(System.in);

    public static void main(String[] args){
        //1.初始化棋盤
        initBoard();
        //2.打印棋盤
        printBoard();
        //3.開始遊戲
        startGame();
    }
    public static void startGame(){
        /*
        黑方 白方 輪流 下棋 
        */
        int player=0;   //player 偶數 黑 ；奇數 白
        while(true){
            if(player%2==0){    //黑方下棋
                System.out.print(">>>請黑方下棋:");
                if(!putDownChess(BLACK_CHESS)){
                    continue;
                }
            }else{              //白方下棋
                System.out.print(">>>請白方下棋:");
                if(!putDownChess(WHITE_CHESS)){
                    continue;
                }
            }
            if(isGameOver()){
                break;
            }
            player++;
        }
    }
    public static boolean isGameOver(){
        //你們自己寫吧 我寫過了 注意和棋的情況
        return false;
    }
    public static boolean putDownChess(String chess){
        //用戶輸入的 (1,1) -> (0,0)
        //1 B
        int x=scanner.nextInt()-1;
        int y=scanner.next().charAt(0)-'A';
        if(!board[x][y].equals("+")){
            System.out.println(">>>此處已有棋子，請重新下棋");
            //另外一種處理方式 就是講player定義爲全局 此處player--即可
            return false;//意味着下棋不成功
        }
        board[x][y]=chess;
        printBoard();
        return true;    //意味着下棋成功
    }
    public static void printBoard(){
        System.out.print("   ");
        for(int i=0;i<=14;i++){
            System.out.print((char)('A'+i)+" ");
        }
        System.out.println();
        for(int i=0;i<board.length;i++){
            System.out.printf("%2d ",i+1);
            for(int j=0;j<board[i].length;j++){
               System.out.print(board[i][j]+" ");
            }
            System.out.println();
        }
    }
    public static void initBoard(){
        board=new String[15][15];
        for(int i=0;i<board.length;i++){
            for(int j=0;j<board[i].length;j++){
                board[i][j]="+";
            }
        }
    }
}