java数组

数组

一维数组

定义

数组对于每一门编程语言来说都是重要的数据结构之一，当然不同语言对数组的实现及处理也不尽相同。

Java 语言中提供的数组是用来存储固定大小的同类型元素。

声明

dataType[] arrayRefVar;   // 首选的方法
dataType arrayRefVar[];  // 效果相同，但不是首选方法

创建数组

Java语言使用new操作符来创建数组，语法如下：

arrayRefVar = new dataType[arraySize];

上面的语法语句做了两件事：

• 一、使用 dataType[arraySize] 创建了一个数组。
• 二、把新创建的数组的引用赋值给变量 arrayRefVar。

数组变量的声明，和创建数组可以用一条语句完成，如下所示：

dataType[] arrayRefVar = new dataType[arraySize];

另外，你还可以使用如下的方式创建数组。

dataType[] arrayRefVar = {value0, value1, ..., valuek};

package array;

/**
 * @author 王旭阳
 */
public class ArrayDemo01 {
    public static void main(String[] args) {
        //声明数组
        //变量的类型  变量的名字  =  变量的值；
        //数组类型
        int[] nums;
        int nums1[];
        //创建数组
        //可以存放10数字 下标从0开始
        nums = new int[10];
        //数组赋值
       nums[0] = 1;
       nums[2] = 2;
       nums[3] = 3;
       nums[4] = 4;
       nums[5] = 5;
       nums[6] = 6;
       nums[7] = 7;
       nums[8] = 8;
       nums[9] = 9;
       nums[1] = 10;

       //int 默认值为0  string是null

       //输出数组
        //System.out.println(nums[0]);
        int num = 0;
        //计算数组的和
        for (int i = 0; i < nums.length; i++) {
            num += nums[i];
        }
        System.out.println(num);

        //组合
        int[] nums2 = new int[10];

    }
}

java内存分析

package array;

/**
 * @author 王旭阳
 */
public class ArrayDemo02 {
    public static void main(String[] args) {
        //静态初始化：创建 + 赋值
        int[] a = {1,2,3,4,5,6};
        System.out.println("静态初始化"+a[0]);

        //动态初始化
        int[] b = new int[10];
        b[0] = 1;
        b[1] = 2;
        System.out.println("动态初始化"+b[1]);
    }

}

四个基本特点

数组边界

数组使用

package array;

/**
 * @author 王旭阳
 */
public class ArrayDemo04 {
    public static void main(String[] args) {
        //foreach
        int[] a = {1,2,3,4,5,6};
//        for (int c : a){
//            System.out.println(c);
//        }
        int[] reverse = reverse(a);
        printArray(reverse);
    }

    /**
     *
     * @param arrays
     */
    public static void  printArray(int[] arrays){
        for (int i : arrays){
            System.out.println(i);
        }
    }

    /**
     * 数组返回值
     * @param arrays
     * @return
     */
    public static int[] reverse(int[] arrays){
        int[] result = new int[arrays.length];
        for (int i = 0,j=result.length-1; i < arrays.length; i++,j--) {
                result[j] = arrays[i];
        }
        return result;
    }
}

多维数组

定义

多维数组可以看成是数组的数组，比如二维数组就是一个特殊的一维数组，其每一个元素都是一个一维数组，例如：

int[][] a = new int[2][3]

package array;
/**
 * @author 王旭阳
 */
public class ArrayDemo05 {
    public static void main(String[] args) {
       //创建数组
        /*
        1,2
        2,3
        7,8
         */
        int[][] a = {{1,2},{2,3},{7,8}};
        System.out.println(a[0][0]);
        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j < a[i].length; j++) {
                System.out.println(a[i][j]);
            }
        }
    }
}

冒泡排序

package array;

import java.util.Arrays;

/**
 * @author 王旭阳
 */
public class ArrayDemo08 {
    public static void main(String[] args) {
        int[] b = {1,5,6,7,9};
        int[] sort = sort(b);
        System.out.println(Arrays.toString(sort));
    }

    /**
     *冒泡
     * @param array
     * @return
     */
    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-1-i; j++) {
                if(array[j+1]>array[j]){
                    temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = temp;
                }
            }
        }
        return array;
    }
}

稀疏数组

package array;

/**
 * @author 王旭阳
 */
public class ArrayDemo09 {
    public static void main(String[] args) {
        //1.创建一个二维数组 11*11 0：没有棋子  1：黑棋  2：白棋
        /*
        0 0 0 0 0 0 0 0 0 0 0
        0 1 0 0 0 ..........0
        0 0 2 ..............0
        .                   .
        .                   .
        .                   .
        0 0 0 0 0 0 0 0 0 0 0
         */


        int[][] array1 = new int[11][11];
        //存入数据
        array1[1][1] = 1;
        array1[2][2] = 2;
        //输出原始数组
        System.out.println("输出原始数组");

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

        //变换成为稀疏数组
        //获取有效值的个数
        int sum = 0;
        for (int i = 0; i < array1.length; i++) {
            for (int j = 0; j < array1.length; 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("输出稀疏数组");
        System.out.print(array2[0][0] + "\t" + array2[0][1] + "\t" + array2[0][2]);
        System.out.println();
        for (int i = 1; i < array2.length; i++) {
            System.out.print(array2[i][0] + "\t" + array2[i][1] + "\t" + array2[i][2]);
            System.out.println();
        }

        //还原稀疏数组
        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];
        }
        //输出还原数组
        System.out.println("输出还原数组");

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

    }
}