【Java基础】一维数组

1.数组的基础知识

数组是用来存储数据的集合，一旦数组被创建，它的大小是固定的。使用一个数组引用变量和下标来访问
数组中的元素。

1.1 声明数组变量

为了在程序中使用数组，必须声明一个引用数组的变量，并指明数组的元素类型。
声明一个数组变量时并不给数组分配任何内存空间。它只是创建一个对数组的引用的存储位置。如果变量不包含对数组的引用，那么这个变量的值为 null。除非数组已经被创建，否则不能给它分配任何元素。

elementType[] arrayRefVar;
elementType arrayRefVar[];  // 来自 C/C++ 语言的风格

// 声明变量 myList, 它引用一个具有 double 型元素的数组
double[] myList;

1.2 创建数组

声明数组变量之后，可以使用下面的语法用 new 操作符创建数组，并且将它的引用赋给一个变量

arrayRefVar = new elementType[arraySize] ;

//声明一个数组变量、创建数组、将数组引用赋值给变量这三个步骤可以合并在一条语句里
elementType[] arrayRefVar = new elementType[arraySize] ;

double[] myList = new double[10] ;

一个数组变量看起来似乎是存储了一个数组，但实际上它存储的是指向数组的引用。严格地讲，一个数组变量和一个数组是不同的，但多数情况下它们的差别是可以忽略的。因此,为了简化,通常可以说 myList 是一个数组，而不用更长的陈述：myList是一个含有 double 型元素数组的引用变量。

当给数组分配空间时，必须指定该数组能够存储的元素个数，从而确定数组大小。创建数组之后就不能再修改它的大小。

1.3 数组元素

数组元素可以通过下标访问。数组下标是基于 o 的，也就是说，其范围从 0 开始到arrayRefVar.length-1结束。

创建数组后，下标变量与正常变量的使用方法相同。

int[] a = new int [10];
a[0] = 1;

Java 有一个简捷的标记，称作数组初始化简写方式，它使用下面的语法将声明数组、创建数组和初始化数组结合到一条语句中

int[] a = {1,2,3};

//使用数组初始化简写方式时，必须将声明、创建和初始化数组都放在一条语句中。将它们分开会产 生语法错误。
//下面是错误的
double[] myList;
myList = {1.9, 2.9, 3.4, 3.5}; // Wrong

1.4 foreach循环

Java 支持一个简便的 for 循环，称为 foreach 循环，即不使用下标变量就可以顺序地遍历整个数组。

for (double e: myList) 
	System.out .println(e) ;

2.数组相关操作

2.1 复制数组

在 Java 中，可以使用赋值语句复制基本数据类型的变量，但不能复制数组。将一个数组变量赋值给另一个数组变量，实际上是将一个数组的引用复制给另一个变量，使两个变量都指向相同的内存地址.

复制数组有三种方法：

// 使用循环语句逐个地复制数组的元素。
int[] sourceArray = {2, 3, 1, 5, 10};
int[] targetArray = new int [sourceArray.length];
for (int i = 0; i < sourceArray.1ength; i++) {
targetArray[i ] = sourceArray [1] ;
}

// 使用 System类的静态方法arraycopy
System.arraycopy(sourceArray, srcPos, targetArray, tarPos, 1ength) ;
/*其中，参数 srcPos 和 tarPos 分别表示在源数组 sourceArray 和目标数组 targetArray 中的
起始位置。从 sourceArray 复制到 targetArray 中的元素个数由参数 length 指定。*/

arraycopy 方法没有给目标数组分配内存空间。复制前必须创建目标数组以及分配给它的内存空间。复制完成后，sourceArray 和 targetArray 具有相同的内容.但占有独立的内存空间。

2.2 将数组传递给方法

当将一个数组传递给方法时，数组的引用被传给方法

public static void printArray(int[] array) {
	for (int i = 0; 1 < array.length; i++) {
		System.out .print (array [i] + " ") ;
	}
} 

// 该数组没有显式地引用 变量，这样的数组称为匿 名数组 (anonymous array)
printArray(new int[]{3, 1, 2, 6, 4, 2});

// 直接传数组变量
int[] array = {1,2,3};
printArray(array);

Java 使用按值传递 (pass-by-value) 的方式将实参传递给方法。传递基本数据类型变量的值与传递数组值有很大的不同。

对于基本数据类型参数，传递的是实参的值，即一个副本。改变里面的形参，不会影响外面的实参。
对于数组类型参数，参数值是数组的引用，给方法传递的是这个引用。从语义上来讲，最好的描述为传递共享信息 (pass-by-sharing), 即方法中的数组和传递的数组是一样的。因此，如果改变方法中的数组，将会看到方法外的数组也改变了。

数组在 Java 中是对象。JVM 将对象存储在一个称作堆(heap) 的内存区域中，堆用于动态内存分配。

2.3 方法返回数组

当方法返回一个数组时，数组的引用被返回。

public static int[] creareArray(int n){
	int[] res = new int[n];
	for(int i=0;i<n;i++)
		res[i]=i;
	return res;
}

2.4 可变长参数列表

具有同样类型的数目可变的参数可以传递给方法，并将作为数组对待。
在方法声明中，指定类型后紧跟着省略号 (…)。

只能给方法中指定一个可变长参数
该参数必须是最后一个参数。任何常规参数必须在它之前。
Java 将可变长参数当成数组对待。可以将一个数组或数目可变的参数传递给可变长参数。当用数目可变的参数调用方法时，Java 会创建一个数组并把参数传给它。

public static void printMax(double... num){
	if (numbers.length == 0) {
		System.out .println( "No argument passed") ;
		return;
	}
	double result = numbers[0] ;
	for (int i = 1; i < numbers.length; i++)
		if (numbers[i] > result)
			result = numbers[i];
	System.out .println ( "The max value is " + result) ;
}

printMax(1,3,8,5,6);
// 传入多个参数，传进去之后形成一个数组。
}

3.数组查找算法

查找 (searching) 是在数组中寻找特定元素的过程

// 线性查找法
public static int 1inearSearch(1nt[ ] list, int key) {
	for (int 1 = 0; i < list.length; 1++) {
		if (key == list[i])
			return i; 
	} 
	return -1;
} 

// 二分查找
public static int binarySearch(int[] list, Int key) {
	int low = 0;
	int high = 1ist.1ength - 1;
	while (high >= low) {
		int mid = (low + high) / 2;
		if (key < list(mid])
			high = mid - 1
		else if (key == list[mid] )
			return mid;
		else
			low = mid + 1;
	}
	return -1; II Not found
}

4.Arrays类

java.util.Arrays 类包含一些实用的方法用于常见的数组操作，比如排序和查找

可以使用 sort 或者 parallelSort 方法对整个数组或部分数组进行排序。

double[] numbers = {6.0, 4.4, 1.9, 2.9, 3.4, 3.5};
java.util.Arrays.sort(numbers) ; // Sort the whole array
java.util.Arrays.parallelSort(numbers) ; // Sort the whole array

char[] chars = {'a' , 'A', '4' , 'F' , 'D' , 'P'};
java.util.Arrays.sort(chars, 1, 3) ; // Sort part of the array
java.util.Arrays.parallelSort(chars, 1, 3) ; / / Sort part of the array

采用二分查找法 ( binarysearch 方法) 在数组中查找关键字。数组必须提前按升序排好。如果数组中不存在关键字，方法返回 -(insertionlndex+1)

int[] list = {2, 4, 7, 10, 11 , 45, 50, 59, 60, 66, 69, 70, 79};
System. out.println("1. Index is " +
java.util.Arrays.binarySearch(list, 11) ) ;
System.out .print1n("2. Index is " +
java .uti1.Arrays.binarySearch(list, 12) ) ;
char[] chars = {'a' , 'c' , 'g' , 'x' , 'y' , 'z'};
System.out.println ( "3. Index is " +
java.uti1.Arrays.binarySearch(chars, ' a' ) ) ;
System.out.printin("4. Index is " +
java.util.Arrays.binarySearch(chars, 't' ) ) ;

采用 equals 方法检测两个数组是否严格相等。如果它们对应的元素都相等，那么这两个数组严格相等。

int[] listl = {2, 4, 7, 10};
int[] list2 = {2, 4, 7, 10};
int[] list3 = {4, 2, 7, 10};
System.out.print1n ( java.util.Arrays.equals(1ist1, list2)) ; // true
System.out.print1n ( java.util.Arrays.equals(1ist2, 1ist3) ); // false

使用 toString 方法来返回一个字符串，该字符串代表了数组中的所有元素。

int[] list = {2, 4, 7,10};
System.out.println( java.util.Arrays.toString(list) ) ;

使用fill 方法填充整个数组或部分数组。

nt[] listl = {2, 4, 7, 10};
int[] list2 = {2, 4, 7, 7, 7, 10};
java.util .Arrays.fill(listl, 5); // Fi11 5 to the whole array
java.util.Arrays.fill(list2, 1, 5, 8) ; // Fill 8 to a partial array