java数组
-
数组是相同类型数据的有序集合。
-
数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成。
-
其中，每一个数据称作一个数组元素，每个数组元素可以通过一个下标来访问它们。
数组声明创建
-
首先必须声明数组变量，才能在程序中使用数组。下面是声明数组变量的语句：
数据类型[] 数组名; // 首选的方法 或 数据类型 数组名[]; // 效果相同，但不是首选项方法
-
数组的元素是通过索引访问的，数组索引从0开始。
-
获取数组长度：arrays.length
数组初始化：
在内存中创建一个数组，并且向其中赋予一些默认值。
两种常见的初始化方式：
1.动态初始化（指定长度）
2.静态初始化（指定内容）
动态初始化数组的格式：
数据类型[] 数组名称 = new 数据类型[数组长度];
静态舒适化数组的格式：
数据类型[] 数据名称 = new 数据类型[] {元素1,2,3……}
注：静态初始化数组的长度根据{}中的元素各数决定
访问数组元素的格式：数组名称[索引值] (ins[3])
注：索引值从0开始，一直到”数组的长度-1“ 为止。
数组一旦创建，程序运行期间，长度不可改变。
使用动态初始化数组的时候，元素拥有默认值，规则如下：
整数型 0;
浮点型 0.0;
字符型 '/u0000'; // 不可见
布尔型 false;
引用型 null;
注：起始静态初始化也有默认值只是，系统自动将其替换为{}中的内容
栈和堆
-
java 的内存需要划分成为5个部分
-
栈（Stack）：存放的都是方法中的变量。方法的运行一定要在栈当中运行。 局部变量：方法的参数，或者是方法{}内部的变量。 作用域：一旦超出作用域，立刻从栈内存当中消失。
-
堆（Heap）：凡是new出来的东西，都在堆当中。
堆内存里面的东西都有一个内存地址值：16进制， 堆内存里面的数据都有默认值。规则： 整数型 0; 浮点型 0.0; 字符型 '/u0000'; 布尔型 false; 引用型 null;
-
方法区（Method Area）：存储.class相关信息，包括方法的信息。
-
本地方法栈（Native Method Stack）：与操作系统相关。
-
寄存器（PC Register）：与CPU相关
注：方法区中存放的是方法（public static void main(String[] args) ），但要真正的运行要把方法中的信息加载到栈，并且单独为信息(main(String[] args)) 开辟一个单独的内存空间，这个过程叫做“进栈”。栈中的变量（int[] arrayG）通过堆中new出来的代码（new int[4];）的内存地址进行索引。
数组的四个基本特点
-
其长度是确定的。数组一旦被创建，它的大小就是不可以改变的。
-
其元素必须是相同类型，不允许出现混合类型。
-
数组中的元素可以是任何数据类型，包括基本类型和引用类型。
-
数组白能量属于引用类型，数组也可以看成是对象，数组中的每个元素相当于改对象的成员变量。
数组本身就是对是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中的。
多维数组
多维数组可以看成是数组的数组，比如二维数组就是一个特殊的一维数组，其每一个元素都是一个一维数组。 例如：
int[][] arrays= new int[2][5];
// 解析：以上二维数组可以看成是一个两行五列的数组。
// 遍历所有子元素
int[][] arrays= {{1,2},{3,4},{5,6},{7,8}};
for (int i = 0; i < arrays.length; i++) {
for (int j = 0; j <arrays[i].length; j++) {
System.out.println(arrays[i][j]);
}
}
Arrays 类
-
数组的工具类java.util.Arrays .
-
由于数组对象本身并没有什么方法可以供我们调用，但API中提供了一个工具类Arrays供我们使用，从而可以对数据对象进行一些基本的操作。
-
查看JDK帮助文档。
-
Arrays 类中的方法都是static修饰的静态方法，在使用的时候可以直接使用类名进行调用，儿“不用”使用对象来调用（注意：不是“不能”。）
具有以下功能：
-
给数组赋值：通过 fill 方法。
-
对数组排序：通过 sort 方法,按升序。
-
比较数组：通过 equals 方法比较数组中元素值是否相等。
-
查找数组元素：通过 binarySearch 方法能对排序好的数组进行二分查找法操作。
int[] a = {2,4,5,778,3,32,5};
int[] b = {2,4,5,778,4,32,5};
Arrays.sort(a);// 数组进行排序：升序
System.out.println(Arrays.toString(a));
// [2, 3, 4, 5, 5, 32, 778]
Arrays.fill(a,2,4,0); // 下标为 [2]到[4] 区间的被 0 替换
System.out.println(Arrays.toString(a));
// [2, 3, 0, 0, 5, 32, 778]
Arrays.fill(a,0); // 全部替换为 0
System.out.println(Arrays.toString(a));
// [0, 0, 0, 0, 0, 0, 0]
System.out.println(Arrays.equals(a,b)); // 判断两个数组的数据类型，返回值 布尔型
System.out.println(Arrays.binarySearch(b,5)); // 通过key查找到元素下标
冒泡排序
-
冒泡排序是最为出名的排序算法之一，总共有八大排序
-
java 代码实现：
public static void main(String[] args) {
int[] c = {6, 3, 1, 8, 4, 9, 2, 0};
int[] mao = mao(c);
System.out.println(Arrays.toString(mao));
}
public static int[] mao(int[] array) {
// 外层循环控制程序走多少次
int tmp = 0;
for (int i = 0; i < array.length - 1; i++) {
boolean falg = false; // 通过flag标志位减少没有意义的比较，优化代码
// 内层循环比大小,比较判断两个数，如果第一个数，比第二个数大/小则交换位置
for (int j = 0; j < array.length - 1 - i; j++) {
// "-i" 是第i次之后，已经产生了i个最大或最小值，不需要再进行比较
if (array[j + 1] < array[j]) {
tmp = array[j];
array[j] = array[j + 1];
array[j + 1] = tmp;
falg = true;
}
}
if (falg == false) {
break;
}
}
return array;
}
稀疏数组
-
-
为什么要进行压缩？
-由于稀疏矩阵中存在大量的“空”值，占据了大量的存储空间，而真正有用的数据却少之又少
-且在计算时浪费资源，所以要进行压缩存储以节省存储空间和计算方便。
public static void main(String[] args) {
int[][] a = new int[10][11];
a[2][3] = 5;
a[3][4] = 7;
a[4][6] = 3;
for (int[] ints : a) {
for (int anInt : ints) {
System.out.print(anInt);
}
System.out.println();
}
/*
00000000000
00000000000
00050000000
00007000000
00000030000
00000000000
00000000000
00000000000
00000000000
00000000000
*/
System.out.println("-----》 二维数组转稀疏数组");
int sum = 0;
for (int i = 0; i < a.length; i++) {
for (int j = 0; j < a.length; j++) {
if (a[i][j] != 0) {
sum++;
}
}
}
// 创建稀疏数组
int[][] ints = new int[sum+1][3];
// 给稀疏数组赋值
ints[0][0] = 10;
ints[0][1] = 11;
ints[0][2] = sum;
// 将非零的数放入数
// count 标记第几个数非零
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++;
ints[count][0] = i;
ints[count][1] = j;
ints[count][2] = a[i][j];
}
}
}
for (int i = 0; i <