java 删除数组关键字,【Java复习巩固 Day2】数组

数组也是大部分编程语言都支持数据结构，Java也不例外。Java的数组类型是一种引用类型的变量，Java程序通过数组引用变量来操作数组，包括获得数组的长度，访问数组元素的值等。

Java的数组要求所有的数组元素具有相同的数据类型。因此，在一个数组中，数组的元素类型是唯一的，即一个数组只能存储一种数据类型的数据，不能存储多种数据类型的数据

定义数组

type[] arrayName;

type arrayName[];

数组是一种引用类型的变量，因此使用它定义一个变量时，仅仅表示定义了一个引用变量，这个引用变量还未指向任何有效内存，因此定义数组时不能指定数组的长度

由于定义数组只是定义了一个引用变量，并未指向任何有效的内存空间，所以还没有内存空间来存储数组元素，因此这个数组也不能使用，只有对数组进行初始化后才可以使用

数组的初始化

所谓的初始化，就是为数组元素分配内存空间，并为每个数组赋初始值

静态初始化：初始化时由程序员显示指定每个数组元素的初始值，由系统决定数组的长度

动态初始化：初始化时程序员只指定数组的长度，由系统为数组元素分配初始值

静态初始化

arrayName = new type[] {elem1, elem2, ...}

动态初始化

arrayName = new type[length];

package day2;

public class ArrayTest {

public static void main(String[] args) {

int[] arr1;

int[] arr2;

// 静态初始化

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

// 动态初始化

arr2 = new int[10];

}

}

在动态初始化中，指定初始值时，系统按照如下规则分配初始值

整数类型为0

浮点类型为0.0

字符类型为’\u0000’

布尔类型为false

引用类型为null

注意：不要同时使用静态初始化和动态初始化，也就是说，不要在进行数组初始化时，既指定数组的长度，也为每个数组元素分配初始值

数组的使用

package day2;

public class ArrayTest {

public static void main(String[] args) {

int[] arr1;

int[] arr2;

// 静态初始化

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

// 动态初始化

arr2 = new int[10];

// 修改数组的元素

arr1[1] = 100;

arr2[0] = 1024;

// 访问数组元素

System.out.println(arr1[1]);

System.out.println(arr2[2]);

// 获取数组的长度

System.out.println(arr2.length);

// foreach循环

for (int item : arr1) {

System.out.println(item);

}

for (int item : arr2) {

System.out.println(item);

}

}

}

100

0

10

1

100

3

4

5

1024

0

0

0

0

0

0

0

0

0

Process finished with exit code 0

注意：使用foreach循环迭代数组元素时，并不能改变数组元素的值，因此不要对foreach的循环变量进行赋值

工具类：Arrays

Java提供的Arrays类里包含了一些static修饰的方法可以直接操作数组

Arrays类处于java.util包下，为了在程序中使用Arrays类，必须在程序中导入java.util.Arrays类

package day2;

import java.util.Arrays;

public class ArraysTest {

public static void main(String[] args) {

int[] arr = new int[10];

// 数组填充

Arrays.fill(arr, 1024);

Arrays.fill(arr, 1, 5, 2);

System.out.println(Arrays.toString(arr));

// 数组复制

int[] arr1 = Arrays.copyOf(arr, 5);

int[] arr2 = Arrays.copyOfRange(arr, 1, 6);

System.out.println(Arrays.toString(arr1));

System.out.println(Arrays.toString(arr2));

// 数组排序

Arrays.sort(arr);

System.out.println(Arrays.toString(arr));

// 二分查找

int pos;

System.out.println((pos=Arrays.binarySearch(arr, 1)) < 0 ? "未找到" : pos);

System.out.println((pos=Arrays.binarySearch(arr, 1, 9, 1024)) < 0 ? "不存在" : pos);

}

}

[1024, 2, 2, 2, 2, 1024, 1024, 1024, 1024, 1024]

[1024, 2, 2, 2, 2]

[2, 2, 2, 2, 1024]

[2, 2, 2, 2, 1024, 1024, 1024, 1024, 1024, 1024]

未找到

4

Process finished with exit code 0

package day2;

import java.util.Arrays;

import java.util.function.IntBinaryOperator;

import java.util.function.IntUnaryOperator;

public class ArraysTest1 {

public static void main(String[] args) {

int[] arr1 = new int[] {3, -4, 25, 16, 30, 18};

// 对数组进行并发排序

Arrays.parallelSort(arr1);

System.out.println(Arrays.toString(arr1));

int[] arr2 = new int[] {3, -4, 25, 16, 30, 18};

Arrays.parallelPrefix(arr2, new IntBinaryOperator() {

@Override

public int applyAsInt(int left, int right) {

return left * right;

}

});

System.out.println(Arrays.toString(arr2));

int[] arr3 = new int[10];

Arrays.parallelSetAll(arr3, new IntUnaryOperator() {

@Override

public int applyAsInt(int operand) {

return operand * 5;

}

});

System.out.println(Arrays.toString(arr3));

}

}

[-4, 3, 16, 18, 25, 30]

[3, -12, -300, -4800, -144000, -2592000]

[0, 5, 10, 15, 20, 25, 30, 35, 40, 45]

Process finished with exit code 0