数组

数组

数组的定义

package com.cheng.array;

public class ArrayDemo01 {

    public static void main(String[] args) {
        int[] nums;//1.定义
        nums  = new int[12];//2.创建一个数组；
        //赋值
        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;
        nums[10] = 11;

        //计算所有元素的和
        int sum=0;
        //获取数组长度：array.length
        for(int i = 0;i< nums.length;i++){
            sum+=i;
        }
        System.out.println(sum);
    }
}

内存的分析

java.lang.ArrayIndexOutOfBoundsException 数组下标越界（常见bug）

三种默认初始化

package com.cheng.array;

public class ArrayDemo02 {
    public static void main(String[] args) {
      //静态初始化：创建+赋值
        int[] a = {1,2,34,5};
        System.out.println(a);//输出的数组a的地址：[I@1b6d3586
        System.out.println(a[3]);//输出的数组a中a[3]的值：5
        //动态初始化：包含默认初始化
        int[] b= new int[10];
        b[1]= 12;
        b[4]= 2;
        System.out.println(b[1]);
        System.out.println(b[4]);
    }
}

数组的四个基本特点

小结

• 数组是相同数据类型（数据类型可以为任意类型）的有序集合

• 数组也是对象。数组元素相当于对象的成员变量

• 数组长度的确定，不可变的。如果越界，则报:ArraylndexOutofbounds

---

---

数组的使用

基础使用

package com.cheng.array;

public class ArrayDemo03 {
    /**
     * 普通版数组的应用
     * @param args
     */
    public static void main(String[] args) {
        int[] a = {1,2,3,4,5,6};
        //1.打印全部的数组元素
        for (int i = 0; i <a.length ; i++) {
            System.out.print(a[i]+"\t");
        }
        System.out.println("");
        System.out.println("=================");

        //2.计算所有元素的和
        int sum = 0;
        for (int i = 0; i <a.length ; i++) {
            sum+=a[i];
        }
        System.out.println("sum ="+sum);
        System.out.println("=---===-==-=-=-=-=-====");
        //3.找出最大数
        int max = a[0];
        for (int i = 1; i <a.length ; i++) {
          if (a[i] > max){
                max = a[i];
            }
        }
        System.out.println("数组里的最大数是："+max);
    }


}

运行结果如下：

数组使用—进阶

package com.cheng.array;

import java.util.Arrays;

public class ArrayDemo04 {
    /**
     *进阶版数组的应用
     * @param args
     */
    public static void main(String[] args) {
        int[] a = {1,2,3,4,5,6};
        //1.进阶版打印，从jdk1.5开始，没有下标
       // for (int i : a) {
       //     System.out.println(i);
       // }

        int[] b = reverse(a);
        printArray(b);
    }
    //2.打印数组的方法printArray(int[] a)
    public static void printArray(int[] a){
        for (int i = 0; i <a.length ; i++) {
            System.out.println(a[i]);
        }
    }
    //3.反转数组
    public static int[] reverse(int[] a){
        int[] b = new int[a.length];
        //反转操作
        for (int i = 0,j =(b.length-1);  i <a.length; i++,j--) {
            b[j]=a[i];
        }
        return b;
    }
}

运行结果如下:

多维数组

package com.cheng.array;

public class ArrayDemo05 {
    /**
     * 多维数组
     * 二维数组demo
     */
    public static void main(String[] args) {
        int[][] a = {{1,2},{2,3},{3,4}};//二维数组的定义、初始化；
        //打印二维数组中的元素
        for (int i = 0; i <a.length ; i++) {
            for (int j = 0; j <a[i].length ; j++) {
                System.out.print(a[i][j]+"\t");
            }
            System.out.println("");
        }

    }
}

运行结果如下：

Arrays类

package com.cheng.array;

import java.util.Arrays;

import static java.util.Arrays.*;

public class ArrayDemo06 {
    public static void main(String[] args) {
        //Arrays类
        //可以在JDK1.8里了解更多Arrays类的方法；
        int[] a = {1, 2, 3, 4, 5, 6, 12, 456, 78, 96, 23};
        int[] b = new int[10];
        Arrays.fill(b,3,5,100);//填充
        Arrays.sort(a);//排序
        System.out.println(Arrays.toString(a));
        System.out.println(Arrays.toString(b));
    }
}

运行结果如下

冒泡排序

package com.cheng.array;

import java.util.Arrays;

/**
 * 冒泡排序
 * 1.比较数组中，两个相邻的元素，如果第一个数比第二个数大，我们就交换他们的位置；
 * 2.每一次比较，都会产生一个最大，或者最小的数字；
 * 3.下一轮则可以少一次排序！
 * 4.依次循环，直到结束！
 */
public class ArrayDemo07 {
    public static void main(String[] args) {

        int[] a = {45,31,4,24,4245,3,3565,6,35,53};
        System.out.println("冒泡排序法-升序");
        System.out.println(Arrays.toString(sort2(a)));
        System.out.println("冒泡排序法-降序");
        System.out.println(Arrays.toString(sort1(a)));
    }
    //冒泡排序法-降序
    public static int[] sort1(int[] b){
        //临时变量
        int temp = 0;
        //外层循环，判断我们这个要走多少次；
        for (int i = 0; i <b.length-1 ; i++) {
            //内层循环，比价判断两个数，如果第一个数，比第二个数大，则较换位置；
            for (int j = 0; j <b.length-1-i ; j++) {

                if (b[j+1]>b[j]){
                    temp = b[j];
                    b[j] = b[j+1];
                    b[j+1] = temp;
                }
            }
        }
        return b;
    }
    //冒泡排序法-降序
    public static int[] sort2(int[] b){
        //临时变量
        int temp = 0;
        //外层循环，判断我们这个要走多少次；
        for (int i = 0; i <b.length-1 ; i++) {
            //内层循环，比价判断两个数，如果第一个数，比第二个数大，则较换位置；
            for (int j = 0; j <b.length-1-i ; j++) {

                if (b[j+1]<b[j]){
                    temp = b[j];
                    b[j] = b[j+1];
                    b[j+1] = temp;
                }
            }
        }
        return b;
    }
}

运行结果如下

稀疏矩阵

package com.cheng.array;

public class ArrayDemo08 {
    public static void main(String[] args) {

        //稀疏数组******
        //1.棋盘，0代表没有棋子，1代表黑棋，2代表白棋；
        int[][] a = new int[5][5];
        a[1][1] = 1;
        a[2][2] = 2;
        System.out.println("原始棋盘：");
        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("");

        }
        System.out.println("==========================");
        //2.把棋盘用稀疏数组表示；
        int sum = 0;
        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j < a.length; j++) {
                if (a[i][j] != 0) {
                    sum++;
                }
            }
        }
        //建立稀疏数组
        int[][] b = new int[sum + 1][3];
        b[0][0] = 5;
        b[0][1] = 5;
        b[0][2] = sum;
        //赋值
        int count = 0;
        for (int j = 0; j < a.length; j++) {
            for (int k = 0; k < a.length; k++) {
                if (a[j][k] != 0) {
                    count++;
                    b[count][0] = j;
                    b[count][1] = k;
                    b[count][2] = a[j][k];
                }
            }
        }
        //打印该棋盘的稀疏数组；
        System.out.println("该棋盘的稀疏数组：");
        for (int k = 0; k <= sum; k++) {
            for (int l = 0; l < 3; l++) {
                System.out.print(b[k][l] + "\t");
            }
            System.out.println("");
        }
        System.out.println("============================");
        //3.还原稀疏数组

        int[][] c = new int[b[0][0]][b[0][1]];
        for (int i = 1; i <b.length ; i++) {
            c[b[i][0]][b[i][1]] = b[i][2];
        }
        //打印还原后的稀疏数组；
        System.out.println("还原后的稀疏数组：");
        for (int i = 0; i <c.length ; i++) {
            for (int j = 0; j <c.length ; j++) {
                System.out.print(c[i][j]+"\t");
            }
            System.out.println("");
        }

    }
}

运行结果如下