Java自学之数组

在Java中数组是一组相关变量的集合，属于引用数据类型。

定义

// 声明并开辟数组
数据类型 数组名称 [] = new 数据类型[长度];
数据类型 [] 数组名称 = new 数据类型[长度];
// 分布完成
// 声明数组
数据类型 数组名称 [] = null;
// 开辟数组
数组名称 = new 数据类型 [长度];

public class ArrayDemo {
	public static void main(String args[]) {
        // 动态初始化数组
		int data [] = new int [3];
		data[0] = 11;
		data[1] = 12;
		data[2] = 13;
		for (int x = 0; x < data.length; x++) {
			System.out.println(data[x] + "、");
		}
        // 静态初始化数组
        int data1[] = new int[] {11,12,13};
        for (int x = 0; x < data1.length; x++) {
			System.out.println(data1[x] + "、");
		}
	}
}

数组引用传递分析

数组属于引用数据类型，在数组使用时需要通过关键字new开辟堆内存空间，一块堆内存空间也可以同时被多个栈内存指向，进行引用数据操作。不能直接使用未开辟堆内存空间的数组。

foreach输出

class ArrayDemo {
	public static void main(String[] args) {
		int data[] = new int[] {11,12,13};
		for (int temp : data) {
			System.out.print(temp + "、");
		}
	}
}

二维数组

定义

// 动态初始化
数据类型 数组名称[][] = new 数据类型[行的个数][列的个数];
// 静态初始化
数据类型 数组名称[][] = new 数据类型[][] {{值,值,..},{值,值,..}}

class ArrayDemo {
	public static void main(String[] args) {
		int data[][] = new int[][] {{1,2,3,4,5},{6,7,8,9},{10,11,12,13}};
		for(int i = 0; i < data.length; i++){
			for (int j = 0; j < data[i].length; j++) {
				System.out.print("data[" + i + "][" + j + "] = " + data[i][j])
			}
			System.out.println();
		}
	}
}

数组排序

class ArrayUtil {
	/**
	* 数组排序处理
	* @param data 要排序的数组内容
	*/
	public static void sort(int data[]){
		for (int x = 0; x < data.length; x++) {
			for (int y = 0; y < data.length - x - 1; y++) {
				if (data[y] > data[y + 1]) {
					int temp = data[y];
					data[y] = data[y + 1];
					data[y + 1] = temp;
				}
			}
		}
	}
	public static void printArray(int temp[]) {
		for (int x = 0; x < temp.length; x++) {
			System.out.print(temp[x] + "、");
		}
		System.out.println();
	}
}

class ArrayDemo {
	public static void main(String[] args) {
		int data[] = new int[] {8,2,7,5,12,6,10,1,3,9};
		ArrayUtil.sort(data);
		ArrayUtil.printArray(data);
	}
}

方法可变参数

为了方便开发者可以更加灵活地定义方法，避免方法中参数的执行限制，所以Java提供了方法可变参数的支持，利用这一特点可以在方法调用时采用动态形式传递若干个参数数据，可变参数定义语法如下。

public [static] [final] 返回值类型 方法名称 (参数类型 ...变量) {
	[return [返回值];]
}

在进行方法参数定义的时候有了一些变化(参数类型 …变量)，而这个时候的参数可以说就是数组形式，即：在可变参数中，虽然定义的形式不是数组，但却是按照数组方式进行操作的。

class ArrayUtil {
	/**
	* 计算给定参数数据的累加结果
	* @param data 要进行累加的数据，采用可变参数，本质上属于数组
	* @return 返回累加结果
	*/
	public static int sum(int... data) {
		int sum = 0;
		for (int temp : data) {
			sum += temp;
		}
		return sum;
	}
}

class ArrayDemo {
	public static void main(String[] args) {
		System.out.println(ArrayUtil.sum(1,2,3));
		System.out.println(ArrayUtil.sum(new int[] {1,2,3}));
	}
}

混合参数

方法中可以接受普通参数和可变参数。两种参数一起使用时，可变参数一定要定义在最后，并且一个方法中只允许定义一个可变参数，普通参数必须传递，而可变参数可以根据需求传递。

class ArrayUtil {
	public static void sum(String name, String url, int... data) {
		...
	}
}

对象数组

在Java中所有的数据类型均可以定义为数组，即除了基本数据类型的数据定义为数组外，引用数据类型也可以定义数组，这样的数组就称为对象数组，对象数组的定义可以采用以下的形式完成。

// 对象数组动态初始化
类 对象数组名称 [] = new 类 [长度];
// 对象数组静态初始化
类 对象数组名称 [] = new 类 [] {实例化对象,实例化对象,...};

class Person {
	private String name;
	private int age;
	public Person(String name,int age){
		this.name = name;
		this.age = age;
	}
	public String getInfo(){
		return "姓名：" + this.name + "、年龄：" + this.age;
	}
}

class ArrayDemo {
	public static void main(String[] args) {
        // 动态初始化对象数组
		Person per[] = new Person[3];
		per[0] = new Person("刘备", 20);
		per[1] = new Person("关羽", 19);
		per[2] = new Person("张飞", 18);
		for (int x = 0; x < per.length; x++) {
			System.out.println(per[x].getInfo());
		}
        // 静态初始化对象数组
        Person per1[] = new Person[] {
            new Person("刘备", 20),new Person("关羽", 19),new Person("张飞", 18)
        }
        for (int x = 0; x < per.length; x++) {
			System.out.println(per1[x].getInfo());
		}
	}
}

原创文章，作者：ZERO，如若转载，请注明出处：https://www.edu24.cn/course/java/java-learn-array.html