java day6 java陣列2與物件導向1

野子發表於2020-12-11
Java陣列物件

陣列

1.陣列的Arrays類

//陣列的工具類java.util.Arrays

API提供了一個Arrays供我們使用，對資料物件進行一種基本的操作

具有以下常用功能：

  1. 給陣列賦值：fill方法
  2. 對陣列排序：sort方法升序
  3. 比較陣列：equals方法比較陣列中元素是否相等
  4. 查詢陣列元素：binarySearch對排序好的陣列進行二分查詢

程式碼示例：

        int[] a = {6,4,8,2,9,45,21};
        int[] b = {50, 50, 50, 50, 50, 50, 50};
        System.out.println(Arrays.toString(a));//列印陣列元素
        Arrays.sort(a);//排序升序
        System.out.println(Arrays.toString(a));
        System.out.println(Arrays.binarySearch(a,8));//查詢
        Arrays.fill(a,50);//全部賦值
        System.out.println(Arrays.toString(a));
        System.out.println(Arrays.equals(a,b));//判斷陣列是否完全相等

除此之外，開啟JDK幫助文件，搜尋Arrays可以看到更多方法

點選跳轉到JDK幫助文件
在這裡插入圖片描述

在這裡插入圖片描述

排序：總共有八大排序

1、氣泡排序

外層冒泡輪數，內層一次比較

時間複雜度為O（n*n）

程式碼：

    public static void main(String[] args) {
        int[] a = {4,2,1,87,54,90,65,43,23,44,65,78,54};
        System.out.println(a.length);
        sort(a);
        System.out.println(Arrays.toString(a));
    }
    //氣泡排序
    //1、比較陣列中兩個相鄰的元素，如果第一個數大於第二個數，則交換兩數
    //2、每一次比較都會產生一個最大或最小的數
    //3、下一輪則可以減少一次排序
    //4、依次迴圈，直到結束
    public static void sort(int[] a){
        int t = 0;
        for (int i = 0; i < a.length - 1; i++) {
            for (int j = 0; j < a.length - 1 - i; j++) {
                if(a[j]>a[j+1]){
                    t = a[j+1];
                    a[j+1] = a[j];
                    a[j] = t;
                }
            }
        }

    }

輸出結果：

13
[1, 2, 4, 23, 43, 44, 54, 54, 65, 65, 78, 87, 90]

思考：如何優化？

2、稀疏陣列

1、需求

編寫五子棋遊戲中，有存檔退出和續上盤的功能

分析：該二維陣列很多預設值是0，記錄了很多沒有意義的資料

解決：稀疏陣列

稀疏陣列介紹：

1、一個陣列中大部分元素為0，或者為同一值的陣列，可以使用稀疏陣列來儲存該陣列

2、處理方式：記錄陣列幾行幾列，多少個不同值

3、把具有不同的元素和行列及值記錄在一個小規模陣列中，從而縮小程式的規模

程式碼實現：

//稀疏陣列
public class ArrayDemo08 {
    public static void main(String[] args) {
        //建立一個二維陣列11*11 0：無棋子  1：黑棋  2：白棋
        int[][] a = new int[11][11];
        a[1][2] = 1;
        a[2][3] = 2;
        //輸出原始陣列
        System.out.println("輸出原始陣列");
        for (int i = 0; i < a.length; i++) {
            for (int i1 = 0; i1 < a.length; i1++) {
                System.out.print(a[i][i1]+"\t");
            }
            System.out.println();
        }
        //轉化為稀疏陣列
        //獲取有效值的個數
        int sum = 0;
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if(a[i][j]!=0){
                    sum++;
                }

            }
        }
        System.out.println("有效值的個數"+sum);
        //建立一個稀疏陣列的陣列
        int[][] b = new int[sum+1][3];
        b[0][0] = 11;
        b[0][1] = 11;
        b[0][2] = sum;
        //遍歷二維陣列，將非零的值存放到稀疏陣列中
        int m = 1;
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if(a[i][j]!=0){
                    b[m][0] = i;
                    b[m][1] = j;
                    b[m][2] = a[i][j];
                    m++;
                }

            }
        }
        for (int i = 0; i < b.length; i++) {
            for (int i1 = 0; i1 < b.length; i1++) {
                System.out.print(b[i][i1]+"\t");
            }
            System.out.println();
        }
        //還原稀疏陣列
        int[][] c = new int[b[0][0]][b[0][1]];
        int n = 1;
        for (int i = 0; i < m-1; i++) {
            c[b[n][0]][b[n][1]] = b[n][2];
            n++;
        }
        for (int i = 0; i < c.length; i++) {
            for (int i1 = 0; i1 < c.length; i1++) {
                System.out.print(c[i][i1] + "\t");
            }
            System.out.println();
        }
    }
}

輸出結果：

輸出原始陣列
0	0	0	0	0	0	0	0	0	0	0	
0	0	1	0	0	0	0	0	0	0	0	
0	0	0	2	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
有效值的個數2
11	11	2	
1	2	1	
2	3	2	
0	0	0	0	0	0	0	0	0	0	0	
0	0	1	0	0	0	0	0	0	0	0	
0	0	0	2	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0

分析：程式碼實現將原始陣列轉化為稀疏陣列，稀疏陣列第一列儲存行，第二列儲存列，第三列儲存有效值

第一行是總的行列與有效值個數，其他是各個有效值所在的位置及有效值的值

物件導向程式設計（OOP）

1、初識物件導向

程式導向與物件導向

程式導向思想：

  1. 步驟清晰簡單，第一步做什麼，第二部做什麼
  2. 程式導向適合處理一些較為簡單的問題
  3. 物件導向思想：物以類聚，分類的思維模式，思考問題首先會解決問題需要哪些分類，然後對分類進行獨立思考。最後才對分類下的細節進行程式導向思考。物件導向適合處理複雜的問題，適合處理多人協作的問題
  4. 屬性+方法=類
  5. 對於描述複雜的事物，為了從巨集觀上把握，從整體上合理分析，我們需要使用物件導向的思路來分析整個系統，但是，具體到微觀操作，仍然需要程式導向的思路去處理
//方法在類裡面，Demo01就是一個類，用class修飾
//一個真正的程式裡面只有一個main方法
//return代表方法結束，返回一個結果，可能為空，也可能是其他型別

什麼是物件導向：

  1. 物件導向程式設計（Object Oriented Programming）

  2. 本質：以類的方式組織程式碼，以物件的形式封裝資料

  3. 抽象：

三大特性：

  1. 封裝：將資料包起來，不暴露。留一個介面給外部訪問

  2. 繼承：子類得到父類的東西

  3. 多型：同一個事物有多重形態

2、方法回顧和加深

方法的定義

  1. 修飾符：public，static等等

  2. 返回型別

    break：跳出switch，結束迴圈

    return：代表方法結束

  3. 方法名：符合命名規範 見名知意

  4. 引數列表：引數型別，引數名，引數個數

  5. 異常丟擲

    像之前的xception in thread “main” java.lang.ArrayIndexOutOfBoundsException: 11 at com.wangchaohong.array.ArrayDemo01.main(ArrayDemo01.java:17)

    陣列越界異常

  6. 方法的呼叫：遞迴，自己呼叫自己

  7. 非靜態方法

    static與類一起載入的//修飾符有static的可以直接呼叫
    類例項化之後才存在

    先有物件後有類

            Demo03 demo03 = new Demo03();
        int sum = demo03.add(2,3);//非靜態方法呼叫，new一個物件，2，3為實參
        System.out.println(sum);
    }
    public int add(int a, int b){//形參

        return a+b;
    }

    //靜態方法，加static，非靜態方法不加static
public class Demo02 {
    public static void main(String[] args) {
        //例項化這個物件
        //物件型別 物件名
        Student student = new Student();
        student.say();                  
    }
    //static與類一起載入的
    //類例項化之後才存在
    //a與b不加static無法相互呼叫，當new了物件可以呼叫
    public void a(){

    }
    public void b(){

    }
}

    我認為類進行例項化就是物件，相當於結構體與結構體變數

  8. 形參和實參

  9. 值傳遞和引用傳遞

    值傳遞：輸出a的值沒有發生改變

    package com.oop;
//值傳遞
public class Demo04 {
    public static void main(String[] args) {
        int a = 5;
        System.out.println(a);
    }

    public static void change(int a){

        a = 10;//沒有返回值
    }
}

    引用傳遞：

    //引用傳遞：物件，本質還是值傳遞
public class Demo05 {//一個類裡只能有一個public class
    public static void main(String[] args) {
           Person person = new Person();
        System.out.println(person.name);
        change(person);
        System.out.println(person.name);
    }
    public static void change(Person person){//傳遞物件改變了其值，傳遞的是地址
        person.name = "wangchaohong";//改變了其值，一個具體的人可以改變屬性
    }

}
class Person {//定義一個person類，下面的一個屬性
    String name;//null
}
//陣列的工具類java.util.Arrays

    感覺值傳遞與引用就像是隻傳遞值和傳遞了地址

  10. this關鍵字

相關文章