---

JAVA数组Array

数组

什么是数组

• 相同数据类型的元素组成的集合。
• 这些元素按线性顺序排列。所谓线性顺序是指除第一个元素外，每一个元素都有唯一的前驱元素；除最后一个元素外，每一个元素都有唯一的后继元素（“一个跟一个”）。
• 可以通过下标的方式访问数组中的每一个元素。
  

数组的创建

• 数组类型变量按照如下等号左边的方式声明。
• 等号右边创建数组对象。

数组的初始化

• 基本类型的数组（数据元素为基本类型）创建后，其元素的初始值：byte、short、char、int、long为0；float和double为0.0；Boolean为false。
• 可以在数组声明的同时进行初始化。（这种初始化方式只能用于声明时初始化，不能用于赋值。）
  

数组的赋值

• 可以通过如下方式给数组类型变量（引用）赋值。
  

数组的访问

• 调用数组的length属性可以获取数组的长度：

int len = arr.length;

• 可以通过下标的方式访问数组中的每一个元素。需要注意的是：数组的下标从0开始，对于长度为n的数组，下标的范围是0~(n-1)。

int tmp = a[2];
//swap(arr[i],arr[i+1])
int temp = arr[i];
arr[i] = arr[i+1];
arr[i+1] = temp;

数组复制

• JDK提供对数组进行复制的方法，即将一个数组（源数组）中的各个元素值复制到另一个数组（目标数组）中。

System.arraycopy(src, srcPos, dest, destPos, length);
//	src——要复制的源数组
//	srcPos——从源数组复制的起始位置
//	dest——复制到的目标数组
//	destPos——复制到目标数组中的起始位置
//	length——要复制的元素个数

	int[] arr = {1,2,3,4,5,6};
	int[] arr1 = arr;
	arr = new int[arr.length + 1];
	System.arraycopy(arr1, 0, arr, 0, arr1.length);
	arr[6] = 7;
	System.out.println(Arrays.toString(arr));

• 还可以通过Arrays.copyOf方法实现数组扩展

dst = Arrays.copyOf(src, src.length + 1);
//src——源数组
//dst——扩展后数组
//src.length + 1 ——扩展后的长度

	int[] arr = {1,2,3,4,5,6};
	int[] arr1 = arr;
//	arr = new int[arr.length + 1];
//	System.arraycopy(arr1, 0, arr, 0, arr1.length);
	arr = Arrays.copyOf(arr1, arr1.length + 1);
	arr[6] = 7;
	System.out.println(Arrays.toString(arr));

数组扩展

• 数组的长度在创建后是不可改变的。所谓扩展是指扩建一个更大的新数组并将原来数组的内容复制到其中。

int[] arr = {1,2,3,4,5,6};
int[] arr1 = arr;
arr = new int[arr.length + 1];
System.arraycopy(arr1, 0, arr, 0, arr1.length);
arr[6] = 7;
System.out.println(Arrays.toString(arr));

代码示例

求数组的最大值并放在最后一位

• MaxOfArray.java

package day01;

import java.util.Random;
import java.util.Arrays;

public class MaxOfArray {

	public static void main(String[] args) {
		//创建一个10个长度的
		int[] arr = new int[10];
		
		//随机生成10个0-99之间的数值，放入数组
		Random ran = new Random();
		for(int i = 0; i < arr.length; i++)
		{
			arr[i] = ran.nextInt(100);
		}
		
		//打印数组中的数据
		System.out.println("数组中的数据为：" + Arrays.toString(arr));
		
		//查询最大值
		int max = arr[0];
		for(int i = 1; i < arr.length; i++)
		{
			if(max < arr[i])
			{
				max = arr[i];
			}
		}
		
		System.out.println("最大值是：" + max);
		
		//创建新数组
		arr = Arrays.copyOf(arr, arr.length + 1);
		
		//最大值放入最后一个位置，并打印新数组内容
		arr[arr.length - 1] = max;
		System.out.println("最新数组中的数据为：" + Arrays.toString(arr));
		
	}

}

• 执行结果
  

Arrays核心API

• JDK中的java.utils.Arrays类提供对数组操作的一系列实用方法：

//toString方法用于字符串表示数组元素
//Arrays.toString
//equals方法用于比较两个数组的各个元素是否相等
//Arrays.equals
int[] arr1 = {1,2,3,4,5,6,7,8,9};
int[] arr2 = {1,2,3,4,5,6,7,8,9};
System.out.println(Arrays.toString(arr1));
System.out.println(Arrays.equals(arr1,arr2));

• Arrays.sort方法用于实现数组的排序。

int[] arr = {40, 92, 1, 54, 22, 33,88, 18};
String[] names = {"Oscar", "Edgar", "Frank", "Laurent", "Hugo", "Jacob", "Aaron", "Gino", "Angus", "Ken"};
//按照数值大小顺序排序
Arrays.sort(arr);
//按照字典顺序排序
Arrays.sort(names);

System.out.println(Arrays.toString(arr));
System.out.println(Arrays.toString(names));

• Arrays.binarySearch方法用于实现有序数组的二分法查找

	int[] arr = {40, 92, 1, 54, 22, 22, 33,88, 18};
	Arrays.sort(arr);
	//返回下标值
	int index = Arrays.binarySearch(arr, 88);
	System.out.println(index);
	//找不到时返回负数。
	index = Arrays.binarySearch(arr, 90);
	System.out.println(index);
	//有多个相同值不一定返回哪个。
	index = Arrays.binarySearch(arr, 22);
	System.out.println(index);

练习题

“水仙花数”问题

所谓“水仙花数”就是一个整数满足其值等于各个数位的n位次幂之和。例如：153就是一个水仙花数。

153 = 1^3 + 5^3 + 3^3

• 问题：计算1000以内的所有水仙花数。用户输入0到1000以内的某个数，系统输出这个范围内的所有
  水仙花数，水仙花数是指一个 n 位数 ( n≥3 )，它的每个位上的数字的 n 次幂之和等于它本身。(例
  如:1^3 + 5^3 + 3^3 = 153)。
• Daffodils.java

package day01;

import java.util.Scanner;
public class Daffodils {

	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		System.out.print("请输入查找水仙花的范围：0~");
		int max = scanner.nextInt();
		scanner.close();
		for(int n = 3; n <= max; n++)
		{
			int sum = 0;
			for(int m = n; m > 0; m /= 10)
			{
				int v = m % 10;
				sum += v * v *v;
			}
			if(n == sum)
			{
				System.out.print(n + " ");
			}
		}
		System.out.println("查找完毕");

	}

}

• 执行结果：
  

百钱买百鸡

计算“百钱买百鸡”的问题。
百钱买百鸡：公鸡5文钱一只，母鸡3文钱一只，小鸡1文钱3只，如何用百文钱买百只鸡？

• DaffodilsExt.java

package day01;

public class DaffodilsExt {

	public static void main(String[] args) {
		int cock, hen, chick;
		System.out.println("百钱买百鸡的方案如下：");
		for(cock = 0; cock <= 20; cock++)
		{
			for(hen = 0; hen <= 33; hen++)
			{
				chick = 100 - cock - hen;
				if(chick % 3 == 0)
				{
					int total = cock * 5 + hen * 3 + chick /3;
					if(total == 100)
					{
						System.out.println("公鸡：" + cock + "，母鸡：" + hen 
								+ "，小鸡：" + chick);
					}
				}
			}
		}

	}

}

• 执行结果
  

冒泡排序法

冒泡排序法（Bubble sort）是一种比较简单的排序算法。在冒泡排序算法中，需要重复的走访要排序的数列，一次比较两个元素，如果它们的大小顺序错误就把它们交换过来。走访数列的工作是重复进行指导没用需要交换的元素，也就是说数列已经排序完成。由于排序过程重总是小数往前放，大数往后放，类似气泡上升，所以称为冒泡排序。

• BubbleSort.java

import java.util.Random;
import java.util.Arrays;

public class BubbleSort {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int[] arr = new int[10];
		Random ran = new Random();
		for(int i = 0; i< arr.length; i++)
		{
			arr[i] = ran.nextInt(100);
		}
		
		System.out.println(Arrays.toString(arr));
		System.out.println("----------冒泡排序开始--------");
		
		for(int i = 0; i < arr.length -1 ; i++)
		{
			for(int j = 0; j < arr.length - i - 1; j++)
			{
				if(arr[j] > arr[j + 1])
				{
					int t = arr[j];
					arr[j] = arr[j + 1];
					arr[j + 1] = t;
				}
			}
		}
		
		System.out.println("---------冒泡排序结束--------");
		System.out.println(Arrays.toString(arr));
	}

}

• 执行结果