JavaDay04-数组

数组

//先声明再创建
类型[] 数组名；//创建好的变量存放在栈中
数组名=new 类型[数组大小];//数组大小必须有；new完的数组在堆中分配内存
//1、声明数组：类型[] 变量名；
//2、创建数组：变量名=new 类型[];
int[] numbs;//定义数组numbs（引用类型），numbs里面有好多个int数字.变量存放在栈内存中
numbs=new int[3];//分配空间，用new来分配空间，分配10个int。对象和数组存放在堆内存中
//3、为数组赋值
numbs[0]=1;//存放在堆内存中
numbs[1]=1;
numbs[2]=1;

1、创建数组时必须指定数组的大小。数组一旦被创建，其大小不可改变。如果越界会报错：ArrayIndexOutofBounds
2、通过下标访问数组元素，下标从0开始
3、通过array.length获取数组的长度
4、数组中的元素可以是基本数据类型也可以是引用类型（类、数组、接口），但是所有的元素必须是同一种类型

内存分析：

1、堆-new的对象、数组；所有线程共享
2、栈-①基本数据类型及其初始化的值；②引用对象的变量。
3、方法区-类；static修饰的变量；所有线程共享

三种初始化：

1、静态初始化：创建+赋值
2、动态初始化：声明+分配空间+后期赋值
3、数组的默认初始化：数组是引用类型，其元素相当于实例变量，创建后会被赋默认值

//静态初始化
int[] array1={1,2,3};
//动态初始化
int[] array2;
array2=new int[2];

数组的使用

public class ArrayDemo02 {
    public static void main(String[] args) {
        int[] arr;
        arr=new int[3];
        //遍历元素并打印
        for (int i = 0; i < 3; i++) {
            System.out.println(arr[i]);
        }
        //计算所有元素的和
        int sum=arr[0];
        for (int i = 1; i < 3; i++) {
            sum += arr[i];
        }
        System.out.println("sum="+sum);
        //查找最大元素
        int max=arr[0];
        for (int i = 1; i < 3; i++) {
            if (arr[i]>max){
                max=arr[i];
            }
        }
        System.out.println("max="+max);
        //增强for循环-arr.for 始于jdk1.5 适合打印输出 不适合操作元素
        for (int i : arr) {
            System.out.println(i);
        }
    }
}

小练习-反转数组

public class ArrayDemo03 {
    public static void main(String[] args) {
        ArrayDemo03 demo03 = new ArrayDemo03();
        int[] arr={1,2,3,4,5};//要进行翻转的数组
        demo03.printArray(demo03.reverseArray(arr));//int[] result=demo03.reverseArray(arr);//反转后要接收结果
    }
    //翻转数组
    /*
    1、定义接收结果的变量
    2、循环实现遍历两个数组并赋值。一个正序遍历一个逆序遍历
     */
    public int[] reverseArray(int[] array){//数组可以作为形参
        int[] result=new int[array.length];//创建数组并分配堆内存
        for (int i = 0,j=array.length-1; i < array.length; i++,j--) {//遍历数组
            result[j]=array[i];//赋值
        }
        return result;//返回结果
    }
    //打印数组元素
    public void printArray(int[] array){
        for (int i : array) {//增强for循环
            System.out.print(i+" ");
        }
    }
}

Arrays类中的常用方法

1、排序：Arrays.sort(array)
2、直接遍历数组并打印Arrays.toString(array)

public class ClassArraysDemo01 {
    public static void main(String[] args) {
        double[] arr={1.2,3.5,6.7,0,2.2,9.3,1.6};
        Arrays.sort(arr);//排序
        System.out.println(Arrays.toString(arr));;//使用Arrays类直接遍历数组并且打印
    }
}

小练习-冒泡排序

import java.util.Arrays;
public class BubbleSortDemo {
    public static void main(String[] args) {
        int[] arr={6,9,2,5,4};
        System.out.println(Arrays.toString(bubbleSort(arr)));
    }
    //冒泡：两两比较，每一轮都能找到最大或者最小的数
    public static int[] bubbleSort(int[] array){
        int temp=0;
        boolean flag=false;//优化
        //外层循环-确定进行几轮排序
        for (int i = 0; i < array.length-1; i++) {
            //内层循环-每一轮的排序
            for (int j = 0; j < array.length-1-i; j++) {
                if (array[j]<array[j+1]){
                    temp=array[j];
                    array[j]=array[j+1];
                    array[j+1]=temp;
                    flag=true;//优化
                    System.out.println(j);
                }
            }
            if (flag==false) break;//优化
        }
        return array;
    }
}

多维数组

public class MulDimArrayDemo01 {
    public static void main(String[] args) {
        MulDimArrayDemo01 demo01 = new MulDimArrayDemo01();
        int[][] arr={{1,2},{10,20},{100,200},{1000,2000}};
        demo01.printMulDivArray(arr);
    }
    //打印多维数组
    public void printMulDivArray(int[][] array){
        for (int i = 0; i < array.length; i++) {//遍历第一维
            for (int j = 0; j < array[i].length; j++) {//遍历第二维
                System.out.print(array[i][j]);//输出array[i][j]
            }
        }
    }
}

稀疏数组与二维数组的转换

public class SparseArrayDemo {
    public static void main(String[] args) {
        /*
        1、创建一个二维数组n*m
        2、创建一个稀疏数组-3列：第一行为n、m、有效值的数量，其他行为行号、列号和值
        3、遍历二维数组，将有效的值放到稀疏数组中
        4、输出稀疏数组
         */
        //创建一个二维数组
        System.out.println("二维数组：");
        int[][] arr=new int[10][10];
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                if (i==4&&j==7){
                    arr[i][j]=10;
                }else{
                    arr[i][j]=0;
                }
                System.out.print(arr[i][j]+"\t");
            }
            System.out.println();
        }
        //遍历二维数组中的非零元素的个数
        int sum=0;
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                if (arr[i][j]!=0){
                    sum++;
                }
            }
        }
        System.out.println("二维数组中非零元素有"+sum+"个。");
        System.out.println("把二维数组转换成稀疏数组：");
        /*
        创建一个稀疏数组：
        1、赋值第一行；
        2、遍历二维数组
        3、将非零元素赋值给稀疏数组
         */
        //创建一个稀疏数组
        int[][] arrParse=new int[sum+1][3];
        arrParse[0][0]=arr.length;
        arrParse[0][1]=arr[0].length;
        arrParse[0][2]=sum;
        int count=0;
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                if (arr[i][j]!=0){
                    ++count;
                    arrParse[count][0]=i;
                    arrParse[count][1]=j;
                    arrParse[count][2]=arr[i][j];
                }
            }
        }
        //输出稀疏数组
        for (int i = 0; i < arrParse.length; i++) {
            System.out.println(arrParse[i][0]+"\t"
                    +arrParse[i][1]+"\t"
                    +arrParse[i][2]+"\t");
        }
        /*
        将稀疏数组还原为二维数组：
        1、创建二维数组；
        2、遍历读取稀疏数组的值；
        3、赋值给二维数组
         */
        //将稀疏数组还原为二维数组
        int n=arrParse[0][0];
        int m=arrParse[0][1];
        int[][] arr1=new int[n][m];
        for (int i = 1; i < arrParse.length; i++) {
            int h=arrParse[i][0];
            int l=arrParse[i][1];
            int val=arrParse[i][2];
            arr1[h][l]=val;
        }
        /*
        输出还原后的二维数组：
        1、遍历；
        2、输出；
        3、换行
         */
        //输出还原后的二维数组
        System.out.println("还原后的二维数组：");
        for (int i = 0; i < arr1.length; i++) {
            for (int j = 0; j < arr1[i].length; j++) {
                System.out.print(arr1[i][j]+"\t");
            }
            System.out.println();
        }
    }
}