- Java 数组
- 一维数组
- 多维数组
- Arrays类
- 数组和字符串的转换处理
- 稀疏数组
- 定义
- 转化
- 还原
- 动态扩容
- 存储固定数量的同类型元素的有序集合（任意类型）
- 数组也是对象，数组元素相当于对象的成员变量，存放在堆中
- 长度确定，不可变
声明数组
变量类型[] 变量名;(首选) 或 变量类型 变量名[]; int[] a; //首选 int a[];
创建数组
变量类型[] 变量名 = new 变量类型[数组长度];
变量类型[] 变量名 = {value0, value1,value2......}
//数组的元素是通过索引访问的。数组索引从 0 开始，所以索引值从 0 到 array.length-1。
- 数组的元素类型和数组的大小都是确定的
- 处理数组元素时通常使用基本循环或者 For-Each 循环
//for-each循环
double[] myList = {1.9, 2.9, 3.4, 3.5};
for (double e: myList) {
System.out.print(e + "、"); // 打印所有数组元素
}
//运行结果：1.9、2.9、3.4、3.5
//数组可以作为参数传递给方法
public static void printArray(int[] array) {
for (int i = 0; i < array.length; i++) {
System.out.print(array[i] + " ");
}
}
printArray(new int[]{3, 1, 2, 6, 4, 2});//调用方法输出数组
//数组作为函数的返回值
public static int[] reverse(int[] list) {
int[] result = new int[list.length];
for(int i=0,j=result.length-1;i
多维数组
-
多维数组可以看成是数组的数组
-
比如二维数组就是一个特殊的一维数组，其每一个元素都是一个一维数组
-
创建多维数组时指定至少第一级数组的维度。
int[][] table = new int[3][];
-
此时仅存在table[0]，table[1]和table[2]。
-
table.length的值为3。
-
可以为每行创建一个具有不同列数的二维数组。这样的数组称为粗糙数组。
-
声明方法跟一维数组一样
-
动态初始化（二维数组为例）
//直接为每一维分配空间：变量类型[][] 变量名 = new 变量类型[行数(>0)][列数(>0)];
int[][] a = new int[2][3]; //2*3的矩阵
//从最高维开始，分别为每一维分配空间，至少声明第一维
String s[][] = new String[2][];
s[0] = new String[2]; //第一行长度
s[1] = new String[3]; //第二行长度
s[0][0] = new String("Good");
s[0][1] = new String("Luck");
s[1][0] = new String("to");
s[1][1] = new String("you");
s[1][2] = new String("!");
//多维数组的引用（以二维数组为例）s[0][0];
Arrays类
数组操作工具类；能方便地操作数组，提供的所有方法都是静态的
- 给数组赋值：通过 fill 方法
- 对数组排序：通过 sort 方法,按升序
- 比较数组：通过 equals 方法比较数组中元素值是否相等
- 查找数组元素：通过 binarySearch 方法能对排序好的数组进行二分查找法操作
方法 说明 public static int binarySearch (Object[] a, Object key) 用二分查找算法在给定数组中搜索给定值的对象(Byte,Int,double等)。数组在调用前必须排序好的。如果查找值包含在数组中，则返回搜索键的索引；否则返回 (-(插入点) - 1) public static boolean equals(long[] a, long[] a2) 如果两个指定的 long 型数组彼此相等，则返回 true。如果两个数组包含相同数量的元素，并且两个数组中的所有相应元素对都是相等的，则认为这两个数组是相等的。换句话说，如果两个数组以相同顺序包含相同的元素，则两个数组是相等的。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等） public static void fill(int[] a, int val) 将指定的 int 值分配给指定 int 型数组指定范围中的每个元素。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等） public static void sort(Object[] a) 对指定对象数组根据其元素的自然顺序进行升序排列。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）
数组和字符串的转换处理
String str = "helloworld";
char[] data = str.toCharArray();// 将字符串转为数组
for (int x = 0; x < data.length; x++) {
System.out.print(data[x] + " ");
data[x] -= 32; //将字符转为大写字母
System.out.print(data[x] + " ");
}
System.out.println(new String(data));
运行结果：
h H e E l L l L o O w W o O r R l L d D HELLOWORLD
稀疏数组
定义
- 采用三列数组形式记录原数组元素坐标和值
- 首行元素：行坐标 列坐标 元素总数量（第二行开始为元素值）
- 第二行开始为原数组中的非0元素坐标、数值
- 记录数组元素时更加节省空间
原始数组：
-
1 0 0 0 0 0 0 0 0 0
0 1 0 0 0 0 0 0 0 0
0 0 1 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
转化为稀疏数组
- 10 10 3 // 行坐标 列坐标 总值数
0 0 1 // 例如：array[0][0] = 1
1 1 1
2 2 1
转化
-
找到原数组中所有的值个数，加一为转化数组的行数；转化数组恒定为3列
-
int values = 0;
for (int[] a : array) {
for (int b : a){
if (b != 0)
values++; //遍历得到原数组中的值的个数
}
}
int [][] array2 = new int [values+1][3];
-
首行信息
-
array2[0][0] = array.length; //原数组行数
array2[0][1] = array[0].length;//原数组列数
array2[0][2] = values; //原数组值的个数
-
遍历原数组所有元素，若 值不为0 则赋值给稀疏数组；注意数组下标
-
int row = 1; //从1开始，因为首行显示总信息
for(int i = 0; i <= array.length; i++){
for(int j = 0; j <= array[0].length; j++){
if(array[i][j] != 0){
array2[row][0] = i; //行坐标
array2[row][1] = j; //列坐标
array2[row][2] = array[i][j]; //该坐标元素值
//坐标格式恒定
row++;
}
}
}
-
遍历输出数组
-
for (int[] a : array2) {
for (int b : a){
System.out.print(b + "t");
}
System.out.println();
}
还原
//还原为原数组
int [][] array3 = new int [array2[0][0]][array2[0][1]];
for (int i = 1; i < array2.length; i++){
for (int j = 0; j < array2[i].length; j++){
array3[array2[i][0]][array2[i][1]] = array2[i][j];
}
}
for (int[] a : array3) {
for (int b : a){
System.out.print(b + "t");
}
System.out.println();
}
动态扩容
- 数组长度是固定不可变的，所谓动态扩容即在数组容量满的时候创建更大的数组
- 将原数组元素复制到新数组中
- 再将新数组命名为元素组名
- 即可实现动态扩容
public class Demo {
public int[] array = new int[10]; // 初始化数组，长度为 10
private static int index = 0; // 数组中实际元素个数
public int[] add(int ...args){
// 原数组剩余空间足够时直接添加元素
if(array.length - index > args.length){
add(array, args);
}else{
//先扩容再添加元素
grow(array, args);
}
return array;
}
//添加元素
private void add(int[] array1, int[] array2){
for (int i = 0; i < array2.length; i++) {
// 从原数组最后一个元素之后开始添加
array1[index++] = array2[i];
}
}
//扩容并添加元素
private void grow(int[] array1, int[] array2){
// 先将数组扩容到原数组加新数组长度
array = new int[array1.length + array2.length];
// 将原数组元素复制到新数组
for (int i = 0; i < array1.length; i++) {
array[i] = array1[i];
}
//执行添加元素
add(array, array2);
}
public static void main(String[] args) {
Demo demo = new Demo();
int[] array = demo.add(1, 2, 4, 5, 6,6 ,7,8);
for (int i = 0; i < array.length; i++) {
System.out.print(array[i] + " "); //1 2 4 5 6 6 7 8 0 0
}
int[] array2 = demo.add(1,1,1,1,1,1,1,2,2,2,22,2);
System.out.println();
for (int i = 0; i < array2.length; i++) {
System.out.print(array2[i]+ " "); //1 2 4 5 6 6 7 8 1 1 1 1 1 1 1 2 2 2 22 2 0 0
}
}
}
