Java学习笔记-数组

01-数组的声明和创建

---

概念

相同类型数据的有序集合，其实数组就是一个容器

声明数组

• 要使用Java的数组，必须经过两个步骤：
  • 声明数组变量
  • 创建数组：分配内存给这个数组
• 声明数组变量的语法：

元素类型[] 数组名;  // 建议使用的方式
元素类型 数组名[];  // 效果相同，这种风格类似 C/C++ 语言

创建数组

数组名 = new 元素类型[元素的个数];

• 数组的动态初始化

元素类型 数组名[] = new 元素类型[元素的个数];

02-数组的初始化

---

• 静态初始化

在数组声明的同时完成初始化操作，不用new关键字

//可简化为int[] array1 = {1，2，3，4，5}
int[] array1 = new int[]{1,2,3,4,5};  
Integer[] array2 = {new Integer(),new Integer()};

• 动态初始化

先使用new关键字创建数组，然后再进行赋值

int[] array = new int[5];
array[0] = 1; //未赋值的默认初始化为0，字符类型初始化为null

03-数组的基本特点

---

• 数组的长度是确定的，一旦创建长度就不能改变
• 元素必须是相同类型
• 数组元素可以是基本类型或者引用类型
• 数组变量是引用类型时，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量
• 数组越界报错：ArrayIndexOutOfBoundsException

数组的反转

//反转数组
public static int[] reverse(int[] array){
    int[] result = new int[array.length];
    for (int i = 0,j=array.length-1; i < array.length; i++,j--) {
        result[j]=array[i];
    }
    return result;
}

04-二维数组

定义格式

• int[][] arr = new int[2][3];

  —定义一个整型的二维数组，其中包含2个一维数组，每个一维数组可以存储3个整数

• arr[0] —下标为0的位置上的一维数组

• arr[1][3] —如果要获取具体的元素需要两个下标

二维数组的反转

for(int start = 0, end = array.length -1; start < end; start++,end--){
	int[] temp = array[start];
	array[start] = array[end];
	array[end] = temp;
}

冒泡排序

/**
* 冒泡排序
* 1.比较数组中相邻的两个元素，如果第一个比第二个大，就交换位置
* 2.对每一对相邻元素做同样的操作，从第一对到最后一对，最后的数字就会是最大的数
* 3.针对所有的元素重复以上的操作，除了最后一个
* 4.持续每次对越来越少的元素执行以上的操作，直到没有任何一对数字需要比较
*/
public static int[] sort(int[] array) {
    int temp = 0;
    for (int i = 0; i < array.length-1; i++) {
        for (int j = 0; j < array.length-1-i; j++) {
            if (array[j]>array[j+1]) {
                temp = array[j+1];
                array[j+1] = array[j];
                array[j] = temp;
            }
        }
    }
    return array;
}

稀疏数组

//创建一个二维数组5*5
int[][] array = new int[5][5];
array[0][1] = 1;
array[1][2] = 2;
//输出原始的数组
System.out.println("输出原始的数组：");
for (int[] ints : array) {
    for (int anInt : ints) {
        System.out.print(anInt+"\t");
    }
    System.out.println();
}

System.out.println("=============");
//转化为稀疏数组保存
//获取有效值的个数
int sum = 0;
for (int i = 0; i < array.length; i++) {
    for (int j = 0; j < array.length; j++) {
        if (array[i][j] != 0) {
            sum++;
        }
    }
}
System.out.println("有效值的个数是："+sum);

System.out.println("=============");
//创建一个稀疏数组的数组
int[][] array1 = new int[sum+1][3];
array1[0][0] = 5;
array1[0][1] = 5;
array1[0][2] = sum;
//遍历二维数组，将非0的值放在稀疏数组中
int count = 0;
for (int i = 0; i < array.length; i++) {
    for (int j = 0; j < array[i].length; j++) {
        if (array[i][j] != 0) {
            count++;
            array1[count][0] = i;
            array1[count][1] = j;
            array1[count][2] = array[i][j];
        }
    }
}

//输出稀疏数组
System.out.println("稀疏数组");
for (int i = 0; i < array1.length; i++) {
    System.out.println(array1[i][0]+"\t"+array1[i][1]+"\t"+array1[i][2]+"\t");
}

System.out.println("=============");
//还原稀疏数组
//1.读取稀疏数组
int[][] array2 = new int[array1[0][0]][array1[0][1]];
//2.给其中的元素还原它的值
for (int i = 1; i < array1.length; i++) {
    array2[array1[i][0]][array1[i][1]] = array1[i][2];
}
//打印
System.out.println("输出还原的数组：");
for (int[] ints : array2) {
    for (int anInt : ints) {
        System.out.print(anInt+"\t");
    }
    System.out.println();
}