第四章 数组

4.1 数组的概述

数组是具有相同数据类型的一组数据的集合。在程序设计中，可以将这些集合称为数组，数组中的每个元素具有相同的数据类型，在JAVA中同样将数组看作一个对象，虽然基本数据类型不是对象，但是由基本数据类型组成的数组则是对象，在程序设计中引入数组可以有效地管理和处理数据。我们经常使用数组，包括一维数组和二维数组等。 4.2  一维数组

一维数组实质上是一组相同类型数据的线性集合，当在程序中需要处理一组数据，或者传递一组数组时，就可以使用数组实现，一维数组的创建及使用。

4.2.1 创建一维数组

数组元素类型决定了数组的数据类型。它可以是Iva中任意的数据关型包括基本数据类型和其他引用类型。数组名字为一个合法的标识符，符号“[]”指明该变量是一个数组类型变量。单个“[]”表示要创建的数组是一个一维组。

声明一维数组的两种方法：

1.数组元素类型 数组名字[ ]；

2.数组元素类型[ ] 数组名字；

int arr[];         //声明int型数组，数组中的每个元素都是int型数值
double[]dou; //声明double型数组，数组中的每个元素都是double型数值

注意声明完数组后，还不能访问它的任何元素，因为声明数组只是给出了数组名字和元素的数据类型，要想真正使用数组，还要为它分配内存空间。

4.2.2 初始化一维数组

int a[]={1,2,3};//第一种方法
int b[]=new int[]{4,5,6};//第二种方法
int c[]=new int[3];//第三种方法
c[0]=7;//给第一个元素赋值
c[1]=8;//给第二个元素赋值
c[2]=9;//给第三个元素赋值

4.2.3 获取数组长度

例4.1

public class GetArrayLength {  //创建主类
	public static void main(String[] args) {  主方法
 
		char a[] = { 'A' , 'B' , 'C' ,'D' };//创建一维数组
		System.out.println("数组a的长度为" + a.length);//输出结果
		char b[] = a;//创建一维数组b，直接等于数组a
		System.out.println("数组b的长度为" + b.length);//输出结果
	 
		}
}

 4.2.4 使用一维数组

例4.2

public class GetDay {    //创建主类
	public static void main(String[] args) {    //创建并初始化一维数组
		// TODO Auto-generated method stub
int day[]=new int[] {31,28,31,30,31,30,31,31,30,31,30,31};   //输出一年12月中每月的天数
for (int i=0;i<12;i++) {   //利用循环将信息输出
	System.out.println((i+1)+"月有"+day[i]+"天");   //输出的信息
}
	}
}

 4.3 二维数组

比如快捷酒店，每-个楼层都有很多房问，这些房问都可以构成维数组， 如果这个酒店有500个房间，并且所有房间都在同一个楼层里，那么拿到499号房钥匙的旅客可能就不高兴了，从1号房走到499号房要花好长时间，因此每个酒店都不只有一个楼层， 而是很多楼层，每一个楼层 都会有很多房间，形成一个立体的结构， 把大量的房间均摊了下来，这种结构就是二维表结构， 如图4.7所示，在计算机中，这种二维表结构可以使用二维数组来表示。如图4.7所示，每一个楼层都是一个一维数组，楼层数本身又构成了一个数组，这样一家酒店 就构成了一个二维数组。

 4.3.1 创建二维数组

 int a [] [] ;
 a = new int [2][4];     //直接分配行列

 int b [] [];
 b = new int [2][1];    //先分配行，不分配列
 b [0]= new int [2]:  //给第一行分配列
 b [1]= new int [2];   //给第二行分配列

4.3.1 创建二维数组

例4.3

public class InitTDArray {     //创建主类
	public static void main(String[] args) {    //主方法
		// TODO Auto-generated method stub
/*第一种方法*/
int tdarr1[][]= {{1,3,5},{5,9,10}};    //定义二维数组
/*第二种方法*/
int tdarr2[][]=new int[][] {{65,55,12},{92,7,22}};   //定义新的二维数组
/*第三种方法*/
int tdarr3[][]=new int[2][3]; //先给数组分配内存空间
tdarr3[0]=new int[] {6,54,71};   //给第一行分配一个一维数组
tdarr3[1][0]=63;   //给第二行第一列赋值给63
tdarr3[1][1]=10;   //给第二行第二列赋值给10
tdarr3[1][2]=7;   //给第二行第三列赋值给7
	}
}

4.3.3 使用二维数组

例4.4

public class Poety {    //创建主类
	public static void main(String[] args) {   //主方法
		// TODO Auto-generated method stub
		char arr[][] = new char[4][]; // 创建一个4行的二维数组
	     arr[0] = new char[] { '春','眠','不','觉','晓'}; // 给第一行赋值 
	     arr[1] =new char[] { '处','处','闻','啼','鸟'};  // 给第二行赋值
	     arr[2] = new char[] { '夜','来','风','语','声'}; // 给第三行赋值
	     arr[3] = new char[] { '花','落','知','多','少' };// 给第四行赋值
	     /*横版输出*/
	     System.out.println("---横版---");    //输出横版
	     for (int i = 0; i < 4; i++) {// 循环4行
	      for( int j=0;j < 5;j++){//循环5列
	     System.out.print(arr[i][j]);//输出数组中的素
	    }
	     if (i % 2 == 0) {
	      System.out.println(",");//如果是一、三句，输出号
	      }else {
	       System.out.println("。");//如果是二、四句，输出句号
	    }
	     }
	     /*竖版输出*/
	     System.out.println("\n-----竖版-----");   //输出竖版
	     for (int j = 0; j < 5; j++) {// 列变行
	      for (int i = 3; i >=0; i--) {// 行变列，反序输出
	       System.out.print(arr[i][j]);//输出数组中的元素
	    }
	      System.out.println();//换行
	     }
	     System.out.println("。，。，");//输出最后的标点
	  }
	}

 例4.5

public class IrregularArray {     //创建主类
	public static void main(String[] args) {     //主方法
		// TODO Auto-generated method stub
int a[][]=new int[3][];   //创建二维数组，指定行数，不指定列数
a[0]= new int[] { 52, 64, 85, 12, 3, 64 };   //第一行分配6个元素
a[1]= new int[] { 41, 99, 2 };   //第二行分配3个元素
a[2]= new int[] { 285, 61, 278, 2 };   //第三行分配4个元素
for(int i=0;i<a.length;i++) {  //循环i的元素
	System.out.print("a["+i+"]中有"+a[i].length+"个元素，分别是:");    //输出length个元素
	for (int tmp:a[i]) {   //foreach循环输出数组中元素
		System.out.print(tmp+" ");  //输出空格
	}
	System.out.println();    //输出换行
	}
}
	}

4.4数组的基本操作

4.4.1 遍历数组

遍历数组就是获取数组中的每个元素。通常遍历数组都是使用for 循环来实现的。遍历维数组很简单，也很好理解，下面详细介绍遍历二维 数组的方法。
遍历二维数组需使用双层for循环，通过数组的length属性可获得数组的长度。

例4.6

public class Trap {    //创建主类
	public static void main(String[] args) {    //主方法
		// TODO Auto-generated method stub
int b[][]=new int[][] {{1},{2,3},{4,5,6}};   //定义二维数组
for (int k=0;k<b.length;k++) {     //循环二维数组的元素
	for (int c=0;c<b[k].length;c++) {   //循环遍历二维数组中的每个元素
		System.out.print(b[k][c]);    //将数组中的元素输出
	}
	System.out.println();     //输出换行
 
	}
}
	}

 4.4.2 填充和批量替换数组元素

例4.7

import java.util.Arrays;    //导入java.util.Arrays类
public class Swap {    //创建主类
	public static void main(String[] args) {   //主方法
		// TODO Auto-generated method stub
int arr[]=new int[5];  //创建int型数组
Arrays.fill(arr, 8);   //使用同一个值对数组进行填充
for(int i=0;i<arr.length;i++) {  //循环遍历数组中的元素
	//将数组中的元素一次输出
	System.out.println("第"+i+"个元素是:"+arr[i]);//输出数组中的元素
	}
}
}

例4.8

import java.util.Arrays;   //导入java.util.Arrays类
public class Displace {   //创建主类
	public static void main(String[] args) {   //主方法
		// TODO Auto-generated method stub
int arr[]=new int[] {45,12,2,77,31,91,10};  //定义并初始化int型数组arr
Arrays.fill(arr,1,4,8);               //使用fill()方法对数组进行填充
for(int i=0;i<arr.length;i++) {   //循环遍历数组中的元素
	//将数组中的每个元素输出
	System.out.println("第"+i+"个元素是:"+arr[i]);  //输出数组中的元素
}
	}
}

 4.4.3 复制数组

例4.9

import java.util.Arrays;     //导入java.util.Arrays类
public class Cope {     //创建主类
	public static void main(String[] args) {    //主方法
		// TODO Auto-generated method stub
		int arr[] = new int[] { 23, 42, 12 };// 定义数组
	    int newarr[]=Arrays.copyOf(arr, 5); //复制数组arr
	    for (int i = 0; i < newarr.length; i++) {//循环变量复制后的新数组
	     System.out.println("第" + i + "个元素是:" + newarr[i]); //将新数组输出
	   }
	 }
}

例4.10

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 newarr[] = Arrays.copyOfRange(arr, 0, 3); // 复制数组
  for (int i =0; i < newarr.length; i++){ //循环遍历复制后的新数组
   //将数组中的每个元素输出
   System.out.println(newarr[i]);// 将新数组中的每个元素输出
  }
 }
}

4.5 数组的排序

在程序设计中，经常需要将一-组数据进行排序，这样更加方便统计与查询。程序常用的排序方法有冒泡排序、选择排序等。本节将对常用的数据排序方法进行详细讲解。

 4.5.1 算法：冒泡排序

冒泡排序是最常用的数组排序算法之-一，它以简洁的思想与实现方法备受青睐，是初学者最先接触的一个排序算法。使用冒泡排序时，排序数组元素的过程总是小数往前放，大数往后放，类似水中气泡往上升的动作，所以称作冒泡排序。

 1.基本思想

 冒泡排序的基本思想是对比相邻的元素值，如果满足条件就交换元素值，把较小的元素移动到数组前面，把较大的元素移动到数组后面（也就是交换两个元素的位置），这样较小的元素就像气泡一样从底部上升到顶部。

2.计算过程

冒泡算法由双层循环实现，其中外层循环用于控制排序轮数，般是 要排序的数组长度减1次，因力最后一次循环只剩下-一个数组元素，不需要对比，同时数组已经完成排序了。而内层循平主要用于对比数细中每个临近元素的大小，以确定见否交换位置，对比和交换次数以排序轮数而碗少。

第一轮外层循环时把最大的元素值63移动到了最后面(相应的比63小的元素向前移动，类似气泡上升)，第二轮外层循环不再对比最后个元素值63,因为它已经确认为最大 (不需要上升)，应该放在最后，需要对比和移动的是其他剩余元素，这次将元素24移动到了63的前一一个位置。其他循环将依此类推，继续完成排序任务。

3.算法实现

例4.12

public class SelectSort {   //创建主类
	/**
	   * 直接选择排序法
	   *  @param array 
	   *    要排序的数组
	   */
	  public void sort(int[] array) {   //主方法
	   int index;
	   for (int i = 1; i <array.length; i++) {   //定义i的值
	    index = 0;   //index为0的数
	    for (int j = 1; j <= array.length - i; j++) {  //定义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) {    
	   System.out.println("选择排序的结果为:");    //选择排序的结果
	   for (int i : array) { //遍历数组
	    System.out.print(i + " ");//输出每个数组元素值
	   }
	   System.out.println();   //输出信息
	  }
	  public static void main(String[] args) {
	   //创建一个数组，这个数组元素是乱序的 
	   int[] array = { 63, 4, 24, 1, 3, 15 };
	    //创建直接排序类的对象 
	   SelectSort sorter = new SelectSort();
	   //调用排序对象的方法将数组排序
	   sorter.sort(array);
	  }
	 }

 4.5.3  Arrays.Sort （）方法

通过Arrays类的静态sort（）方法可实现对数组的排序，sort（）方法提供了多种使用方式，可对任意类型数组进行升序排序。

例4.13

import java.util.Arrays;    //导入java.util.Arrays类
public class Taxis {    //创建主类
    public static void main(String[] args) {   //主方法
        // TODO Auto-generated method stub
        int arr[]=new int[] {23,42,12,8};//声明数组
         Arrays.sort(arr);//将数组进行排序
         System.out.println("排序后的结果为:");  //输出排序结果
         for(int i=0;i<arr.length;i++) {//循环遍历排序后的数组
          System.out.print(arr[i]+" ");//将排序后数组中各个元素输出
         }
    
    }
}