学Java的第6天

数组

• 数组是相同类型的数据的有序集合
• 其中每一个数据称作数组元素，每个数组元素可以通过下标访问他们

数组的声明创建

声明数组变量的语法：

dataType[] arrayRefVar;//首选方法
或
dataType arrayRefVar[];//效果相同，非首选方法

Java语言使用new关键字来创建数组，语法如下：

dataType[] arrayRefVar = new dataType[arraySize];

数组的元素通过索引（下标）来访问，从0开始
获取数组长度： array.length
在栈中声明，new在堆中开辟空间

数组初始化

静态初始化：

int[] a = {1,2,3};

动态初始化：

int[] a = new int[2];
a[0]=1;
a[1]=2;
a[2]=3;

赋值一个元素后，其他元素隐式赋值，默认值为0。

数组的四个基本特点

1. 长度确定，一旦被创建，大小无法改变
2. 元素类型必须相同，不能出现混合类型
3. 元素可以是任何类型，包括基本类型和引用类型
4. 数组变量属于引用类型，可以看成是对象，元素相当于对象的成员变量

数组的边界

0 ~ 数组长度-1 下标越界异常： java.lang.ArrayIndexOutOfBoundsException

数组的使用

普通for循环遍历数组 for……each遍历数组

多维数组

二维数组：

int[][] a = new int[2][5];

二维数组相当于一个一维数组，它的每个元素也是一个一维数组

int[][] a = {{1,2},{1,2,3},{1}};

二维数组的遍历：

int[][] a = {{1, 2}, {1, 2, 3}, {1}};
    for (int[] x : a
    ) {
        for (int b : x
        ) {
            System.out.println(b);
        }
    }

三维数组就是每个元素都是一个二维数组……套娃

Arrays类

toString

Arrays.toString() 打印数组元素

sort

Arrays.sort() 升序排序

fill

Arrays.fill(数组对象,值) Arrays.fill(数组对象,起始索引,结束索引,值) 填充元素赋值

equals

比较数组

binarySearch

对排序好的数组进行二分查找

八大排序

详情见我写的另一篇文章八大排序算法

稀疏数组

当一个数组大部分元素为0或同一个值时，可以使用稀疏数组来保存
稀疏数组的处理方式：

1. 记录有几行几列有几个不同值
2. 记录不同值的索引和具体值

案例：假设有个11*11的棋盘，只有某几个位置有棋子

public class SparseArray {
    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[] x : a) {
            for (int i : x) {
                System.out.print(i + "\t");
            }
            System.out.println();
        }
 
        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;
 
        //遍历二维数组，将非0的值存放到稀疏数组
        int count = 0;
        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j < a[i].length; j++) {
                if (a[i][j] != 0){
                    count++;
                    b[count][0] = i;
                    b[count][1] = j;
                    b[count][2] = a[i][j];
                }
            }
        }
        System.out.println("稀疏数组为：");
        for (int i = 0; i < b.length; i++) {
            System.out.println(b[i][0] + "\t" + b[i][1] + "\t" + b[i][2] + "\t");
        }
 
        System.out.println("=============================");
        System.out.println("还原数组:");
 
        //读取稀疏数组
        int[][] c = new int[b[0][0]][b[0][1]];
 
        //还原数组的值
        for (int i = 1; i <b.length ; i++) {
            c[b[i][0]][b[i][1]] = b[i][2];
        }
        System.out.println("还原数组为：");
        for (int[] i: c) {
            for (int j:i) {
                System.out.print(j + "\t");
            }
            System.out.println();
        }
 
    }
}

面向对象编程

什么是面向对象

• 面向对象编程(Object-Oriented Programming, OOP)

• 面向对象编程的本质就是:以类的方式组织代码，以对象的组织(封装)数据。

• 抽象

• 三大特性：

  • 封装
  • 继承
  • 多态

• 从认识论角度考虑是先有对象后有类。对象，是具体的事物。类，是抽象的，是对对象的抽象

• 从代码运行角度考虑是先有类后有对象。类是对象的模板。

方法回顾

静态方法

用static修饰的方法
可以直接用 类名.方法名() 调用

非静态方法

没有用static修饰的方法
需要先实例化对象才能调用

GirlFriend gl = new GirlFriend();
gl.eat();

创建与初始化对象

使用new关键字创建对象，除了分配内存空间外还会给创建好的对象进行初始化以及对类中的构造方法的调用。
构造方法的特点：

1. 必须和类的名字相同
2. 必须没有返回类型，也不能写void

什么都不写的时候，默认会提供一个无参构造方法。
一个类可以有多个构造方法。构造方法也能重载。
构造方法相当于给对象初始化的时候赋予对象初始值。
快捷键Alt + Insert创建构造方法。

创建对象内存分析

在栈中的保存的是对象的引用变量名，真正的对象在堆中，根据类为模板生成对象，根据构造方法给对象赋予初始属性。