Java数组
1. 数组概述
相同类型的若干数据,按一定先后次序排列的有序集合
每个数据被称作一个数组元素,可通过他的下标来访问
2. 数组声明创建
声明与创建
首先声明数组变量
int[] aname;//首选方法
int aname[];
Java使用new操作符来创建数组
int[] aname = new int[size];
数组元素通过索引访问,数组索引从0开始
获取数组长度:arrays.length
内存分析
Java:
堆
存放new对象和数组
可以被线程共享,不会存放在别的对象引用
栈
存放基本数据类型
引用对象的变量,存放引用在堆地址
方法区
可以被线程共享
包含所有class和static变量
三种初始化
静态初始化
int[] a = {1,2,3};
Man[] mans = {new Man(1,1),new Man(2,2)};
动态初始化
int[] a = new int[2];
a[0] = 1;
数组默认初始化
数组是引用类型,相当于类的实例变量,按同样方式隐式初始化。
数组四个基本特点
长度确定,大小不变
元素必须是相同类型
可任意类型
数组变量是引用类型,数组对象存放在堆中
数组下标越界
下标合法区间:[0,length-1],越界报错.
ArrayIndexOutOfBoundsException:数组下标越界异常
小结:
数组是相同类型有序集合
数组是对象
数组长度不可变,超出报越界异常
3. 数组使用
for each
数组作方法入参
数组作返回值入参
public static void main(String[] args) {
int[] arrays = {1,2,3,4,5};
//1.for循环
// for (int i = 0; i
// System.out.println(arrays[i]);
// }
//2.for each
// for (int array:arrays) {
// System.out.println(array);
// }
//3.调用入参方法
// printArray(arrays);
//4.数组作返回值
int[] reverse = reverse(arrays);
printArray(reverse);
System.out.println("=====================");
int[][] array = {{1,2},{3,4},{5,6},{7,8}};
for (int i = 0; i < array.length ; i++) {
for (int j = 0; j < array[i].length ; j++) {
System.out.println(array[i][j]);
}
}
}
//3.方法入参
public static void printArray(int[] arrays){
for (int array:arrays) {
System.out.println(array);
}
}
//4.数组作返回值
public static int[] reverse(int[] arrays){
int[] result = new int[arrays.length];
for (int i = 0; i < arrays.length ; i++) {
result[i] = arrays[arrays.length-i-1];
}
return result;
}
4. 多维数组
多维数组定义:可看成是数组的数组,二维数组是特殊的一维数组,其中每个元素都是一维数组。
int[][] a = new int[2][3];
5. Arrays类
数组工具类Arrays:java.util.Arrays
数组对象本身没什么方法,可调用Arrays类中的
查看java API手册
Arrays类中方法有static修饰,可直接调用
功能:
给数组赋值:fill
排序:sort,升序
比较数组:equals,比较数组中元素是否相等
查找数组元素:binarySearch,对已排序数组二分查找
public static void main(String[] args) {
int[] a = {1,2,3,87,2678,431,17,77899};
//System.out.println(a); //[I@531be3c5
//1.输出数组
//System.out.println(Arrays.toString(a)); //依次输出数组元素
//自写toString
//printArrays(a);
//2.升序排序
//Arrays.sort(a);
//System.out.println(Arrays.toString(a));
//3.填充
//Arrays.fill(a,0);
Arrays.fill(a,2,4,0);
System.out.println(Arrays.toString(a));
//4.比较 ==与equals
int[] b = a;
System.out.println(a==b);
System.out.println(Arrays.equals(a,b));
Integer i1 = 128;
Integer i2 = 128;
System.out.println(i1==i2);
System.out.println(i1.equals(i2));
//5.二分查找
System.out.println(Arrays.binarySearch(a,17));
System.out.println(Arrays.binarySearch(a,77899));
}
public static void printArrays(int[] a){
for (int i = 0; i < a.length ; i++) {
if (i == 0){
System.out.print("[");
}
if (i == a.length-1){
System.out.print(a[i]+"]");
}else{
System.out.print(a[i]+", ");
}
}
}
6. 稀疏数组
介绍:
一个数组大部分元素为0,或同一值可用稀疏算法
处理方式:
记录数组中一共几行几列,有多少个不同值
把巨头不通知的元素和行列及值记录在小规模数组中,从而缩小规模
//稀疏数组
//1.创建一个二维数组 0:无,1:黑棋,2:白棋
int[][] array1 = new int[11][11];
array1[1][2] = 1;
array1[2][3] = 2;
System.out.println("输入原始数组");
for (int[] ints:array1) {
for (int anInt:ints) {
System.out.print(anInt+"\t");
}
System.out.println();
}
//2.稀疏数组
int sum = 0;
for (int i = 0; i < 11 ; i++) {
for (int j = 0; j < 11 ; j++) {
if (array1[i][j]!=0){
sum++;
}
}
}
System.out.println("======================================");
System.out.println("有效值个数:"+sum);
//打印稀疏数组
int[][] array2 = new int[sum+1][3];
array2[0][0] = 11;
array2[0][1] = 11;
array2[0][2] = sum;
//遍历,并存放其他数字
int count = 0;
for (int i = 0; i < array1.length ; i++) {
for (int j = 0; j < array1[i].length ; j++) {
if (array1[i][j]!=0){
count++;
array2[count][0] = i;
array2[count][1] = j;
array2[count][2] = array1[i][j];
}
}
}
//输出
System.out.println("输出稀疏数组");
for (int i = 0; i < array2.length ; i++) {
System.out.println(
array2[i][0]+"\t"+
array2[i][1]+"\t"+
array2[i][2]+"\t"
);
}
//3.还原
System.out.println("==========================");
System.out.println("还原稀疏数组");
int[][] array3 = new int[array2[0][0]][array2[0][1]];
//还原其他元素
for (int i = 1; i < array2.length ; i++) {
array3[array2[i][0]][array2[i][1]] = array2[i][2];
}
for (int[] ints:array3) {
for (int anInt:ints) {
System.out.print(anInt+"\t");
}
System.out.println();
}