Java 语言中提供的数组是用来存储固定大小的同类型元素 数组对于每一门编程语言来说都是重要的数据结构之一，当然不同语言对数组的实现及处理也不尽相同。 你可以声明一个数组变量，如 numbers[100] 来代替直接声明 100 个独立变量 number0，number1，….，number99
声明数组变量
首先必须声明数组变量，才能在程序中使用数组。下面是声明数组变量的语法：
Type[] arrayName; // 👍首选的方法或Type arrayName[]; // 效果相同，但不是首选方法
⚠️注意: 建议使用 dataType[] arrayRefVar 的声明风格声明数组变量。 dataType arrayRefVar[] 风格是来自 C/C++ 语言 ，在Java中采用是为了让 C/C++ 程序员能够快速理解java语言
下面是这两种语法的代码示例：
double[] myList; // 首选的方法
int[] myList;
或
double myList[]; // 效果相同，但不是首选方法
int myList[];
数组格式
动态数组
数组存储的数据类型[] 数组名字 = new 数组存储的数据类型[长度]
int[] arr1 = new int[3];
静态数组
数据类型[] 数组名 = new 数据类型[]{元素1,元素2,元素3…}
int[] arr2 = new int[]{1,2,3};
省略格式
数据类型[] 数组名 = {元素1,元素2,元素3…}
int[] arr3 = {1,2,3};
数组存储的数据类型： 创建的数组容器可以存储什么数据类型
[] : 表示数组
数组名字：为定义的数组起个变量名，满足标识符规范，可以使用名字操作数组
new: 关键字，创建数组使用的关键字
数组存储的数据类型: 创建的数组容器可以存储什么数据类型。
[长度]： 数组的长度，表示数组容器中可以存储多少个元素
⚠️注意：数组有定长特性，长度一旦指定，不可更改。和水杯道理相同，买了一个2升的水杯，总容量就是2升，不能多也不能少。数组的元素是通过索引访问的。数组索引从 0 开始，所以索引值从 0 到 arrayRefVar.length-1
- 静态初始化没有直接指定长度，但是仍然会自动推算得到长度
- 静态初始化标准格式可以拆分成为两个步骤
- 动态初始化也可以拆分成为两个步骤
- 静态初始化一旦使用省略格式，就不能拆分成为两个步骤了
✅ 建议: 如果不确定数组当中的具体内容，用动态初始化；否则，已经确定了具体的内容，用静态初始化
下面的语句首先声明了一个数组变量 myList，接着创建了一个包含 10 个 double 类型元素的数组，并且把它的引用赋值给 myList 变量
public class TestArray {
public static void main(String[] args) {
// 数组大小
int size = 10;
// 定义数组
double[] myList = new double[size];
myList[0] = 5.6;
myList[1] = 4.5;
myList[2] = 3.3;
myList[3] = 13.2;
myList[4] = 4.0;
myList[5] = 34.33;
myList[6] = 34.0;
myList[7] = 45.45;
myList[8] = 99.993;
myList[9] = 11123;
// 计算所有元素的总和
double total = 0;
for (int i = 0; i < size; i++) {
total += myList[i];
}
System.out.println("总和为： " + total);
}
}
/*
以上实例输出结果为：
总和为： 11367.373
*/
下面的图片描绘了数组 myList。这里 myList 数组里有 10 个 double 元素，它的下标从 0 到 9
处理数组
数组的元素类型和数组的大小都是确定的，所以当处理数组元素时候，我们通常使用基本循环或者 For-Each 循环
public class TestArray {
public static void main(String[] args) {
double[] myList = { 1.9, 2.9, 3.4, 3.5 };
// 打印所有数组元素
for (int i = 0; i < myList.length; i++) {
System.out.println(myList[i] + " ");
}
// 计算所有元素的总和
double total = 0;
for (int i = 0; i < myList.length; i++) {
total += myList[i];
}
System.out.println("Total is " + total);
// 查找最大元素
double max = 0;
for (int i = 0; i < myList.length; i++) {
if (myList[i] > max)
max = myList[i];
}
System.out.println("Max is " + max);
//数组反转
int[] array = new int[]{1,2,3,4,5};
for (int a=0,b=array.length-1; a < b; a++,b--) {
array[a] = array[a]^array[b];
array[b] = array[a]^array[b];
array[a] = array[a]^array[b];
}
for (int i = 0; i < array.length; i++) {
System.out.println(array[i]);
}
}
}
/*
1.9
2.9
3.4
3.5
Total is 11.7
Max is 3.5
*/
数组原理内存图
内存概述
- 内存是计算机中的重要原件，临时存储区域，作用是运行程序,编写的程序是存放在硬盘中的,必须放进内存中才能运行，运行完毕后会清空内存
- Java虚拟机要运行程序，必须要对内存进行空间的分配和管理
Java虚拟机的内存划分
为了提高运算效率，就对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式
For-Each 循环
JDK 1.5 引进了一种新的循环类型，被称为 For-Each 循环或者加强型循环，它能在不使用下标的情况下遍历数组
语法格式如下：
for(type element: array) {
System.out.println(element);
}
public class TestArray {
public static void main(String[] args) {
double[] myList = { 1.9, 2.9, 3.4, 3.5 };
// 打印所有数组元素
for (double element : myList) {
System.out.println(element);
}
}
}
/*
以上实例编译运行结果如下：
1.9
2.9
3.4
3.5
*/
数组作为函数的参数
数组可以作为参数传递给方法。
例如，下面的例子就是一个打印 int 数组中元素的方法:
public class TestArray {
public static void main(String[] args) {
// 下面例子调用 printArray 方法打印出 1 3 5 7 9
printArray(new int[] { 1, 3, 5, 7, 9 });
}
public static void printArray(int[] array) {
for (int i = 0; i < array.length; i++) {
System.out.print(array[i] + " ");
}
}
}
方法的形参实参类型区别
import java.lang.reflect.Array;
import java.util.Arrays;
public class TestArray {
public static void main(String[] args) {
int a = 1;
int b = 2;
changeBasicType(a, b);
System.out.printf("a=%s,b=%s\n", a, b); // a=1,b=2
int[] arr ={1,2,3};
changeReferenceType(arr);
System.out.printf("a=%s\n",Arrays.toString(arr)); // a=[10000, 2, 3]
}
public static void changeBasicType(int a, int b) {
a = a + b;
b = b + a;
System.out.printf("a=%s,b=%s\n", a, b); // a=3,b=5
}
public static void changeReferenceType(int[] arr) {
arr[0] = 10000;
}
}
⚠️注意: 方法的实参为基本类型时,传递的是数据值. 方法的实参为引用类型时,传递的是地址值
数组作为函数的返回值
public static int[] reverse(int[] list) {
int[] result = new int[list.length];
for (int i = 0, j = result.length - 1; i < list.length; i++, j--) {
result[j] = list[i];
}
return result;
}
以上实例中 result 数组作为函数的返回值
多维数组
多维数组可以看成是数组的数组，比如二维数组就是一个特殊的一维数组，其每一个元素都是一个一维数组，例如：
String str[][] = new String[3][4];
多维数组的动态初始化（以二维数组为例）
直接为每一维分配空间，格式如下：
type[][] typeName = new type[typeLength1][typeLength2];type 可以为基本数据类型和复合数据类型，arraylength1 和 arraylength2 必须为正整数，arraylength1 为行数，arraylength2 为列数。例如：
int a[][] = new int[2][3];解析：二维数组 a 可以看成一个两行三列的数组
从最高维开始，分别为每一维分配空间，例如： ```java import java.sql.Array; import java.util.Arrays;
/**
TestArray */ public class TestArray {
public static void main(String[] args) { String str1[][] = new String[2][]; str1[0] = new String[2]; str1[1] = new String[3]; str1[0][0] = new String(“Good”); str1[0][1] = new String(“Luck”); str1[1][0] = new String(“to”); str1[1][1] = new String(“you”); str1[1][2] = new String(“!”); for (String[] i : str1) { System.out.println(Arrays.toString(i)); }
String[][] str2 = {{“1”,”2”}, { “3”, “4” }, { “5”, “6” },}; for (String[] i : str2) { System.out.println(Arrays.toString(i)); } } } / [Good, Luck] [to, you, !] [1, 2] [3, 4] [5, 6] / ``` 解析：s[0]=new String[2] 和 s[1]=new String[3] 是为最高维分配引用空间，也就是为最高维限制其能保存数据的最长的长度，然后再为其每个数组元素单独分配空间 s0=new String(“Good”) 等操作
多维数组的引用（以二维数组为例）
对二维数组中的每个元素，引用方式为 arrayName[index1][index2]，例如：
num[1][0];
数组的常见错误操作
数组越界异常
数组越界异常，会抛出 ArrayIndexOutOfBoundsException
数组空指针异常
public class TestArray {
public static void main(String[] args) {
int[] arr = {1,2,3};
// System.out.println(arr[3]); // Exception in thread "main"
// java.lang.ArrayIndexOutOfBoundsException: 3
arr =null;
System.out.println(arr[0]); // Exception in thread "main" java.lang.NullPointerException
}
}
所有的引用类型变量，都可以赋值为一个null值,arr = null 意味着变量arr将不会在保存数组的内存地址，也就不允许再操作数组了,会抛出 NullPointerException 空指针异常
Arrays 类
java.util.Arrays 类能方便地操作数组，比如排序和搜索等。它提供的所有方法都是静态的
具有以下功能：
- 给数组赋值：通过 fill 方法将指定的值赋给指定整数数组的每个元素
- 对数组排序：通过 sort 方法按升序
- 比较数组：通过 equals 方法比较数组中元素值是否相等
- 查找数组元素：通过 binarySearch 方法能对排序好的数组进行二分查找法操作。
具体说明请查看下表：
| 序号 | 方法和说明 |
|---|---|
| 1 | public static void fill(int[] a, int val) 将指定的 int 值分配给指定 int 型数组指定范围中的每个元素。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等） |
| 2 | public static void sort(Object[] a) 对指定对象数组根据其元素的自然顺序进行升序排列。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等） |
| 3 | public static boolean equals(long[] a, long[] a2) 如果两个指定的 long 型数组彼此相等，则返回 true。如果两个数组包含相同数量的元素，并且两个数组中的所有相应元素对都是相等的，则认为这两个数组是相等的。换句话说，如果两个数组以相同顺序包含相同的元素，则两个数组是相等的。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等） |
| 4 | public static int binarySearch(Object[] a, Object key) 用二分查找算法在给定数组中搜索给定值的对象(Byte,Int,double等)。数组在调用前必须排序好的。如果查找值包含在数组中，则返回搜索键的索引；否则返回 (-(插入点) - 1) |
Collections.sort()排序
方式一: Comparable接口并重写comparTo方法
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
//Comparable接口后面一定要加上需要比较的数据类型
class Person implements Comparable<Person> {
private String name;
private int age;
public Person() {
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Person{" + "name='" + name + '\'' + ", age=" + age + '}';
}
// 自身定义年龄升序
@Override
public int compareTo(Person o) {
return this.age - o.age; // 升序
}
}
public class PersonTest {
public static void main(String[] args) {
List<Person> people = new ArrayList<>();
people.add(new Person("AAA", 20));
people.add(new Person("BBB", 18));
people.add(new Person("CCC", 30));
System.out.println(people);
Collections.sort(people);
System.out.println(people);
}
}
方式: new Comparator(){ }排序的实现过程
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
class Person {
private String name;
private int age;
public Person() {
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Person{" + "name='" + name + '\'' + ", age=" + age + '}';
}
}
public class PersonTest {
public static void main(String[] args) {
List<Person> people = new ArrayList<>();
people.add(new Person("AAA", 20));
people.add(new Person("BBB", 18));
people.add(new Person("CCC", 30));
System.out.println(people);
// Collections.sort(people, new Comparator<Person>() {
// @Override
// public int compare(Person o1, Person o2) {
// return o2.getSalary() - o1.getSalary();
// }
// });
Collections.sort(people, (o1, o2) -> o1.getAge() - o2.getAge()); // 升序
System.out.println(people);
Collections.sort(people, (o1, o2) -> o2.getAge() - o1.getAge()); // 降序
System.out.println(people);
Collections.sort(people, Comparator.comparingInt(Person::getAge)); // 升序
System.out.println(people);
}
}
若有收获，就点个赞吧
0 人点赞
