Java学习笔记—数组操作

·  阅读 292
Java学习笔记—数组操作

数组操作

数组声明和初始化

数组声明

数组声明有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()实际上是修改原有数组本身值

image-20200527100832144

多维数组

二维数组

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

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.length3。实际上ns在内存中的结构如下:

image-20200527101013260

遍历二维数组,就是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}
    }
};
复制代码

其结构如下图:

image-20200527101301536

打印如下:

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);
复制代码
分类:
后端
标签: