第七节、轻松学Java_数组与方法

一维数组

要使用Java 中的数组，必须先声明数组，再为数组分配内存空间。一维数组的声明有两种方式，一般语法格式如下：
数据类型 数组名[];
数据类型[] 数组名;
数组对象有一个属性length，可以用来获取数组的元素个数，称为数组长度。

package com.test;

public class Test {
	public static void main(String[] args) {
		//声明一个数组，并为其分配内存空间
		int[] ar1;
		ar1=new int[3];
		//默认值为0
		System.out.println("ar1[0]="+ar1[0]);
		System.out.println("ar1[1]="+ar1[1]);
		System.out.println("ar1[2]="+ar1[2]);
		
		//下面两种方式均可创建数组
		int[] ar2=new int[3];
		int[] ar3= {1,4,5};
		ar2[0]=1;
		ar2[2]=3;
		for(int i=0;i<ar2.length;i++)
		{
			System.out.print(ar2[i]+",");
			System.out.println(ar3[i]);
		}
	}
}

输出：
ar1[0]=0
ar1[1]=0
ar1[2]=0
1,1
0,4
3,5

初始化数组：
在定义数组时，指定数组的长度，并由系统自动为元素赋初值，这些称为动态初始化。
数组的初始化还有一种静态方式，就是在定义数组的同时就为数组的每个元素赋值。数组的静态初始化有两种方式，具体格式如下：
类型[] 数组名 = new 类型[]{元素，元素，…};
类型[] 数组名 = {元素，元素，…};

package com.test;

public class Test {
	public static void main(String[] args) {
		//静态初始化
		int[] ar1=new int[] {1,2,3};
		int[] ar2= {1,4,5};
		ar1[0]=1;
		ar1[2]=3;
		//加强型循环，它能在不使用索引的情况下遍历数组。
		for(int x:ar2)
		{
			System.out.print(x+",");
		}
	}
}

输出：
1,4,5,

多维数组

声明二维数组时，也可以直接对数组赋值，将赋给数组的值放在大括号中，多个数值之间使用逗号(,)隔开。
数据类型 数组名[ ][ ] = {{初值1，初值2，初值3}，{初值4，初值5，初值6}，…}；

package com.test;

public class Test {
	public static void main(String[] args) {
		//静态初始化
		int[][] ar1= {{1,2,3},{4,5,6},{7,8,9}};
		String[][] ar2= new String[1][3];
		ar2[0][0]="Hello";
		ar2[0][1]=" World";
		ar2[0][2]="!";
		//加强型循环，它能在不使用索引的情况下遍历数组。
		for(int i=0;i<1;i++)
		{
			for(int j=0;j<ar2[i].length;j++)
			{
				System.out.print(ar2[i][j]);
			}
		}
		System.out.println();
		for(int i=0;i<ar1.length;i++)
		{
			for(int j=0;j<ar1[i].length;j++)
			{
				System.out.print(ar1[i][j]+"\t");
			}
			System.out.println();
		}
	}
}

输出：
Hello World!
1 2 3
4 5 6
7 8 9

数组排序

Java API 提供了一个数组类Arrays（java.util.Arrays），能方便地操作数组，它提供的所有方法都是静态的。

sort()方法

package com.test;

import java.util.Arrays;
public class Test {
	public static void main(String[] args) {
		int[] ar= {2,3,1,6,5};
		Arrays.sort(ar);
		for(int i=0;i<ar.length-1;i++)
		{
			System.out.print(ar[i]+",");
		}
		System.out.println(ar[ar.length-1]);
		
	}
}

输出：
1,2,3,5,6

binarySearch()方法

binarySearch(Object[] a, Object key)

• 搜索值不是数组元素，且在数组元素值范围内，从1 开始计数，返回“-”后跟插入点索引。
• 搜索值是数组元素，从0 开始计数，返回搜索值的索引。
• 搜索值不是数组元素，且大于数组内的所有元素，索引为**-(length +1)**
• 搜索值不是数组元素，且小于数组内的所有元素，索引为**-1**。

package com.test;

import java.util.Arrays;
public class Test {
	public static void main(String args[]) {
		int[] arr = { 4, 3, 1, 9, 5, 8 };
		Arrays.sort(arr);// 排序后为{1,3,4,5,8,9}
		int s1 = Arrays.binarySearch(arr, 6);
		int s2 = Arrays.binarySearch(arr, 4);
		int s3 = Arrays.binarySearch(arr, 10);
		int s4 = Arrays.binarySearch(arr, 0);
		System.out.println("s1 = " + s1);
		System.out.println("s2 = " + s2);
		System.out.println("s3 = " + s3);
		System.out.println("s4 = " + s4);
	}
}

输出：
s1 = -5
s2 = 2
s3 = -7
s4 = -1

binarySearch(object[] a, int fromIndex, int endIndex, object key)

• 该搜索键在指定范围内，但不是数组元素，由1 开始计数，返回“-”后跟插入点索引。
• 该搜索键在指定范围内，且是数组元素，由0 开始计数，返回搜索值的索引。
• 该搜索键不在指定范围内，且小于指定范围（数组）内元素，返回-(fromIndex+1)。
• 该搜索键不在指定范围内，且大于指定范围（数组）内元素，返回-(toIndex+1)。

package com.test;

import java.util.Arrays;
public class Test {
	public static void main(String args[]) {
		int arr[] = { 1, 3, 4, 5, 8, 9 };
		Arrays.sort(arr);
		int s1 = Arrays.binarySearch(arr, 1, 3, 6);
		int s2 = Arrays.binarySearch(arr, 1, 3, 4);
		int s3 = Arrays.binarySearch(arr, 1, 3, 2);
		int s4 = Arrays.binarySearch(arr, 1, 3, 10);
		int s5 = Arrays.binarySearch(arr, 1, 3, 0);
		System.out.println("s1 = " + s1);
		System.out.println("s2 = " + s2);
		System.out.println("s3 = " + s3);
		System.out.println("s4 = " + s4);
		System.out.println("s5 = " + s5);
	}
}

输出：
s1 = -4
s2 = 2
s3 = -2
s4 = -4
s5 = -2

方法中使用数组作为参数

这里其实也就是引用传递：

package com.test;

public class Test {
	public static void change(char[] c, int length) {
		for (int i = 0; i < length; i++) {
			if (c[i] == 'l') { // 修改形参数组元素
				c[i] = 'w'; // 将形参数组中所有字符l 修改为w
				// System.out.println("ok");
			}
		}
	}

	public static void main(String[] args) {
		char array[] = { 'h', 'e', 'l', 'l', 'o', 'j', 'a', 'v', 'a' };
		// 使用for 循环，输出原数组元素
		System.out.println("调用方法前，数组元素：");
		for (int i = 0; i < array.length; i++) {
			System.out.print(array[i] + " ");
		}
		System.out.println();
		// 调用方法改变数组中的元素
		change(array, array.length);
		// 使用for 循环，输出更改后的数组元素
		System.out.println("调用方法后，数组元素：");
		for (int i = 0; i < array.length; i++) {
			System.out.print(array[i] + " ");
		}
	}
}

输出：
调用方法前，数组元素：
h e l l o j a v a
调用方法后，数组元素：
h e w w o j a v a