JAVA数组
一、数组声明创建
数组是相同类型数据的有序集合；
数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成；
其中，每个数据称作一个数组元素，每个数组元素可以通过一个下标来访问。
public static void main(String[] args) {
// 变量的类型 变量名 = 变量值
// 数组类型 数组名 = 数组的值
int[] nums; //声明数组，首选
nums = new int[10]; // 创建数组，可以存放10个int类型的数据
// int[] nums=new int[10];
// 赋值
nums[0]=1;
nums[1]=2;
nums[2]=3;
nums[3]=4;
nums[4]=5;
nums[5]=6;
nums[6]=7;
nums[7]=8;
nums[8]=9;
nums[9]=10;//int 类型的默认值是0
// 计算所有数据的和
int sum =0;
for (int i = 0; i < nums.length; i++) {
sum+=nums[i];
}
System.out.println("总和"+sum);
}
内存分析
当声明一个数组之后会在栈中申请一块内存，在进行new时，会在堆中申请数组的具体大小内存，内存里存放赋值数据。当使用下标进行取值时，注意下标的大小，超出范围，会报数组下标越界的错误。
三种初始化
数组的四个基本特点
- 其长度是确定的。数组一旦被创建，它的大小就是不可以改变的。
- 其元素必须是相同类型,不允许出现混合类型。
- 数组中的元素可以是任何数据类型，包括基本类型和引用类型。
- 数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型。数组对象本身是在堆中的。
数组边界
二、数组使用
For-Each 循环/数组作方法入参/数组作返回值
public static void main(String[] args) {
int[] arrays={1,2,3,4,5};
// for (int array : arrays) { //没有下标,比较适合查询遍历
// System.out.println(array);
// }
// printArray(arrays);
int[] recerse=reverseArray(arrays);
printArray(recerse);
}
//打印数组元素
public static void printArray(int[] arrays){
for (int i = 0; i < arrays.length; i++) {
System.out.print(arrays[i]+" ");
}
}
//反转数组
public static int[] reverseArray(int[] arrays){
int[] result=new int[arrays.length];
for (int i = 0,j= result.length-1; i <arrays.length ; i++,j--) { //可以定义多个变量，逗号隔开
result[j]=arrays[i];
}
return result;
}
三、多维数组
public static void main(String[] args) {
//[4][2] 四行两列
int[][] arrays={{1,2},{2,3},{3,4},{4,5}};
for (int i = 0; i < arrays.length; i++) {
for (int j = 0; j < arrays[i].length; j++) {
System.out.print(arrays[i][j]+" ");
}
}
}
四、Arrays类
public static void main(String[] args) {
int[] nums={25,1546546,156,15,2,23};
//数组的打印
System.out.println(nums);
System.out.println(Arrays.toString(nums));
PrintNums(nums);
//数组的排序
Arrays.sort(nums);
System.out.println(Arrays.toString(nums));
//数组的填充
Arrays.fill(nums,0);//用0进行填充
Arrays.fill(nums,2,4,0);//也可以对于指定的位置进行填充，当前是2-4位置进行用0填充
System.out.println(Arrays.toString(nums));
}
//模仿toString方法的输出
public static void PrintNums(int[] arr){
for (int i = 0; i < arr.length; i++) {
if(i==0){
System.out.print("[");
}
if(i== arr.length-1){
System.out.println(arr[i]+"]");
}else{
System.out.print(arr[i]+", ");
}
}
}
五、冒泡排序★★★★★
//冒泡排序
//比较数组中相邻的两个数据，如果第一个比第二个数字大，我们就交换他们的位置
//每一次交换，都会产出一个最大或者最小的数字；
//下一轮则可以少一次排序
//依次循环，直到结束
public static void main(String[] args) {
int[] arrays = {45, 1265, 46, 15, 216, 5, 38, 56, 1};
System.out.println(Arrays.toString(sortBetter(arrays)));
}
public static int[] sort(int[] arrays) {
int temp = 0;
for (int i = 0; i < arrays.length - 1; i++) {//外层循环控制循环次数
for (int j = 0; j < arrays.length - 1 - i; j++) {//内层循环控制数字的比较
if (arrays[j + 1] > arrays[j]) {
temp = arrays[j];
arrays[j] = arrays[j + 1];
arrays[j + 1] = temp;
}
}
}
return arrays;
}
//优化版，减少不需要进行的排序，如果没有交换变换，直接退出循环
public static int[] sortBetter(int[] arrays) {
int temp;
boolean flag = false; //通过flag标识符减少没有意义的比较
for (int i = 0; i < arrays.length - 1; i++) {//外层循环控制循环次数
for (int j = 0; j < arrays.length - 1 - i; j++) {//内层循环控制数字的比较，如果第一个数比第二个数小，则交换位置
if (arrays[j + 1] > arrays[j]) {
temp = arrays[j];
arrays[j] = arrays[j + 1];
arrays[j + 1] = temp;
flag = true;
}
}
if (flag == false) { //flag为false，代表没有进行交换，则直接退出循环
break;
}
}
return arrays;
}
六、稀疏数组
public static void main(String[] args) {
//创建稀疏矩阵
int[][] arr1=new int[11][11];
arr1[1][2]=1;
arr1[2][3]=2;
//输出稀疏矩阵
System.out.println("输出稀疏矩阵");
for (int[] ints : arr1) {
for (int anInt : ints) {
System.out.print(anInt+"\t");
}
System.out.println();
}
//转换为稀疏数组
//遍历查询稀疏矩阵中的有效数据的个数
int sum=0;
for (int i = 0; i < arr1.length; i++) {
for (int j = 0; j < arr1[i].length; j++) {
if(arr1[i][j]!=0){
sum++;
}
}
}
System.out.println("非0个数为："+sum);
//首先创建一个稀疏数组的数组
int[][] arr2=new int[sum+1][3];
//填充稀疏数组的第一行数据
arr2[0][0]=11;
arr2[0][1]=11;
arr2[0][2]=sum;
//依次填入稀疏数组的后续内容
//遍历原稀疏矩阵，把非0有效数据进行存储
int count=0;//记录稀疏数组的行数
for (int i = 0; i < arr1.length; i++) {
for (int j = 0; j < arr1[i].length; j++) {
if(arr1[i][j]!=0){
count++;
arr2[count][0]=i;
arr2[count][1]=j;
arr2[count][2]=arr1[i][j];
}
}
}
System.out.println("=========================");
System.out.println("输出稀疏数组");
//输出稀疏数组
for (int[] ints : arr2) {
System.out.print(ints[0]+"\t"+ints[1]+"\t"+ints[2]);
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];
}
//打印还原的稀疏矩阵
System.out.println("=========================");
System.out.println("输出还原的稀疏矩阵");
for (int[] ints : arr3) {
for (int anInt : ints) {
System.out.print(anInt+"\t");
}
System.out.println();
}
}
