14. 数组

数组特点

1、数组的长度一旦确定就不可更换
2、数组的元素必须为相同类型,不能出现混合类型(类似int和double一起)
3、数组的元素可以是任意数据类型,包括基本类型和引用类型
4、数组本身即对象,而java的对象存在堆中,所以数组对象本身是在堆中的

 

1、数组的声明和创建

public class ArrayDemo01 {
    public static void main(String[] args) {
        int[] numbs;//1、声明了一个数组

        numbs = new int[10];//2、创建一个数组并分配了10个空间

        //声明与创建可以一起写: int[] numbs = new int[10];

        //3、给数组中的元素赋值

        numbs[0]=1;//数组元素一号是编号[0]
        numbs[1]=2;
        numbs[2]=3;
        numbs[3]=4;
        numbs[4]=5;
        numbs[5]=6;
        numbs[6]=7;
        numbs[7]=8;
        numbs[8]=9;
        numbs[9]=10;

        //尝试计算数组的和

        int sum = 0;

        //获取数组长度:arrays.length

        for(int i =0;i< numbs.length;i++){
            sum = sum + numbs[i];
        }
        System.out.println("总和"+sum); //55

        System.out.println(numbs[10]);// java.lang.ArrayIndexOutOfBoundsException 数组下标越界异常。

    }
}

 

2、初始化

//静态初始化:创建+赋值
int[] a = {1,2,3,4,5};

//动态初始化:创建但不赋值,赋值要单独操作
int[] b = new int[10] ;
b[0]=10;

 

3、数组的使用

public class ArrayDemo03 {
    public static void main(String[] args) {
        //数组的使用

        //1、打印数组的全部元素

        int[] array = {1,2,3,4,5};

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

        //2、计算所有数组元素的和
        int sum = 0;
        for (int i = 0; i < array.length; i++) {
            sum += array[i];
        }
        System.out.println("sum="+sum);

        //3、查找最大元素
        int max = 0;
        for (int i = 0; i < array.length; i++) {
            if(array[i]>max){
                max=array[i];
            }
        }
        System.out.println("max="+max);

        //4、应用增强for循环遍历数组元素。没有下标,适合打印输出。jdk1.5后存在。
        for(int arrays : array){
            System.out.print(arrays+" ");
        }

        //5、数组作为参数(例如在方法中)
        printArrays(array);

    }
    //5、写一个方法:遍历数组元素
    public static void printArrays(int[] arrays){
        for (int i = 0; i < arrays.length; i++){
            System.out.print(arrays[i]+ " ");
        }
    }
}

 

4、数组的使用:反转数组

public class ArrayDemo04 {
    //6、数组作为返回值:使用反转数组理解

    public static void main(String[] args) {
        int[] array = {1,2,3,4,5};

        int[] reverse = reverse(array);
        printArrays(reverse);
    }

    //写一个反转数组的方法
    public static int[] reverse(int[] arrays){
        int[] result = new int[arrays.length];
        int j =result.length-1;

        for(int i = 0;i<arrays.length;i++,j--){
            result[j] = arrays[i];  //  result[4]=arrays[0];result[0]=arrays[4].
        }
        return result;

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

 

5、二维数组

public class ArrayDemo05 {

    public static void main(String[] args) {
        //二维数组
        /*
        1,2  arrays[0]
        2,3  arrays[1]
        3,4  arrays[2]
        4,5  arrays[3]
         */

        int[][] arrays = {{1,2},{2,3},{3,4},{4,5}};

        //遍历二维数组的方法:嵌套for循环;
        for (int i = 0; i < arrays.length; i++) {
            for(int j = 0;j < arrays[i].length;j++){//j < arrays[i].length ,意味着j的值只有0和1。
                System.out.println(arrays[i][j]);
            }
        }


        //二维数组的取长度方法
        System.out.println(arrays.length);//取得的外部数组长度:4
        System.out.println(arrays[1].length);//取得的内部数组长度:2

        System.out.println(arrays[0][0]); //1
        printArrays(arrays[0]); //1 2


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


}

 

6、Arrays类的方法

public class ArrayDemo06 {
    //Arrays类的学习

    public static void main(String[] args) {
        int[] a = {1,4,5,2,777,54,865,3452};

        //1、打印数组Arrays.toString
        System.out.println(a); // [I@3cb5cdba 直接打印会出现哈希code
        System.out.println(Arrays.toString(a)); //[1, 4, 5, 2, 777, 54, 865, 3452]

        //2、数组排序sort
        Arrays.sort(a);
        System.out.println(Arrays.toString(a)); //[1, 2, 4, 5, 54, 777, 865, 3452]

        //3、数组的填充
        Arrays.fill(a,0);  //将数组中的元素全部填充为0
        System.out.println(Arrays.toString(a));  //[0, 0, 0, 0, 0, 0, 0, 0]
    }
}

 

7、冒泡排序!

import java.util.Arrays;

public class ArrayDemo07 {

    //冒泡排序:时间复杂度o(n2);

    public static void main(String[] args) {
        /*
        拆解冒泡排序;
        1、比较数组中,相邻的两个元素,如果第一个元素比第二个元素大,则调换位置;
        2、每一次比较,都会产生一个最大或最小的数字;
        3、下一轮可以减少一次排序;
        4、重复循环,直到结束;
         */

        int[] b ={1,34,666,33,412,6534};
        int[] c = sort(b); // [6534, 666, 412, 34, 33, 1]
        System.out.println(Arrays.toString(c));

    }
    //写一个冒泡排序的方法
    public static int[] sort(int[] a){
        //建立临时变量:两个数的交换需要一个临时变量;
        int temp = 0;
        //建立外层循环:判断循环走多少次;

        //尝试优化掉最后一次的比较;
        boolean flag = false;

        for (int i = 0; i < a.length-1; i++) {
            //内层循环:比较两个数;-i是为了减少一次排序;
            for(int j = 0 ; j < a.length-1-i;j++){
                //交换两个数;
                if(a[j+1]>a[j]) {
                    temp = a[j + 1];
                    a[j + 1] = a[j];
                    a[j] = temp;
                    flag = true;
                }
            }
            //如果没有进行比较,即for循环结束循环,flag就==false,那么可以跳过最后一次比较,直接用break跳出循环;
            if (flag==false){break;};


        }
        return a;


    }
}

 

8、稀疏数组

import java.util.Arrays;

public class ArrayDemo08 {
    //稀疏数组
    //问题:因为二维数组中很多值默认是0,因此记录和很多无意义的数据
    //解决:使用稀疏数组解决问题;
    //处理方式:稀疏数组记录数组有几行几列,有多少个不同值;
    public static void main(String[] args) {
        //1、创建一个二维数组 11*11  ; 0;没有棋子;1:白棋;2:黑棋;
        int[][] array1 = new int[11][11];
        array1[1][2]=1;
        array1[2][3]=2;
        //2、输出原始数组;
        for (int i = 0; i < array1.length; i++) {
            for (int j = 0; j < array1.length; j++) {
                System.out.print(array1[i][j]+"\t");
            }
            System.out.println();
        }
        //原始数组:
        //0    0    0    0    0    0    0    0    0    0    0
        //0    0    1    0    0    0    0    0    0    0    0
        //0    0    0    2    0    0    0    0    0    0    0
        //0    0    0    0    0    0    0    0    0    0    0
        //0    0    0    0    0    0    0    0    0    0    0
        //0    0    0    0    0    0    0    0    0    0    0
        //0    0    0    0    0    0    0    0    0    0    0
        //0    0    0    0    0    0    0    0    0    0    0
        //0    0    0    0    0    0    0    0    0    0    0
        //0    0    0    0    0    0    0    0    0    0    0
        //0    0    0    0    0    0    0    0    0    0    0


        //一、我们使用稀疏数组保存上面的原始数组;
        //1、我们要获取有效值个数:指除了0以外其他数的个数;
        int sum =0;
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if(array1[i][j]!=0){
                    sum++;
                }
            }

        }
        System.out.println("有效值个数:"+sum); //2

        //2、创建稀疏数组
        int[][] array2 = new int[sum+1][3];//划定稀疏数组的空间
        array2[0][0] =11;
        array2[0][1] =11;
        array2[0][2] =sum;

        pringtArray(array2);
        //11    11    2
        //0      0    0
        //0        0     0
        //稀疏数组创建完成!

        //3、遍历原始数组,将非零的值存放于稀疏数组中;
        int count=0;
        for (int i = 0; i < array1.length; i++) {
            for (int j = 0; j < array1.length; j++) {
                if (array1[i][j]!=0){
                    count++;
                    array2[count][0] = i;
                    array2[count][1] = j;
                    array2[count][2] = array1[i][j];
                }
            }

        }
        //输出稀疏输出
        pringtArray(array2);
        /*
        11    11    2
        1    2    1
        2    3    2
        输出完成!
         */

        //二、利用稀疏数组还原原始数组;

        //1、读取稀疏数组
        int[][] array3 = new int[array2[0][0]][array2[0][1]]; //读取稀疏数组array2的行和列,即两个11,来创建还原数组array3;

        //2、给元素还原值;
        for (int i = 1; i < array2.length; i++) {
            array3[array2[i][0]][array2[i][1]] = array2[i][2];
        }

        //3、打印还原数组
        pringtArray(array3);
        /*
0    0    0    0    0    0    0    0    0    0    0
0    0    1    0    0    0    0    0    0    0    0
0    0    0    2    0    0    0    0    0    0    0
0    0    0    0    0    0    0    0    0    0    0
0    0    0    0    0    0    0    0    0    0    0
0    0    0    0    0    0    0    0    0    0    0
0    0    0    0    0    0    0    0    0    0    0
0    0    0    0    0    0    0    0    0    0    0
0    0    0    0    0    0    0    0    0    0    0
0    0    0    0    0    0    0    0    0    0    0
0    0    0    0    0    0    0    0    0    0    0


        打印完成!
         */



    }
    public static void pringtArray(int[][] a){
        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j < a.length; j++) {
                System.out.print(a[i][j]+"\t");
            }
            System.out.println();
        }

    }
}

 

posted @ 2021-02-07 15:54  jyurokuya  阅读(33)  评论(0编辑  收藏  举报