数组（Array）是有序的元素序列。 若将有限个类型相同的变量的集合命名，那么这个名称为数组名。 组成数组的各个变量称为数组的分量，也称为数组的元素，有时也称为下标变量。用于区分数组 的各个元素的数字编号称为下标。数组是在程序设计中，为了处理方便， 把具有相同类型的若干元素按有序 的形式组织起来的一种形式。这些有序排列的同类数据元素的集合称为数组。 数组是用于储存多个相同类型数据的集合。 数组是对象类型（引用类型） 数组是固定长度，下标是从0开始，结束下标是，length属性-1，下标不存在系统会抛出异常。
面试题
如下代码能不能编译，有没有错误，如果没有错误程序输入结果是？
int[ ] nums = new int[7]; nums[7] = 30; System.out.println(nums[7]); System.out.println(nums[1]); 答案是有错误，第二句与第三句无法编译，这个数组的长度是7，但是数组索引从0开始，依次递增，直至最后一个元素的索引为数组长度 – 1。因此不存在 nums[7]，未给该数组赋值，则nums[1]会按照默认值0输出声明一个可以包括任何类型元素的数组？
Object[ ] objs = new Object[ ]{1, .5, new Date(), LocalDate.now()}; Object[ ] os = new Object[10]; Object数组可以包括任何类型元素的数组
1 声明数组对象
声明数组，是一个有序元素集合。java中数组元素的个数是固定的（声明后不能增加元素，不能删除元素）声明一个数组对象需要指定数组的类型和大小。类型[ ] 变量名 = new 类型[ ]; 例：int[ ] a3 = {10, 20, 30}; 那么a3[0]=10 a3[1]=20 a3[2]=30
//声明整型数组对象
int[] intArray; // 声明一个整型数组对象
//声明字符串数组对象
String[] stringArray; // 声明一个字符串数组对象
//String[] stringArray; // 声明一个字符串数组对象
Person[] personArray; // 声明一个Person对象数组对象
//在声明数组对象后，你还需要为数组分配内存空间，即指定数组的大小
//1.使用new关键字手动分配内存空间：
intArray = new int[5]; // 创建一个大小为5的整型数组对象
//2.将一个已有的数组赋给已声明的数组对象：
int[] existingIntArray = {1, 2, 3, 4, 5}; // 已有的整型数组
intArray = existingIntArray; // 将已有数组赋给已声明的整型数组对象为声明字符串数组对象并分配内存空间的完整示例：
String[] stringArray; // 声明一个字符串数组对象
stringArray = new String[3]; // 创建一个大小为3的字符串数组对象
// 将值分配给数组元素
stringArray[0] = "Hello";
stringArray[1] = "World";
stringArray[2] = "!";
// 访问和输出数组元素
for (String str : stringArray) {
System.out.println(str);
}
//输出结果
//Hello
//World
//!声明数组对象时可以分为两个步骤，即先声明数组对象，然后再分配内存空间，或者直接在声明时同时分配内存空间。在使用数组前，一定要为其分配合适的内存空间。
在Java中，如果你声明了一个数组，只给出了数组的长度而没有为数组元素赋值，那么数组的元素将使用默认值进行初始化。不同类型的数组元素会有不同的默认值：
- 对于基本数据类型的数组（如
int[]、double[]、boolean[]等），元素的默认值为0（对于数值类型）或false（对于布尔类型）。- 对于引用数据类型的数组（如
String[]、Object[]等），元素的默认值为null。
public class LocalArray {
public static void main(String[] args) {
int length = 5;
int[] numbers = new int[length]; // 使用默认值初始化整型数组
// 输出整型数组的元素
for (int i = 0; i < length; i++) {
System.out.println(numbers[i]);
}
String[] names = new String[length]; // 使用默认值初始化字符串数组
// 输出字符串数组的元素
for (int i = 0; i < length; i++) {
System.out.println(names[i]);
}
}
}
2.使用数组
数组对象有.length 属性返回数组元素的个数千万不写 length()在Java中，有多种方式可以遍历数组，可以根据不同的需求选择合适的方法。 1.使用普通for循环：(推荐)
int[] numbers = {1, 2, 3, 4, 5};
for (int i = 0; i < numbers.length; i++) {
System.out.println(numbers[i]);
}2.使用增强型for循环（foreach循环）：(推荐)
int[] numbers = {1, 2, 3, 4, 5};
for (int number : numbers) {
System.out.println(number);
}3.使用Java 8的流(Stream)：
int[] numbers = {1, 2, 3, 4, 5};
Arrays.stream(numbers)
.forEach(number -> System.out.println(number));4.使用Java 8的流(Stream)和方法引用：
int[] numbers = {1, 2, 3, 4, 5};
Arrays.stream(numbers)
.forEach(System.out::println);5.使用Java 8的IntStream：
int[] numbers = {1, 2, 3, 4, 5};
IntStream.range(0, numbers.length)
.forEach(i -> System.out.println(numbers[i]));这些方法中，普通for循环是最常见的遍历方式，适用于对数组中的元素进行任意操作，可以通过索引访问数组元素。增强型for循环适用于简单遍历数组，不需要访问索引，语法更简洁。Stream的方式适用于使用函数式编程风格，并且具有一些在集合操作上的额外功能。
Arrays是Java提供的一个包含各种数组操作的工具类。它提供了许多静态方法，可以用于对数组进行排序、搜索、填充、比较等操作。
sort()：用于对数组进行排序。可以对包含基本数据类型或对象的数组进行排序。
binarySearch()：用于在已排序的数组中进行二分搜索。如果数组中存在目标元素，则返回其索引；如果不存在，则返回一个负数。
fill()：用指定的值填充数组的所有元素，可以使用基本数据类型或对象。
equals()：用于比较两个数组是否相等。会判断数组的长度和元素是否一一相等。
toString()：将数组转换为字符串表示。
copyOf()：复制一个数组，可以指定新数组的长度。新数组的长度可以大于或小于原数组。
asList()：将指定的元素转换为一个固定大小的列表。可以用于快速创建包含多个元素的数组列表。
这些只是Arrays类提供的一小部分方法。该类还提供了其他一些有用的方法，如hashCode()、deepEquals()、hashCode()等。通过使用Arrays类，可以更方便地操作和处理数组。
import java.util.Arrays;
public class ArraysDemo {
public static void main(String[] args) {
int[] numbers = {5, 2, 8, 3, 9};
Arrays.sort(numbers);
System.out.println(Arrays.toString(numbers));
int index = Arrays.binarySearch(numbers, 3);
System.out.println("Element 3 is at index " + index);
int[] copiedArray = Arrays.copyOf(numbers, numbers.length);
System.out.println(Arrays.toString(copiedArray));
String[] names = {"Alice", "Bob", "Charlie"};
System.out.println("Are arrays equal? " + Arrays.equals(numbers, copiedArray));
System.out.println("Are arrays equal? " + Arrays.equals(numbers, names));
}
}输出结果为
[2, 3, 5, 8, 9]
Element 3 is at index 1
[2, 3, 5, 8, 9]
Are arrays equal? true
Are arrays equal? false//初始化数组 定义string类型数组ss(var可根据赋值的类型，给变量合适的类型),split(",")以,做分割，给数组赋值
var ss = "java,html,css,javascript,mysql,vue,python".split(",");
//输出数组的长度
System.out.println(ss.length);
//直接输出数组，以符号和哈希码形式输出
System.out.println(ss);
//通过Arrays.toString()方法以字符串形式输出
System.out.println(Arrays.toString(ss));
//输出数组下标为4的字符串，即第五个字符串
System.out.println(ss[4]);
//将数组遍历出来
int index = 0;
for (String s : ss) {
System.out.println(ss[index++]);
}
//将数组格式化遍历出来
for (int i = 0; i < ss.length; i++) {
System.out.printf("ss[%d] = %s%n", i, ss[i]);
}
//将数组格式化倒序遍历出来
for (int i = ss.length - 1; i >= 0; i--) {
System.out.printf("ss[%d] = %s%n", i, ss[i]);
}
3 数组排序
冒泡排序
详细可参考另一篇文章 http://t.csdn.cn/er9TT冒泡排序是一种简单的排序算法，它通过不断交换相邻的元素，将最大（或最小）元素逐渐“冒泡”到数组的末尾，从而实现排序。
public class Text2 {
public static void main(String[] args) {
Random ra = new Random();
int[] aa=new int[10];
//用随机数赋予数组值
for (int i = 0; i < aa.length; i++) {
aa[i]=ra.nextInt(1,101);
}
System.out.println("初始化数组"+Arrays.toString(aa));
for (int i = 0; i < aa.length-1; i++) {
for (int j = 0; j < aa.length-1-i; j++) {
//> 升序 <降序
if (aa[j]>aa[j+1]){
int t =aa[j];
aa[j]=aa[j+1];
aa[j+1]=t;
}
}
}
System.out.println("排序后数组(升序)"+Arrays.toString(aa));
}
}
实现乱序（洗牌）只需把aa[j]>aa[j+1]更换为Math.random()>.5即可，要想更乱，多来几次就行
int[] ns = {1, 9, 3, 20, 35, 16, 5, 2, 0};
System.out.println(Arrays.toString(ns));
//升序，int类型只支持升序
Arrays.sort(ns);
System.out.println(Arrays.toString(ns));
//输出
[1, 9, 3, 20, 35, 16, 5, 2, 0]
[0, 1, 2, 3, 5, 9, 16, 20, 35]Arrays.sort()升序降序乱序 用Lambda表达式实现
Integer[] ns = {1, 9, 3, 20, 35, 16, 5, 2, 0};
System.out.println(Arrays.toString(ns));
//升序
Arrays.sort(ns);
//Arrays.sort(ns, (a, b) -> a - b);
System.out.println(Arrays.toString(ns));
//降序
Arrays.sort(ns, (a, b) -> b - a);
System.out.println(Arrays.toString(ns));
//乱序（洗牌） 可以多洗几次，数组更乱
Arrays.sort(ns, (a, b) -> Math.random() > .5 ? 1 : -1);
System.out.println(Arrays.toString(ns));
//输出
[1, 9, 3, 20, 35, 16, 5, 2, 0]
[0, 1, 2, 3, 5, 9, 16, 20, 35]
[35, 20, 16, 9, 5, 3, 2, 1, 0]
[2, 5, 0, 1, 9, 3, 16, 20, 35]
用户自定义对象排序
声明类对象，最好要实现ComparableComparable<Student> 实现默认排序规则首先新建一个类Student对象并实现 ComparableComparable<Student> 定义四个类private int id;
private String name;
private LocalDate birth;
private int score;
按Alt+insert生成构造器（Constructor），get set方法，toString()方法以及compareTo方法（鼠标右击选择Generate..也可以）
有快捷方法只需安装lombok组件即可快速生成，感兴趣的可以看另一篇文章
http://t.csdn.cn/0qSxv
public class Student implements Comparable<Student> {
private int id;
private String name;
private LocalDate birth;
private int score;
public LocalDate getBirth() {
return birth;
}
public void setBirth(LocalDate birth) {
this.birth = birth;
}
public Student(int id, String name, LocalDate birth, int score) {
this.id = id;
this.name = name;
this.birth = birth;
this.score = score;
}
@Override
public String toString() {
return "Student{" +
"id=" + id +
", name='" + name + '\'' +
", birth=" + birth +
", score=" + score +
'}';
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getScore() {
return score;
}
public void setScore(int score) {
this.score = score;
}
@Override
public int compareTo(Student o) {
//默认return 0;根据compareTo的具体参数进行排序
// b.score-a.score 成绩降序
return id - o.id; //根据对象的id升序
}
}import java.time.LocalDate;
import java.util.Arrays;
public class ArrSort5 {
public static void main(String[] args) {
Student[] ss = new Student[]{new Student(10, "李四", LocalDate.of(2001, 3, 16), 90), new Student(25, "张三丰", LocalDate.of(2012, 9, 15), 30), new Student(12, "赵六", LocalDate.of(1998, 3, 16), 95), new Student(35, "李现", LocalDate.of(2020, 9, 15), 80), new Student(66, "周勇", LocalDate.of(2010, 7, 21), 10)};
Arrays.sort(ss);//根据实体类方法的设定输出，默认升序，我们设置的是根据对象的id升序
System.out.println(Arrays.toString(ss));
Arrays.sort(ss, (a, b) -> b.getBirth().compareTo(a.getBirth()));//根据日期
System.out.println(Arrays.toString(ss));
Arrays.sort(ss, (a, b) -> a.getName().compareTo(b.getName()));//根据名字
System.out.println(Arrays.toString(ss));
}
}输出
4 多维数组
//一维 int[ ] i = new int[3]; //二维 int[ ][ ] a2 = new int[2][3]; //三维 int[ ][ ][ ] a3 = new int[1][2][3]; //n维数组 int[ ][ ][ ][ ][ ][ ][ ][ ][ ] num;
二维数组是一种特殊的数组形式，它由多个一维数组（也称为行）组成，并且每个一维数组具有相同的长度（也称为列）。二维数组可以看作是一个表格或矩阵的结构。在Java中，可以通过使用方括号（[]）声明和初始化二维数组。 type[ ][ ] arrayName = new type[rowSize][columnSize];
public class TwoDimensionalArray {
public static void main(String[] args) {
// 声明和初始化一个3x3的二维数组
int[][] twoDArray = new int[3][3];
// 给二维数组赋值
twoDArray[0][0] = 1;
twoDArray[0][1] = 2;
twoDArray[0][2] = 3;
twoDArray[1][0] = 4;
twoDArray[1][1] = 5;
twoDArray[1][2] = 6;
twoDArray[2][0] = 7;
twoDArray[2][1] = 8;
twoDArray[2][2] = 9;
// 访问二维数组中的元素
int value = twoDArray[1][2]; // 获取第2行第3列的元素值
System.out.println("二维数组的长度：" + twoDArray.length);
System.out.println("获取的元素值：" + value);
}
}
二维数组的长度：3
获取的元素值：6三维数组是数组的一种特殊形式，它是一个多维数组，由多个二维数组组成。可以将它想象为由多个平行的二维数组构成的数据结构。
三维数组可以用于表示三维空间中的数据，例如三维坐标系中的点，立方体中的像素数据或者各种三维矩阵。
在Java中，可以通过一个以逗号分隔的方括号（[ ]）序列来声明和初始化三维数组。每个维度都可以有不同的长度，表示数组的大小。
public class ThreeDimensionalArray {
public static void main(String[] args) {
// 声明和初始化一个3x3x3的三维数组
int[][][] threeDArray = {
{ {1, 2, 3}, {4, 5, 6}, {7, 8, 9} },
{ {10, 11, 12}, {13, 14, 15}, {16, 17, 18} },
{ {19, 20, 21}, {22, 23, 24}, {25, 26, 27} }
};
// 访问三维数组中的元素
int value = threeDArray[1][2][0]; // 获取第2个二维数组的第3个元素的第1个元素
System.out.println("三维数组的长度：" + threeDArray.length);
System.out.println("获取的元素值：" + value);
}
}
三维数组的长度：3
获取的元素值：16public class Text1 {
public static void main(String[] args) {
String s;
String[] s1;
String[][] s2;
String[][][] s3;
String[][][][] s4;
String[][][][][] s5;
//声明初始化二维数组
int[][] i2 = {{1, 2, 3}, {11, 22}, {333}};
var i3 = new int[][]{{1, 2, 3}, {11, 22}, {333}};
System.out.println(i3[2][0]);
for (int[] nn : i2) {
for (int t : nn) {
System.out.print(t + " ");
}
System.out.println();
}
for (int i = 0; i < i2.length; i++) {
for (int j = 0; j < i2[i].length; j++) {
System.out.printf("i2[%d][%d] = %d ", i, j, i2[i][j]);
}
}
}
}文章出处登录后可见！
已经登录？立即刷新
