java学习笔记第三章

三、数组 & 常用类

数组Array基本概念：

一维数组、二维数组、多维数组

数组是相同数据类型（可以为任意类型数据）的有序集合，通过索引来引用

数组也是对象；数组元素相当于对象的成员变量

数组长度是确定的，不可变的；如果越界，则报ArrayIndexOutOfBonnd

 

数组有三个特点：

1.其长度是确定的，数组一旦被创建，它的大小是不可改变的

2.其元素必须是相同类型，不允许出现混合类型

3.数组中的元素可以是任何数据类型，包含基本类型和引用类型

eg：int[] a = new int[3]; 3是数组长度；a[0] 、a[1] 、 a[2]

 

Car.java
public class Car {
    String name;
    
    public Car(String name){
        this.name=  name;
    }
}

Test01.java
public class Test01 {
    public static void main(String[] args) {
        /**
         * 1. 数组是相同数据类型(数据类型可以为任意类型)的有序集合
         * 2. 数组也是对象。数组元素相当于对象的成员变量(详情请见内存图)
         * 3. 数组长度的确定的，不可变的。如果越界，则报：ArrayIndexOutofBoundsException
         */
        int[] a = new int[3];
        a[0] = 23;
        a[1] = 28;
        a[2] = 32;

        Car[] cars = new Car[4];
        cars[0] = new Car("奔驰");
        System.out.println(a.length); 
        for(int i=0;i<a.length;i++){
            System.out.println(a[i]);
        }
        
    }
}

 

数组声明和初始化：

一维数组的声明方式有两种：

type[] 变量名;

type 变量名[];

eg: int[] a; int b[];

通过new来创建数组： int[] a = new int[3];

初始化：对数组元素初始化，数组元素相当于对象的成员变量，按照成员变量的规则初始化

1.默认初始化： 默认值跟成员变量的规则一样：数字，整数：0，浮点数0.0，char \u0000，布尔型 0false

2.动态初始化： a[0]=1;for循环赋值 或 用容器来放，大部分容器底层实现是数组

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

　　a[i] = i*12;

}

3.静态初始化：  int c[] = {23,34,56,78};  //长度4，索引范围0-3

public class Test02 {
    public static void main(String[] args) {
        //声明
        int[] a;
        int b[];
        //创建数组对象
        a = new int[4];
        b = new int[5];
        
        //初始化(对数组元素的初始化)
        //默认初始化：数组元素相当于对象的成员变量，默认值跟成员变量的规则一样。数字0，布尔false,char\u0000,引用：null
        //动态初始化：
        for(int i=0;i<a.length;i++){
            a[i] = i*12;
        }
        
        //静态初始化
        int c[] = {23,43,56,78};   //长度：4，索引范围：[0,3]
        Car[] cars = {
                        new Car("奔驰"),
                        new Car("比亚迪"),
                        new Car("宝马")
                    };
        Car c2 = new Car("奔驰");
        System.out.println(c2==cars[0]);    
    }
}

 

操作对象就是操作引用，引用是地址；数组属于引用类型

 

二维数组：

int[][] a = {{1,2},{3,4,0,9},{5,6,7}};         

二维数组理解参考表格

public class Test01 {
    public static void main(String[] args) {
//        int [][] a = {
//                        {1,2},
//                        {3,4,0,9},
//                        {5,6,7}
//                    };
        
        int[][]  a = new int[3][];
        a[0] = new int[2];
        a[1] = new int[4];
        a[2] = new int[3];
        
        a[0][0] = 1;
        a[0][1] = 2;
        
        a[1][0] = 3;
        a[1][1] = 4;
        a[1][2] = 0;
        a[1][3] = 9;
        
        a[2][0] = 5;
        a[2][1] = 6;
        a[2][2] = 7;
        
        System.out.println(a[2][2]);
    }
}

public class Matrix {
    
    /**
     * 打印指定的矩阵
     * @param c
     */
    public static void print(int[][] c){
        //打印矩阵
        for(int i=0;i<c.length;i++){
            for(int j=0;j<c.length;j++){
                System.out.print(c[i][j]+"\t");
            }
            System.out.println();
        }
    }
    
    /**
     * 矩阵加法
     * @param a
     * @param b
     * @return
     */
    public static int[][]  add(int[][] a,int[][] b){
        int[][] c = new int[a.length][a.length];
        for(int i=0;i<c.length;i++){
            for(int j=0;j<c.length;j++){
                c[i][j] = a[i][j]+b[i][j];
            }
        }
        return c;
    }
    
    public static void main(String[] args) {
        int[][]  a = {
                        {1,3,3},
                        {2,4,7},
                        {6,4,9}
                     };
        int[][]  b = {
                {3,3,3},
                {2,4,7},
                {1,4,9}
        };
        
        int[][] c = add(a, b);
        
        print(c);
        
    }
}

 ===============================常用类===============================

String类： 不可变字符序列

StringBuilder类/StringBuffer类： 可变字符序列；同属于抽象类AbstractStringBuilder下的两个类

StringBuilder类，线程不安全，效率高;

StringBuffer类，线程安全，效率低； 

 

根据StringBuilder字符数组，diy，定义数组类，模拟ArrayList

StringBuilder； char[] value;  

MyArrayList  ;   Object[] elements;

天下文章一大抄，主要是想象力，创新（反复的类比，模仿，并创造）