数组声明创建&内存分析&数组的特点&多维数组&Array类&经典的冒泡排序&稀疏数组
数组声明创建
声明数组变量的语法：
// 首先方法
int[] number;
// 效果相同，但不是首选方法
// int number[];
// 使用new操作符来创建数组
number = new int[7];
// 合并起来就是以下写法
// int[] number2=new int[7];
// 给数组元素赋值
number[0]=7;
// 获取数组中的数据
System.out.println(number[0]); //7
内存分析
java内存分析：
画图分析：
代码分析：
public static void main(String[] args) {
// 静态初始化 创建 + 赋值
int[] number = {1,2,3,4,5};
// 动态初始化： 包含默认初始化
int[] number1 = new int[4];
number1[0]=7;
System.out.println(number[0]); //1
System.out.println(number1[0]); //7
System.out.println(number1[1]); //0 默认值
}
数组的特点
- 长度是确定的。数组一旦被创建，他的大小就是不可以改变的
- 其元素必须时相同的类型
- 元素可以是任何数据类型（基本类型，引用类型）
- 数组变量是引用类型，数组也可以作为对象，Java中的对象是在堆中，因此数组无论保存原始数据类型还是其他对象类型，数组对象本身就是在堆中的。
代码演示（数组反转）：
public static void main(String[] args) {
int[] array={1,2,3,4,5};
int[] reverse=reverse(array);
printArray(reverse);
}
// 打印数组元素
public static void printArray(int[] array) {
for (int i = 0; i < array.length; i++) {
System.out.println(array[i]);
}
}
// 反转数组
public static int[] reverse(int[] array){
int[] result=new int[array.length];
for (int i = 0,j=result.length-1;i<array.length;i++,j--) {
result[j]=array[i];
}
return result;
}
多维数组
数组的嵌套
代码演示：
public static void main(String[] args) {
int[][] array={{1,2},{3,4},{5,6}};
printArray(array);
}
// 打印数组元素
public static void printArray(int[][] array) {
for (int i = 0; i < array.length; i++) {
for (int i1 = 0; i1 < array[1].length; i1++) {
System.out.println(array[i][i1]);
}
}
}
Arrays类
常用功能：（举几个例子）
给数组赋值：通过fill方法
public static void main(String[] args) {
boolean[] a1=new boolean[5];
Arrays.fill(a1,false);
Arrays.fill(a1,2,3,true);
System.out.println(Arrays.toString(a1));
// [false, false, true, false, false]
}
给数组排序：通过sort方法，按升序
public static void main(String[] args) {
int[] arr={1,2,4,3,7,6,5};
Arrays.sort(arr);
System.out.println(Arrays.toString(arr));
}
比较数组：通过equals方法比较数组中元素值是否相等
public static void main(String[] args) {
int[] arr={7,7,7,7};
int[] arr1=arr;
boolean i = Arrays.equals(arr,arr1);
System.out.println(i); //true
}
查找数组元素：通过binarySearch方法能对排序好的数组进行二分查找法操作
public static void main(String[] args) {
int[] arr={7,8,7,7};
int res = Arrays.binarySearch(arr,8);
System.out.println(res);
}
经典的冒泡排序
import java.util.Arrays;
public class Ayyay01 {
public static void main(String[] args) {
int[] arr={1,3,5,2,4};
System.out.println(Arrays.toString(test(arr)));
}
public static int[] test(int[] a) {
int temp=0;
// 交换的次数
for (int i = 0; i < a.length - 1; i++) {
boolean flag=false;
for (int i1 = 0; i1 < a.length - 1 - i; i1++) {
if(a[i1+1]<a[i1]) {
temp=a[i1];
a[i1]=a[i1+1];
a[i1+1]=temp;
flag=true;
}
}
if (flag==false) {
break;
}
}
return a;
}
}
稀疏数组
- 当数组中的大部分元素为0，或者为同一个值的数组时，可以使用稀疏数组来保存数组。
- 处理方式： 记录数组一共有几行几列，有多少个不同值
把具有不同值的元素和行列以及值记录在一个小规模的数组中，从而缩小程序的规模
注意：二维数组中的length指的是行数
代码演示：
package com.peng.scanner;
import java.lang.reflect.Array;
import java.util.Arrays;
public class Ayyay01 {
public static void main(String[] args) {
int[][] arr=new int[7][7];
arr[1][2]=1;
arr[3][4]=1;
for (int[] ints:arr) {
for (int ar:ints) {
System.out.print(ar+"\t");
}
System.out.println();
}
int sum=0;
for (int i = 0; i < 7; i++) {
for (int i1 = 0; i1 < 7; i1++) {
if(arr[i][i1]!=0) {
sum++;
}
}
}
System.out.println(sum);
int[][] arr2=new int[sum+1][3];
arr2[0][0]=11;
arr2[0][1]=11;
arr2[0][2]=sum;
int count=0;
for (int i = 0; i < arr.length; i++) {
for (int i1 = 0; i1 < arr[i].length; i1++) {
if (arr[i][i1]!=0) {
count++;
arr2[count][0]=i;
arr2[count][1]=i1;
arr2[count][2]=arr[i][i1];
}
}
}
System.out.println();
for (int[] n:arr2) {
for (int m:n) {
System.out.print(m+"\t");
}
System.out.println();
}
System.out.println();
int[][] arr3=new int[arr2[0][0]][arr2[0][1]];
for (int i = 1; i < arr2.length; i++) {
arr3[arr2[i][0]][arr2[i][1]]=arr2[i][2];
}
for (int[] x:arr3) {
for (int y:x) {
System.out.print(y+"\t");
}
System.out.println();
}
}
}
最后效果如下：
