数组操作

数组声明和初始化

数组声明

数组声明有2种方式

type arrayName[];
type[] arrayName;

数组初始化

方式一

//分配长度为 4 个 int 型的内存空间，并分别赋初始值1，2，3，4
int[] array = new int[]{1, 2, 3, 4};

方式二

//方式一的简写
int[] array = {1, 2, 3, 4};

方式三

//分配长度为 4 的内存空间，并全部赋为默认值 0
//相当于 int[] array = new int[4]{0, 0, 0, 0} 的简写
int[] array = new int[4];

数组默认值

数组的默认值**(一般规律为数值型数组默认值为 0，引用型数组默认值为 null)**：

数组类型	默认初始值
byte	0
short	0
int	0
long	0
char	编码为0的字符('\u0000')
String（引用类型）	null
float	0.0
double	0.0
boolean	false

注意点

方式二是方式一的简写，方式二不能脱离数组的声明，即{1,2,3}不能单独存在定义数组。

遍历数组

方式一：for循环

public class Main {
    public static void main(String[] args) {
        int[] ns = { 1, 4, 9, 16, 25 };
        for (int i=0; i<ns.length; i++) {
            int n = ns[i];
            System.out.println(n);
        }
    }
}
/*结果
1 
4 
9 
16 
25 
*/

方式二：for each循环

public class Main {
    public static void main(String[] args) {
        int[] ns = { 1, 4, 9, 16, 25 };
        for (int n : ns) {
            System.out.println(n);
        }
    }
}
/*结果
1 
4 
9 
16 
25 
*/

方式三：Arrays.toString() 快速打印数组

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] ns = { 1, 1, 2, 3, 5, 8 };
        System.out.println(Arrays.toString(ns));
    }
}
//结果：[1, 1, 2, 3, 5, 8]

数组排序

冒泡排序

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] ns = { 28, 12, 89, 73, 65, 18, 96, 50, 8, 36 };
        // 排序前:
        System.out.println(Arrays.toString(ns));
        for (int i = 0; i < ns.length - 1; i++) {
            for (int j = 0; j < ns.length - i - 1; j++) {
                if (ns[j] > ns[j+1]) {
                    // 交换ns[j]和ns[j+1]:
                    int tmp = ns[j];
                    ns[j] = ns[j+1];
                    ns[j+1] = tmp;
                }
            }
        }
        // 排序后:
        System.out.println(Arrays.toString(ns));
    }
}
/*结果
[28, 12, 89, 73, 65, 18, 96, 50, 8, 36] 
[8, 12, 18, 28, 36, 50, 65, 73, 89, 96] 
*/

Arrays.sort 排序

Java的标准库已经内置了排序功能，我们只需要调用JDK提供的Arrays.sort()就可以排序：

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] ns = { 28, 12, 89, 73, 65, 18, 96, 50, 8, 36 };
        Arrays.sort(ns);
        System.out.println(Arrays.toString(ns));
    }
}

Arrays.sort()实际上是修改原有数组本身值

多维数组

二维数组

二维数组就是数组的数组。定义一个二维数组如下：

public class Main {
    public static void main(String[] args) {
        int[][] ns = {
            { 1, 2, 3, 4 },
            { 5, 6, 7, 8 },
            { 9, 10, 11, 12 }
        };
        System.out.println(ns.length); // 3
    }
}

因为ns包含3个数组，因此，ns.length为3。实际上ns在内存中的结构如下：

遍历二维数组，就是for循环嵌套

for (int[] arr : ns) {
    for (int n : arr) {
        System.out.print(n);
        System.out.print(', ');
    }
    System.out.println();
}

或者使用Java标准库的Arrays.deepToString()：

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[][] ns = {
            { 1, 2, 3, 4 },
            { 5, 6, 7, 8 },
            { 9, 10, 11, 12 }
        };
        System.out.println(Arrays.deepToString(ns));
    }
}

三维数组

int[][][] ns = {
    {
        {1, 2, 3},
        {4, 5, 6},
        {7, 8, 9}
    },
    {
        {10, 11},
        {12, 13}
    },
    {
        {14, 15, 16},
        {17, 18}
    }
};

其结构如下图：

打印如下：

public static void main(String[] args) {
    int[][][] ns = {
        {
            {1, 2, 3},
            {4, 5, 6},
            {7, 8, 9}
        },
        {
            {10, 11},
            {12, 13}
        },
        {
            {14, 15, 16},
            {17, 18}
        }
    };
    System.out.println(Arrays.deepToString(ns));
}

数组其它操作

数组过滤

filter 方法可以将数组中不符合的元素去掉，返回一个新数组。

public static void main(String[] args) {
    int[] arr = new int[]{1, 2, 6, 3, 4, 5};
    List list = Arrays.stream(arr).boxed().collect(Collectors.toList());
    list = (List) list.stream().filter(item -> {
        System.out.println(item);
        return ((Integer) item) > 3;
    }).collect(Collectors.toList());
    System.out.println(Arrays.toString(list.toArray()));
}

填充数组`Arrays.fill()`

void fill(int[] a, int val)全部填充

void fill(int[] a, int fromIndex, int toIndex, int val)填充指定索引的元素 左闭右开

public static void main(String[] args) {
    int[] arr = new int[]{6, 6, 6, 6, 6, 6, 6};
    Arrays.fill(arr, 8);
    System.out.println(Arrays.toString(arr));//[8, 8, 8, 8, 8, 8, 8]
    Arrays.fill(arr, 1, 3, 9);    //[8, 9, 9, 8, 8, 8, 8]
    System.out.println(Arrays.toString(arr));
}

数组排序`Arrays.sort()`

void sort(int[] a)全部排序 默认升序

void sort(int[] a, int fromIndex, int toIndex)排序指定索引的元素

int[] array = new int[]{3, 7, 8, 2, 1, 9};
Arrays.sort(array);    //全排序
Arrays.sort(array, 2, 5);    //2到5排序

复制数组`Arrays.copyOf()`

int[] copyOf(int[] original, int newLength)复制数组，指定新数组长度

int[] copyOfRange(int[] original, int from, int to)复制数组，指定所复制的原数组的索引

int [] array=new int[]{3,7,8,2,1,9};
array2=Arrays.copyOf(array,3); //新数组的长度为3
array3=Arrays.copyOfRange(array,3,5); //复制第三到五个元素

检查数组中是否包含某个值

先使用Arrays.asList()将Array转换成List<String>，这样就可以用动态链表的contains函数来判断元素是否包含在链表中

String[] stringArray = { "a", "b", "c", "d", "e" };
boolean b = Arrays.asList(stringArray).contains("a");
System.out.println(b);

连接两个数组（需要下载apache的jar包）

ArrayUtils是Apache提供的数组处理类库，其addAll方法可以很方便地将两个数组连接成一个数组

int[] intArray = { 1, 2, 3, 4, 5 };
int[] intArray2 = { 6, 7, 8, 9, 10 };
// Apache Commons Lang library
int[] combinedIntArray = ArrayUtils.addAll(intArray, intArray2);

数组翻转`reverse`

int[] intArray = { 1, 2, 3, 4, 5 };
int[] combinedIntArray = ArrayUtils.reverse(intArray);

Java学习笔记—数组操作