java 数组练习 java数组基础

数组基础

如何声明一个数组

int[] nums = new int[10];
// 数组类型 + 数组名  = new 数组长度

数组的基本特点

数组中开辟空间的原理
1、声明一个数组 会在栈内存中开辟一块空间，str
String [ ] str = null
2、创建数组长度 当new了之后会在堆内存中开辟一块空间存储数组长度
str = new String [ 5]
3、给数组赋值 未给数组赋值前，数组会有初始值，像int型数组初始为0.string型初始为null （数组中的默认初始化）

str[0]=1、str [1] = 2

……

三个初始化方式

数组的默认初始化

静态初始化
给数组直接赋值，长度固定类型固定
int [ ] nums= {1,2,3,4,5};
string [ ] str = { ‘1’,‘asb’,‘中国’};
Mas [ ] mas = {new Mas(),new Mas()}

动态初始化
规定类型，可以循环赋值，
int [ ] nums = new int [ 10 ];

数组的边界
【 0 ，length-1】

小结：

1. 数组是相同数据类型（数据类型可以为任意类型）的有序集合
2. 数组也是对象。数组元素相当于对象的成员变量
3. 数组长度是确定的、不可变的 如果区间越界则报错：ArrayIndexoutofBounds

数组的使用

//打印数组元素
    public static void prinArray(int[] nums){
        for (int i = 0; i < nums.length; i++) {
            System.out.println(nums[i]);
        }
    }
    //反转数组
    public  static int[] reverse (int[] nums){
        //12345.54321
        int[] reveser = new  int[nums.length];
        for (int i = 0,j = nums.length-1; i < nums.length; i++,j--) {
            reveser[j] = nums [i];
        }
        return reveser;
    }

二维数组
定义
多维数组可以看成是数组的数组，比如二维数组就是一个特殊的一维数组，其每一个元素都是一个一维数组

int [][] arrays =new int[1][2];

二维数组简单遍历输出

//二维数组
        int[][] arr = {{1,2},{3,4},{5,6}};

        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j <arr[i].length ; j++) {
                System.out.println(arr[i][j]);

            }
        }

Arrays类中简单的操作
sort 排序方法
fill 赋值方法
equals 比较数组中是否相等
toString 输出数组中的内容

排序方法—冒泡排序

//冒泡排序
    //1、比较数组中，两个相邻的有元素，如果第一个数比第二个数大，我们就交换他们的位置
    //2、每比较一次，都会产生一个最大或最小的数字。
    //3、下一轮则可以少排序一次
    //4、依次排序，直到结束
public static int [] sort (int [] array){
		int temp =0;//定义临时变量
	for(int i =0; i<array.length-1;i++){
		for(int j=0;j<array-1-i;j++){//相互比较大小，-i
			if( array[j+1]>array[j]){//判断后一个数大于前面一个数
				temp =array[j];
				 array[j]=array[j+1];
				array[j+1] =temp;
			}			
		}		
	}
	return array;
}

稀疏数组
看不懂，直接搬

//1、创建一个二维数组，11*11 0： 没有棋子  1： 黑棋  2 ： 白棋

        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 - 1; i++) {
            for (int j = 0; j < arr1.length-1; j++) {
                if (arr1[i][j] != 0) {
                    sum++;
                }
            }
        }
        System.out.println("有效值的个数："+sum);

        System.out.println("=========");

        //稀疏数组，压缩数组
        //1、创建一个稀疏数组中的数组
        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("输出稀疏数组");
        for (int i = 0; i < arr2.length; i++) {
            System.out.println(arr2[i][0]+"\t"
                    +arr2[i][1]+"\t"
                    +arr2[i][2]+"\t");
        }

        System.out.println("=========");
        System.out.println("还原");
        //1、读取稀疏数组
        int [][] arr3 =new int[arr2[0][0]][arr2[0][1]];

        //2、给其中的元素还原他的值
        for (int i = 1; i < arr2.length; i++) {
            arr3[arr2[i][0]][arr2[i][1]] = arr2[i][2];

        }


        //打印
        System.out.println("输出原始的数组");
        for (int[] ints : arr1) {
            for (int anInt : ints) {
                System.out.print(anInt + "\t");

            }
            System.out.println();
        }