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

野子發表於2020-12-11

陣列

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關鍵字

相關文章