Day6:关于数组的学习

数组

定义

1. 数组时相同类型数据的集合
2. 按照先后顺序排列组合而成
3. 每个数据作为数组里的一个元素,可以通过下标来访问

具体写法

写法1:int[] nums; Java特色的写法,首选.

写法2:int nums2[]; 富含C语言,c++特色的写法.

声明并创建一个数组例题:计算一个数组的和

int[] nums=new int[10];//动态初始化
int sum=0;
nums[0]=1;
nums[1]=2;
nums[2]=3;
nums[3]=4;
nums[5]=6;//.默认初始化,不赋值的元素默认为0
//nums.length可以算出数组的长度
for(int i=0;i<nums.length;i++){
    sum+=nums[i];
}
System.out.print(sum);

数组的内存分析

int array=null;//在栈中新建一个array,为空
array=new int[10];//到堆中建立一个个数为10的数组
array[0]=1;//赋值
int[] a={1,2,3,4,5,6};//静态初始化

因此,数组本身就在堆里面

二维数组

二维数组简单理解就直角坐标系中的x,y.arrays[i] [j]也可以理解为表格中第i+1行的第j+1列

打印二位数组练习:

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.println("第"+(i+1)+"行第"+(j+1)+"列"+arrays[i[j]);
            }
        }

结果为

小结

注:下表不得超过[0,数组名.length]

关于反转数组输出的练习

数组作方法入参和数组作为返回值

int[] arrays={1,2,3,4,5};//main方法
     int[] reverse=reverse(arrays);//声明创建新数组接受返回的数组
     printarrays(reverse);//调用方法输出反转数组

public static int[] reverse(int[] arrays){
        int[] result=new int[arrays.length];//创建新数组
        for (int i = 0,j=arrays.length-1; i <arrays.length ; i++,j--) {
            result[j]=arrays[i];//反转,i+j=4
        }//括号中j与i顺序可变,输出不变
        return result;//数组作为返回值
    }

public static void printarrays(int[] arrays){//打印数组
        for (int i = 0; i <arrays.length ; i++) {
            System.out.print(arrays[i] +" ");
        }
    }

for-each:

int[] arrays={1,2,3,4,5}
for(int 新数组:已知数组)
//例子
for(int array:arrays)

Array方法

展示:

int[] a={1,2,3,6,4,5};
        Arrays.fill(a,2,4,2);//把a[2],a[3]赋值为2,不包括a[4]
        Arrays.sort(a);按大小升序
        System.out.print(Arrays.toString(a));输出数组

冒泡排序

简单讲就是将前(后)两个对比,在依次对比

public class Demo03 {
    public static void main(String[] args) {
        int[] a={24,55,38,46,79,6,0};
        int[] sort=sort(a);//调用
        System.out.println(Arrays.toString(sort));
    }
    public static int[] sort(int[] array){
        int temp=0;
        //array.length-1为循环次数
        for (int i = 0; i <array.length-1 ; i++) {
       //由于每次里循环已把前两个排好,前一个不再需要排序,所以只排后面的
            for (int j = 0; j < array.length-1-i; j++) {
                if(array[j+1]<array[j]){
                    temp=array[j];//利用temp交换
                    array[j]=array[j+1];
                    array[j+1]=temp;
                }
            }
        }
        return array;//返回数组
    }
}

稀疏数组

当一个数组大部分元素为0或同一数值,就可以用稀疏数组保存这一数组

处理方式: 1.记录一共几行几列,有多少个不同值

2.分别将不同元素的行列及数值保存在一个小规模数组里面

打印输出以及还原稀疏数组代码练习

打印一个11行11列的数组,第二行第三列赋值1,第三行第四列赋值2

int[][] array1=new int[11][11];
        array1[1][2]=1;
        array1[2][3]=2;

统计除0以外的数值sum

int sum=0;
        for (int i = 0; i <11; i++) {
            for (int j = 0; j <11 ; j++) {
                if(array1[i][j]!=0){
                    sum++;
                }
            }
        }

赋值新数组array2

int count=0;
        int[][] array2=new int[sum+1][3];
        array2[0][0]=11;
        array2[0][1]=11;
        array2[0][2]=sum;
        for (int i = 0; i <array1.length ; i++) {
            for (int j = 0; j <array1.length ; j++) {
                if(array1[i][j]!=0){//除0以外进入,得出有效值的行列
                    count++;
                    array2[count][0]=i;//第count行第0列赋值i
                    array2[count][1]=j;//第一列赋值j
                    array2[count][2]=array1[i][j];//第二列赋值
                }
            }
        }

还原稀疏数组array3

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循环操作为array.for
            for (int anInt : ints) {//ints.for
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }

int[] ints : array3) {//增强for循环操作为array.for
            for (int anInt : ints) {//ints.for
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }