数组

数组的声明和创建

public class Demo01 {
    public static void main(String[] args) {
        //1.数组声明语法
        int[] nums; //1.定义
        int nums2[];//2.c风格，不建议

        //2.Java用new创建数组,分配空间
        // dataType[] arrayRefVar = new dataType[arraySize]
        nums = new int[10];

        //3.给数组元素赋值
        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;

        //计算所有元素的和
        int sum = 0;

        for(int i = 0 ; i<nums.length; i++){
            sum = sum + nums[i];
        }
        System.out.println("总和为：" + sum);
    }
}

内存分析

public static void main(String[] args) {
    //静态初始化：创建＋赋值
    int[] a = {1,2,3,4,5,6,7,8,};
    System.out.println(a[0]);

    //动态初始化:包含默认初始化
    int[] b = new int[10];
    b[0] = 10;
    System.out.println(b[0]);
    System.out.println(b[1]);
    System.out.println(b[2]);
    System.out.println(b[3]);

    /*数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，
     其中的每个元素也被按照实例变量同样的方式被隐式初始化*/
}

• 数组长度确定，数组被创建，它的大小就不可改变
• 其元素必须是相同类型，不允许出现混合类型。。
• 数组中元素可以是任何数据类型，包括基本类型和引用类型。
• 数组变量属于引用类型，数组也可以看成对象，数组中的每个元素相当于该对象的成员变量。
• 数组本身就是对象，java对象在堆中，因此数组无论原始类型还是其它类型都保存在堆中。

下标的合法区间：[0, length-1]

越界报错：ArrayIndexOutOfBoundsException

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

    //打印全部数组元素
    for(int i = 0; i<arrays.length; i++){
        System.out.println(arrays[i]);
    }
    System.out.println("==============");

    //计算元素和
    int sum = 0;
    for (int i = 0; i<arrays.length; i++){
        sum += arrays[i];
    }
    System.out.println("sum=" +sum);

    //计算元素最大值
    int max = arrays[0];
    for (int i = 0; i<arrays.length; i++){
        if (arrays[i]>max)
            max=arrays[i];
    }
    System.out.println("max="+max);
}

数组的使用

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

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

        //    for (int array : arrays) {//arrays.for
        //        System.out.println(array);
        //     }
        
        int[] result = reverseArray(arrays);
        printArray(result);
    }

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

    //反转数组
    public static int[] reverseArray(int[] arrays){
        int[] arrays2 = new int[arrays.length];
        for (int i=0,j=arrays.length-1; i<arrays.length; i++,j--){
            arrays2[j] = arrays[i];
        }
        return arrays2;
    }

}

多维数组

可以看作数组的数组

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

    printArray(array[0]);//1 2
    System.out.println(array[2][0]);//3
    System.out.println(array.length);//4
    System.out.println(array[0].length);//2

}

Arrays类

工具类都是别人写的，尽可能不重复造轮子

    public static void main(String[] args) {
        int[] a = {1,2,3,4,923,23,7,566};
        System.out.println(a);//[I@1b6d3586哈希值

        //打印数组元素toString
        System.out.println(Arrays.toString(a));

        Arrays.sort(a);//数组进行排序
        System.out.println(Arrays.toString(a));

        Arrays.fill(a,0);//填充
        System.out.println(Arrays.toString(a));
    }

Arrays类中的方法都是static修饰的静态方法，在使用过程中可以直接用类名调用，而不用使用对象来调用

常用功能：

• 给数组赋值：fill方法
• 给数组排序：sort方法升序
• 比较数组：equals方法
• 查找数组元素：binarySearch方法对排序号的数组进行二分法查找

jdk帮助文档

冒泡排序

import java.util.Arrays;

public class Demo07 {
    public static void main(String[] args) {
        int[] a = {1,3,2,6,7,9,4,5};
        int[] sort = sort(a);
        System.out.println(Arrays.toString(sort));

    }
    public static int[] sort(int[] array) {
        int temp = 0;
        for (int i = 0; i<array.length-1; i++){
            for (int j = 0; j<array.length-i-1; j++){
                if(array[j]>array[j+1]) {
                    temp = array[j + 1];
                    array[j + 1] = array[j];
                    array[j] = temp;
                }
            }
        }
        return array;
    }
}

稀疏数组

public class Demo08 {
    public static void main(String[] args) {
        //创建一个11*11的棋盘。0：没有棋子、1：黑棋、2：白棋
        int[][] array1= new int[11][11];
        array1[1][2]=1;
        array1[2][3]=2;
        //输出原始数组
        System.out.println("输出原始数组");

        for (int[] ints : array1) {
            for(int anInt : ints){
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }
        System.out.println("=================");

        //转化为稀疏数组
        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);

        //创建一个稀疏数组
        int[][] array2 = new int[sum+1][3];
        array2[0][0] = 11;
        array2[0][1] = 11;
        array2[0][2] = sum;

        //遍历二维数组，将非零值放入稀疏数组
        int count = 0;
        for(int i=0; i<array1.length; i++){
            for (int j=0; j<array1[i].length; j++){
                if (array1[i][j]!=0) {
                    count++;
                    array2[count][0]=i;
                    array2[count][1]=j;
                    array2[count][2]=array1[i][j];
                }
            }
        }
        //输出稀疏数组
        System.out.println("稀疏数组");
        for(int i=0; i<array2.length; i++){
            System.out.println(array2[i][0]+"\t"
                    +array2[i][1]+"\t"
                    +array2[i][2]+"\t");
        }
    }
}

Java数组

原文：https://www.cnblogs.com/squirrelV/p/14443208.html