数组
1 数组概述
数组是具有相同数据类型的一-组数据的集合。例如，球类的集合一-足球、 篮球、羽毛球等;电器集合一电视机、 洗衣机、电风扇等。在程序设计中，可以将这些集合称为数组。数组中的每个元素具有相同的数据类型。在Java中同样将数组看作是一个对象，虽然基本数据类型不是对象，但是由基本数据类型组成的数组则是对象。在程序设计中引入数组可以更有效地管理和处理数据。可根据数组的维数将数组分为一维数组、二维数组…
2 一维数组的创建与使用
2.1 创建一维数组
数组作为对象允许使用new关键字进行内存分配。在使用数组之前，必须首先定义数组变量所属的类型，一维数组的创建有两种方式。
1. 先声明，再用new运算符进行内存分配
数组元素类型 名字[];
数组元素类型[] 名字;
//具体声明如下：
int arr[];
String str[];
声明数组后还不能立即访问它的任何元素，因为声明数组只是给出了数组名字和元素的数据类型，要想使用数组，还要为它分配内存空间，必须指明数组的长度，格式如下：
数组名字 = new 数组元素的类型[数组元素的个数];
//实例代码如下：
arr = new int[5];
注意：使用new关键字为数组分配内存时，整型数组中各个元素的初始值都为0
2. 声明的同时为数组分配内存 ：(java)中普遍使用的方法
语法如下：
数组元素的类型 数组名 = new 数组元素的类型[数组元素个数]
//实例代码如下：
int month[] = new int[12];
2.2 初始化一维数组
2.3 使用一维数组
例2.3 创建类GetDay,在主方法中创建int型数组，并实现将各月的天数输出：
public class GetDay //创建类
{
public static void main(String[] args) //创建主方法
{
int[] day = new int[]{31,28,31,30,31,30,31,31,30,31,30,31};
for(int i=0;i<12;i++)
System.out.println((i+1)+"月有"+day[i]+"天");
}
}
//输出示例
/*
1月有31天
2月有28天
3月有31天
4月有30天
5月有31天
6月有30天
7月有31天
8月有31天
9月有30天
10月有31天
11月有30天
12月有31天
Process finished with exit code 0
*/
3 二维数组的创建与使用
如果一维数组中的各个元素仍然是一个数组，那么它就是一个二维数组。
3.1 创建二维数组
1. 先声明，再用new运算符进行内存分配
数组元素类型 名字[][];
数组元素类型[][] 名字;
//具体声明如下：
int myarr[][];
同一维数组一样，二维数组在声明时也没有分配内存空间，同样要使用new关键字来分配内存，然后才可以进行访问每个元素，对于高维数组，有两种为数组分配内存的方式：
//（1）直接为每一维分配内存空间，实例如下：
a = new int[2][4];
//(2)分别为每一维分配内存空间
a = new int[2][];
a[0] = new int[2];
a[1] = new int[3];
2. 声明的同时为数组分配内存
3.2 初始化二维数组
type arrayname[][] = {value1,value2...valuen};
//type:数组数据类型
//arrayneme:数组名称，一个合法的标识符
//value:数组中各元素的值
//初始化实例如下：
int myarr[][] = {{12,0},{45,10}};3.3 使用二维数组
例3.3 创建类Matrix,在主方法中编写代码实现输出一个3行4列且所有元素都为0的矩阵：
public class Matrix //创建类
{
public static void main(String[] args) //创建主方法
{
int[][] a = new int[3][4];
for(int i=0;i<a.length;i++)
{
for(int j=0;j<a[i].length;j++)
System.out.print(a[i][j]);
System.out.println();
}
}
}
//输出示例
/*
0000
0000
0000
Process finished with exit code 0
*/
4 数组的基本操作
4.1 遍历数组
遍历二维数组需要使用双层for循环，通过数组的length属性可获得数组的长度
例4.1.1 创建类Trap，在主方法中编写代码，定义二维数组，将二维数组中的元素呈梯形输出：
public class Trap {
public static void main(String[] args) {
int[][] a = new int[][]{{1}, {2, 3}, {4, 5, 6}};//定义二维数组
for (int i = 0; i < a.length; i++) {//循环遍历二维数组中的每个元素
for (int j = 0; j < a[i].length; j++) {
System.out.print(a[i][j]);//将数组中的元素输出
}
System.out.println();//输出空格
}
}
}
//输出示例：
/*
1
23
456
Process finished with exit code 0
*/在遍历数组时，使用foreach语句可能会更加简单，下面的实例就是通过foreach语句遍历二维数组。
例4.1.2 创建类Tautog,在主方法中定义二维数组，使用foreach语句遍历二维数组：
public class Tautog {
public static void main(String[] args) {
int[][] arr2 = new int[][]{{4, 3}, {1, 2}}; //定义二维数组
System.out.println("数组中的元素是：");
int i = 0;//外层循环计数器变量
for (int[] x :
arr2) { //外层循环变量为一维数组
i++; //外层计数器递增
int j = 0; //内层循环计数器
for (int e :
x) { // 循环遍历每一个数组元素
j++; // 内层循环计数器递增
if (i == arr2.length && j == x.length) { // 判断变量是二维数组中的最后一个元素
System.out.print(e); //输出二维数组最后一个元素
} else {
//如果不是二维数组中的最后一个元素
System.out.print(e + "、"); // 输出信息
}
}
}
}
}
//输出示例：
/*
数组中的元素是：
4、3、1、2
Process finished with exit code 0
*/4.2 填充替换数组元素
数组中的元素定义完成后，可通过Arrays类的静态方法il()来对数组中的元素进行替换。该方法通过各种重载形式可完成任意类型的数组元素的替换。fll()方法有两种参数类型。下面以int型数组为例介绍ill()方法的使用方法。
（1）fill(int[] a,int value)
//该方法可将指定的int值分配给int型数组的每个元素，语法如下：
fill(int[] a,int value);
//a:要进行元素替换的数组
//value:要存储数组中所有元素的值
例4.2.1 创建类Swap，在主方法中创建一维数组，并实现通过fill()方法填充数组元素，最后将数组中各个元素输出。
import java.util.Arrays; // 导入java.util.Arrays类
public class Swap {
public static void main(String[] args) {
int[] arr = new int[5]; // 创建int型数组
Arrays.fill(arr, 8); // 使用同一个值对数组进行填充
for (int i = 0; i < arr.length; i++) { // 循环遍历数组中的元素
System.out.println("第" + i + "个元素是" + arr[i]);
}
}
}
//输出示例：
/*
第0个元素是8
第1个元素是8
第2个元素是8
第3个元素是8
第4个元素是8
Process finished with exit code 0
*/
(2)fill(int[] a,int fromIndex,int toIndex,int value)
//该方法将指定的int值分配给int型数组指定范围中的每个元素。填充的范围从索引fromIndex（包括）到索引toIndex（不包括），如果fromIndex==toIndex,则填充范围为空，语法如下：
fill(int[] a,int fromIndex,int toIndex,int value);
//a:要进行填充的数组
//fromIndex:要使用指定值填充的第一个元素的索引（包括）
//toIndex:要使用指定值填充的最后一个元素的索引（不包括）
//value:要存储在数组所有元素的值
注意：如果指定的索引位置大于或者等于要进行填充的数组长度，则会报出ArrayIndexOutOf-BoundsException(数组越界异常) 异常。
例4.2.2 创建类Displace,创建一维数组，并通过fill()方法替换数组元素，最后将数组中的各个元素输出。
import java.util.Arrays; // 导入java.util.Arrays类
public class Displace {
public static void main(String[] args) {
int[] arr = new int[]{45,12,2,10}; // 创建int型数组
Arrays.fill(arr,1,2,8); // 使用同一个值对数组进行填充
for (int i = 0; i < arr.length; i++) { // 循环遍历数组中的元素
System.out.println("第" + i + "个元素是" + arr[i]);
}
}
}
//输出示例：
/*
第0个元素是45
第1个元素是8
第2个元素是2
第3个元素是10
Process finished with exit code 0
*/
4.3 对数组进行排序
通过Arrays类的静态sort()方法可以实现对数组的排序。sort()方法提供了多种重载形式，可对任意类型的数组进行升序排序。语法如下：
Arrays.sort(object)
//object:指进行排序的数组名称
例4.3 创建类Taxis，在主方法中创建一维数组，将数组排序后输出。
import java.util.Arrays; // 导入java.util.Arrays类
public class Taxis {
public static void main(String[] args) {
int[] arr = new int[]{23,42,12,8}; // 创建int型数组
Arrays.sort(arr); // 将数组进行排序
for (int i = 0; i < arr.length; i++) { // 循环遍历数组中的元素
System.out.println(arr[i]);
}
}
}
//输出示例：
/*
8
12
23
42
Process finished with exit code 0
*/
4.4 复制数组
Arrarys类的copyOf()方法与copyOfRange()方法可实现对数组的复制。copyOf()方法是复制数组至指定长度，copyOfRange()方法则将指定数组的指定长度复制到一个新数组中。
（1）copyOf()方法，语法如下：
copyOf(arr,int newlength);
//arr:要进行复制的数组
//newlenghth:int型常量，指复制后的新数组长度。如果新数组长度大于数组arr的长度，则用0填充（整型0填充，char型null填充），如果复制后的数组长度小于数组arr的长度，则会从数组arr的第一个元素开始截取到满足新数组长度为止
例4.4.1 创建类Cope,在主方法中创建一维数组，实现将此数组复制得到一个长度为5的新数组，并将新数组输出：
import java.util.Arrays; // 导入java.util.Arrays类
public class Cope {
public static void main(String[] args) {
int[] arr = new int[]{23, 42, 12}; // 创建int型数组
int[] newarr = Arrays.copyOf(arr, 5); // 复制数组arr
for (int i = 0; i < newarr.length; i++) { // 循环遍历数组中的元素
System.out.println(newarr[i]);
}
}
}
//输出示例：
/*
23
42
12
0
0
Process finished with exit code 0
*/
（2）copyOfRange()方法，语法如下：
copyOfRange(arr,int fromIndex,int toIndex);
//arr:要进行复制的数组对象
//fromIndex:指定开始复制数组的索引位置，必须在0-整个数组长度之间，新数组包括fromIndex元素
//toIndex:要复制范围的最后索引位置，可以大于数组arr长度，新数组不包括toIndex元素
例4.4.2 创建类Repeat,在主方法中创建一维数组，并将数组中索引位置是0-3的元素复制到新数组中，最后将新数组输出：
import java.util.Arrays; // 导入java.util.Arrays类
public class Repeat {
public static void main(String[] args) {
int[] arr = new int[]{23, 42, 12, 84, 10}; // 创建int型数组
int[] newarr = Arrays.copyOfRange(arr, 0, 3); // 复制数组arr
for (int i = 0; i < newarr.length; i++) { // 循环遍历数组中的元素
System.out.println(newarr[i]);
}
}
}
//输出示例：
/*
23
42
12
Process finished with exit code 0
*/
4.5 数组查询
Arrays类的binarySearch()方法，可使用二分搜索法来搜索指定数组，以获得指定对象。该方法返回要搜索元素的索引值。binarySearch()方法提供 了多种重载形式，用于满足各种类型数组的查找需要。binarySearch()方法有两种参数类型。
(1) binarySearch(Object[] a, Object key)
//a:要搜索的数组
//key:要搜索的值
例5.1.1 创建Reference类，在主方法中创建一维数组arr,实现查找元素4在数组中的索引：
import java.util.Arrays; // 导入java.util.Arrays类
public class Reference {
public static void main(String[] args) {
int[] arr = new int[]{1, 8, 9, 4, 5}; // 创建int型数组
Arrays.sort(arr);//对数组进行排序
int index=Arrays.binarySearch(arr,4);
System.out.println("4的索引位置是："+index);
}
}
//输出示例：
/*cd
4的索引位置是：1
Process finished with exit code 0
*/
（2）binarySearch(Object[] a,int fromlndex , int tolndex,Object key)
//该方法在指定的范围内检索某一元素
//a:要进行检索的数组
//fromIndex:指定范围的开始索引处（包含）
//toIndex:指定范围处的索引（不包含）
//key:要搜索的元素
例5.1.2 创建Rakel类，在主方法创建String数组，实现查找元素“cd”在指定范围的数组str中的索引位置：
import java.util.Arrays; // 导入java.util.Arrays类
public class Rakel {
public static void main(String[] args) {
String[] str = new String[]{"ab","cd","ef","yz"};//定义String型数组
Arrays.sort(str); // 将数组进行排序
int index = Arrays.binarySearch(str,0,2,"cd");
System.out.println("cd的索引位置是："+index);
}
}
//输出示例：
/*
cd的索引位置是：1
Process finished with exit code 0
*/
5 数组排序算法
5.1 冒泡排序
冒泡排序是最常用的数组排序算法之一，它排序数组元素的过程总是小数往前放，大数往后放，类似水中气泡往上升的动作，所以称作冒泡排序。
5.1.1 基本思想
是对比相邻的元素值，如果满足条件就交换元素值，把较小的元素移动到数组前面，把较大的元素移动到数组后面，这样较小的元素就像气泡一样从底部上升到顶部。
5.1.2 算法实现
例5.1.2 创建BubbleSort类，实现冒泡排序的一个演示，其中排序使用的是正排序：
/**
* 冒泡排序算法实例
*
* @author Codeplus
*/
public class BubbleSort {
public static void main(String[] args) {
//创建一个数组，这个数组元素是乱序的
int[] array = new int[]{64, 4, 24, 1, 3, 15};
//创建冒泡排序类的对象
BubbleSort sorter = new BubbleSort();
//调用排序方法将数组进行排序
sorter.sort(array);
}
/**
* 冒泡排序
*
* @param array 要排序的数组
*/
public void sort(int[] array) {i
for (int i = 1; i < array.length; i++) {
//比较相邻的两个元素，较大的数往后冒泡
for (int j = 0; j < array.length - i; j++) {
if (array[j] > array[j + 1]) {
int temp = array[j];//把第一个元素的值保存在临时变量里
array[j] = array[j + 1];//把第二个元素值保存到第一个元素单元里
array[j + 1] = temp;//把临时变量保存到第二个元素中
}
}
}
showArray(array); //输出冒泡排序后的数组元素
}
/**
* 显示数组中的所有元素
*
* @param array 要显示的数组
*/
public void showArray(int[] array) {
for (int i :
array) { //遍历数组
System.out.print(" >" + i); //输出每个数组元素值
}
System.out.println();
}
}
//输出示例：
/*
>1 >3 >4 >15 >24 >64
Process finished with exit code 0
*/
5.2 直接选择排序
5.2.1 基本思想
将指定排序位置与其他数组元素分别对比，如果满足条件就交换元素值。注意这里与冒泡排序的区别，不是交换相邻元素，而是把满足条件的元素与指定的排序位置交换，这样排序好的位置逐渐扩大，最后整个数组都成为已经排序好的格式。
5.2.2 算法实现
例5.2.2 创建SelectSort类，这个类作为直接选择排序的一个演示，其中排序选择的是正排序：
/**
* 直接选择排序算法实例
*
* @author Codeplus
*/
public class SelectSort {
public static void main(String[] args) {
//创建一个数组，这个数组元素是乱序的
int[] array = new int[]{64, 4, 24, 1, 3, 15};
//创建直接选择排序类的对象
SelectSort sorter = new SelectSort();
//调用排序方法将数组进行排序
sorter.sort(array);
}
/**
* 直接选择排序
*
* @param array 要排序的数组
*/
public void sort(int[] array) {
int index;
for (int i = 1; i < array.length; i++) {
index=0;
for (int j = 1; j <= array.length - i; j++) {
if (array[j] > array[index]) {
index=j;
}
}
//交换在位置array.length-i和index（最大值）上的两个数
int temp = array[array.length-i];//把第一个元素的值保存在临时变量里
array[array.length-i] = array[index];//把第二个元素值保存到第一个元素单元里
array[index] = temp;//把临时变量保存到第二个元素中
}
showArray(array); //输出冒泡排序后的数组元素
}
/**
* 显示数组中的所有元素
*
* @param array 要显示的数组
*/
public void showArray(int[] array) {
for (int i :
array) { //遍历数组
System.out.print(" >" + i); //输出每个数组元素值
}
System.out.println();
}
}
//输出示例：
/*
>1 >3 >4 >15 >24 >64
Process finished with exit code 0
*/
5.3 反转排序
5.3.1 基本思想
把数组最后一个元素与第一个元素交换，倒数第二个元素与第二个元素替换，以此类推，直到把所有数组元素反转替换
5.3.2 算法实现
例5.3.2 创建ReverseSort类，实现反转排序演示：
/**
* 反转排序算法实例
*
* @author Codeplus
*/
public class ReverseSort {
public static void main(String[] args) {
// 创建一个数组
int[] array = {10, 20, 30, 40, 50, 60};
// 创建反转排序类的对象
ReverseSort sorter = new ReverseSort();
// 调用排序对象的方法将数组反转
sorter.sort(array);
}
/**
* 直接选择排序法
*
* @param array 要排序的数组
*/
public void sort(int[] array) {
System.out.println("数组原有内容：");
showArray(array);// 输出排序前的数组值
int temp;
int len = array.length;
for (int i = 0; i < len / 2; i++) {
temp = array[i];
array[i] = array[len - 1 - i];
array[len - 1 - i] = temp;
}
System.out.println("数组反转后内容：");
showArray(array);// 输出排序后的数组值
}
/**
* 显示数组所有元素
*
* @param array 要显示的数组
*/
public void showArray(int[] array) {
for (int i : array) {// foreach格式遍历数组
System.out.print("\t" + i);// 输出每个数组元素值
}
System.out.println();
}
}
//输出示例：
/*
数组原有内容：
10 20 30 40 50 60
数组反转后内容：
60 50 40 30 20 10
Process finished with exit code 0
*/
