数组

数组概述

数组的定义

数组是相同类型数据的有序集合
每一个数据被称作为一个数组元素，每个数组数组元素可以通过一个数组下标来访问它们。

数组声明创建

首先必须声明数组变量，才能在程序中使用数组。格式为，

类型名[] 数组名称;
java语言使用关键字new来创建新数组，格式如下，

类型名[] 数组名称 = new 类型名[数组长度]
数组的元素通过索引访问。索引从数字0开始有序排列。0,1,2,3,4...
获取数组长度的方法：.length方法。

import java.util.Arrays;

public class Demo01 {
    public static void main(String[] args) {
        // 声明一个数组
        int[] list1;

        // 创建一个新数组
        list1 = new int[6]; // list1中可以存放5个int类型的数据

        // 给数组元素赋值
        list1[0] = 1;
        list1[1] = 8;
        list1[2] = 9;
        list1[3] = 7;
        list1[4] = 3;

        // 将数组转换为字符串打印出来
        System.out.println(Arrays.toString(list1));

        // 将数组长度打印出来
        System.out.println(list1.length);
    }
}

//[1, 8, 9, 7, 3, 0]
//6

三种初始化
- 静态初始化
```
int[] a = {1, 2, 3};
Man[] mans = {new Man(1,1), new Man(2, 2)};
```
- 动态初始化
```
int[] a = new int[2];
int[0] = 1;
int[1] = 2;
```
- 数组的默认初始化
  
  数组是引用类型，它的元素相当于类的实例变量。因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。

import java.util.Arrays;

public class Demo02 {
    public static void main(String[] args) {
        // 静态初始化
        int[] list1 = {1, 2, 3};
        System.out.println(list1[2]);

        // 动态初始化
        int[] list2 = new int[3];
        list2[0] = 0;
        list2[1] = 1;
        list2[2] = 2;
        System.out.println(list2[2]);

        // 默认初始化
        int[] list3 = new int[2];
        System.out.println(Arrays.toString(list3));
    }
}

//3
//2
//[0, 0]

数组使用

增强型for循环
数组当作方法的参数
数组当作方法的返回值

比如，

import java.util.Arrays;

public class Demo04 {
    public static void main(String[] args) {
        int[] list1 = {1,2,3,4};
        printList(list1);
        printList(reverse(list1));
    }

    //打印数组
    public static void printList(int[] args) {
        System.out.println(Arrays.toString(args));
    }

    //反转数组
    public static int[] reverse(int[] args) {
        int position = args.length - 1;
        int[] reverseList = new int[position   1];
        for (int item : args) {
            reverseList[position] = item;
            position--;
        }
        return reverseList;
    }
}

//[1, 2, 3, 4]
//[4, 3, 2, 1]

多维数组

多维数组何以看成由数组组成的数组。比如二维数组就是由一些一维数组组成的数组。

二维数组：

int a[][] = new int[2][5]; // 由两个五个元素的数组组成的数组

public class Demo05 {
    public static void main(String[] args) {
        int[][] list1 = {{1,2,6},{3,4,7},{8,9,0}};
        System.out.println(list1[2][1]);
    }
}

// 9

Arrays类

数组的工具类: java.util.Arrays

import java.util.Arrays;
//工具Arrays的各种用法

public class Demo06 {
    public static void main(String[] args) {
        int[] list1 = {911, 103, 5, 4, 76, 459, 1, 2};
        int[] list2 = {911, 103, 5, 4, 76, 459, 1, 2};
        int[] list3 = new int[4];

        //打印数组
        System.out.println(Arrays.toString(list1));

        //对数组进行排序 : 升序
        Arrays.sort(list1);
        System.out.println(Arrays.toString(list1));

        //用二分法在排序好的数组中查找目标值
        System.out.println(Arrays.binarySearch(list1, 5));

        //判断两个数组中元素值是否完全相等(有序)
        System.out.println(Arrays.equals(list1,list2));

        //数组填充(一般用于初始化)非初始化情况下将覆盖原有数据
        Arrays.fill(list1, 10);
        Arrays.fill(list2, 0, 3, 9); // 下标0~3(不包括3)的元素填充为数字9
        Arrays.fill(list3, 8);
        System.out.println(Arrays.toString(list1));
        System.out.println(Arrays.toString(list2));
        System.out.println(Arrays.toString(list3));
    }
}

//[911, 103, 5, 4, 76, 459, 1, 2]
//[1, 2, 4, 5, 76, 103, 459, 911]
//3
//false
//[10, 10, 10, 10, 10, 10, 10, 10]
//[9, 9, 9, 4, 76, 459, 1, 2]
//[8, 8, 8, 8]

冒泡排序

冒泡排序是八大排序算法之一。
冒泡排序包含：两层循环，外层为冒泡轮数，里层为依次比较。
根据嵌套循环，可以得出这个算法的时间复杂度为O(n2)。

冒泡排序的列子，

import java.util.Arrays;

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

    }

    /*
    冒泡排序：(从小到大）
    1. 比较数组中两个相邻的元素。如果第一个数比第二个数大，则交换他们的位置。
    2. 每一轮的排序都会产生一个最大的元素。
    3. 那么下一轮可以少一次比较。
     */

    public static int[] sort(int[] targetList) {
        int temp = 0;

        //外层循环，判断走多少轮
        for (int i = 0; i < targetList.length - 1; i  ) {
            //内层循环，进行判断交换位置
            for (int j = 0; j < targetList.length -1 - i; j  ) {
                if (targetList[j 1] < targetList[j]) {
                    temp = targetList[j 1];
                    targetList[j 1] = targetList[j];
                    targetList[j] = temp;
                }
            }
        }

        return targetList;
    }
}

//[1, 2, 3, 7, 7, 9]

优化方法如下，

import java.util.Arrays;

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

    }

    /*
    冒泡排序：(从小到大）
    1. 比较数组中两个相邻的元素。如果第一个数比第二个数大，则交换他们的位置。
    2. 每一轮的排序都会产生一个最大的元素。
    3. 那么下一轮可以少一次比较。
     */

    public static int[] sort(int[] targetList) {
        int temp = 0;
        boolean didSorted = false;

        //外层循环，判断走多少轮
        for (int i = 0; i < targetList.length - 1; i  ) {
            //内层循环，进行判断交换位置
            for (int j = 0; j < targetList.length -1 - i; j  ) {
                if (targetList[j 1] < targetList[j]) {
                    temp = targetList[j 1];
                    targetList[j 1] = targetList[j];
                    targetList[j] = temp;
                    didSorted = true; //当触发了交换位置。将判断是否触发的控制器改为true
                }
            }

            //如果没触发交换，则说明数组已经排序。那就直接跳出循环，节省资源。
            if (!didSorted) {
                break;

        }
    }

        return targetList;
    }
}

//[1, 2, 3, 7, 7, 9]

稀疏数组

一种数据结构
需求：以下是一组数据组成的方阵（二维数组）。其中填充数据为0，有效数据只有两个。

00000000000
01000000000
00200000000
00000000000
00000000000
00000000000
00000000000
00000000000
00000000000
00000000000
00000000000
分析问题：保存类似数据时，会保存很多无效数据。
解决：稀疏数组
处理方式：
- 记录数组一共有几行几列，有多少各不同的值
- 把具有不同值得元素和行列以及值记录在一个小规模的数组中，从而缩小程序的规模
例如，以上例子可以写成

0 [11, 11, 2] //11行11列两个不同数值1,2

1 [1, 1, 1] //1,1的位置上的值为1

2 [2, 2, 2] //2, 2的位置上的值为2

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

        //创建一个2维数组 11*11 有三种值 0（填充）, 1, 2.
        int[][] board1 = new int[11][11];
        board1[1][1] = 1;
        board1[2][2] = 2;

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

        System.out.println("==========================");

        //转换为稀疏数组来保存
        //1. 获取有效值的个数
        int noOfEffectiveNumbers = 0;
        for (int[] ints : board1) {
            for (int anInt : ints) {
                if (anInt != 0) {
                    noOfEffectiveNumbers  ;
                }
            }
        }
        System.out.println("有效数字个数： "   noOfEffectiveNumbers);

        //2. 创建一个稀疏数组的数组
        int[][] effectiveArray = new int[noOfEffectiveNumbers 1][3];
        effectiveArray[0] = new int[]{11, 11, 2};

        //3. 遍历二维数组，将非零的值存放入稀疏数组
        int position = 1; // 从第二个一维数组开始
        int i = 0; //列
        int j; //行
        for (int[] ints : board1) {
            j = 0;
            for (int anInt : ints) {
                if (anInt != 0) {
                    effectiveArray[position] = new int[]{j, i, anInt}; // {行数，列数，数值}
                    position  ;
                }
                j  ;
            }
            i  ;
        }

        //打印稀疏数组
        for (int[] ints : effectiveArray) {
            for (int anInt : ints) {
                System.out.print(anInt   "\t");
            }
            System.out.println();
        }

        System.out.println("==========================");

        //逆向转换为原数组
        int line = effectiveArray[0][0];
        int row = effectiveArray[0][1];
        int[][] board2 = new int[line][row];

        for (int i1 = 1; i1 < effectiveArray.length; i1  ) {
            board2[effectiveArray[i1][0]][effectiveArray[i1][1]] = effectiveArray[i1][2];
        }

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

/*
00000000000
01000000000
00200000000
00000000000
00000000000
00000000000
00000000000
00000000000
00000000000
00000000000
00000000000
==========================
有效数字个数： 2
11112
111
222
==========================
00000000000
01000000000
00200000000
00000000000
00000000000
00000000000
00000000000
00000000000
00000000000
00000000000
00000000000
 */

来源：https://www.icode9.com/content-4-875151.html

2021_2_24_数组

数组

数组概述

数组声明创建

数组使用

多维数组

Arrays类

冒泡排序

稀疏数组

相关推荐