java 数组的使用

数组

基本介绍

数组可以存放多个同一类型的数据，数组也是一种数据类型，是引用类型。

即：数组就是一组数据。

数组的使用

1、数组的定义

方法一 -> 单独声明
数据类型[] 数组名 = new 数据类型[大小]
说明：int[] a = new int[5]; //创建一个数组，名字a，存放5个int。没有具体数据，默认值为0

方法一 -> 单独声明
单独声明： new 类型[]{1,2,3,4};  -> new int[]{1,2,3,4,5}; 

方法二： -> 先声明，再new
int[] a;   //先声明
a = new int[5]; // 再new

方法三 静态初始化：
数据类型 数组名[] = {元素值，元素值...}
int[] a = {2,3,4,5,6,7}

声明空数组: new int[0]
//上面指定数字的，都是赋默认值，只有大括号中的，才是真正的赋值。


// 方式一：
int[] x = new int[3];
// 方式二：
int[] y;
y = new int[3];
// 方式三：
int[] z = new int[]{1, 2, 3, 4, 5, 6};
// 方式四：
int[] a = {13, 2, 3, 32, 325, 13, 25};

2、数组的引用

数组名[下标/索引]

注意细节

1、数组是多个相同数据类型的组合，实现对这些数据的同意管理。【或者满足自动转换】

double[] array1 = {1.1, 2.2, 3.3, 4};  // 4可以自动转换为小数。   

2、数组中的元素可以是任何数据类型，包括基本类型和引用类型。但是不能混用。

3、数组创建后，如果没有赋值，则有默认值。

int、short、byte、long： 0

boolean： flase

String：null

float、double： 0.0

char：\u0000

4、数组的下标是从 0 开始的。

5、数组的下标必须在范围内调用。否则报：下标越界异常

6、数组是引用类型，数组型数据是对象（object）

数组赋值机制

1、基本数据类型赋值，这个值是具体的数据，而且相互不影响，赋的是值。

2、数组在默认情况下是引用传递，赋的值是地址。

值传递/值拷贝 和 引用传递/地址拷贝 的区别

数据拷贝

public class Array01{
	public static void main(String[] args){
		int[] arr1 = {10, 20, 30};
		// 1、创建一个新的数组arr2，开辟新的空间，大小为arr1.length
		int[] arr2 = new int[arr1.length];
		for (int i=1; i<arr2.length; i++) {
			arr2[i] = arr1[i];
		}

		arr2[0] = 100;//修改arr2不会对arr1产生影响
		for (int i=0; i<arr2.length; i++) {
			System.out.println(arr2[i]);
			
		}
	}
}

数组反转

将数组中的元素前后转换

public class Array01{
	public static void main(String[] args){
		int[] arr1 = {11,22,33,44,55,66,77};

		int len = arr1.length;
		for (int i=0; i <= len/2-1; i++) {
			int temp = arr1[i];
			arr1[i] = arr1[len-1-i];
			arr1[len-1-i] = temp;
		}
      
		for (int i=0; i<len; i++) {
			System.out.println(arr1[i]);
		}
	}
}

总结：这种反转的，从中间往两边扩的问题，全部的中间判断都是 i<(arr.length / 2)

数组添加

实现动态的给数组添加元素，实现对数组的扩容

1、原始数组使用静态分配： int[] arr = {1,2,3};

2、增加元素，直接放在数组的最后：arr = {1,2,3,4}

3、用户可以通过如下方法来决定是否继续添加。添加成功，是否继续添加? Y\N

import java.util.Scanner;
public class Array01{
	public static void main(String[] args){
		int[] arr1 = {1,2,3};

		while(true){
			System.out.println("是否添加？ y/n");
			Scanner myScanner = new Scanner(System.in);
			char answer = myScanner.next().charAt(0);
			if (answer == 'y'){
				System.out.println("请输入添加的值");
				int addNum = myScanner.nextInt();
                
                // 创建新的数组用于添加元素。
				int[] arr2 = new int[arr1.length + 1];
				for (int i=0; i < arr1.length; i++) {
					arr2[i] = arr1[i];
				}
				arr2[arr2.length-1] = addNum;
				arr1 = arr2;
				System.out.println("数据添加成功");
				for(int i=0; i<arr1.length; i++){
					System.out.print(arr1[i] + "\t");
				}
			} else{
				break;
			}	
		}
	}
}

排序

排序是将一组数据，按照指定的顺序进行排列的过程。【之后详细介绍】

排序的分类：

1、内部排序

指将需要处理的所有数据都加载到内部存储器中进行排序，包括（交换式排序法，选择式排序法和插入式排序法）

2、外部排序法

数据量过大，无法全部加在到内存中，需要借助外部存储进行排序。包括（合并排序法和直接合并排序法）

冒泡排序：

冒泡排序的特点：

方法一：

public class Array01{
	public static void main(String[] args){
		int[] arr1 = {1,8,7,4,6,5};
		for (int i=0; i<(arr1.length-1); i++) {
			for (int z = i; z<arr1.length; z++) {
				if (arr1[i] > arr1[z]){
					int temp = arr1[z];
					arr1[z] = arr1[i];
					arr1[i] = temp;
				}
			 } 
		}

		for (int i=0; i<arr1.length; i++) {
			System.out.println(arr1[i]);
		}

	}
}

方法二

public class Array01{
	public static void main(String[] args){
		int[] arr1 = {1,8,7,4,3,5};
		for (int x=0; x<arr1.length-1; x++) {
			for (int i=0; i<arr1.length-1-x; i++) {
				if (arr1[i] > arr1[i+1]){
					int temp = arr1[i+1];
					arr1[i+1] = arr1[i];
					arr1[i] = temp;
				}
			}

			for (int z=0; z<arr1.length; z++) {
				System.out.print(arr1[z] + "\t");
			}
			System.out.println();
		}
	}
}