数组中的每个元素具有相同的数据类型。在Java中同样将数组看作是一个对象, 虽然基本数据类型不是对象,但是由基本数据类型组成的数组则是对象。在程序设计中引入数组可以更有效地管理和处理数据。我们经常使用的数组包括一维数组和二维数组等。
数组元素类型决定了数组的数据类型。它可以是Java中任意的数据类型,包括基本数据类型和其他引用类型。数组名字为一个合法的标识符,符号“[ ]”指明该变量是一个数组类型变量。 单个“[ ]”表示要创建的数组是一个一 维数组。
注意:Java中的数组第一个元素, 索引是以0开始的。
我们初始化一维数组的时候都会在内存中分配内存空间,内存空间的大小决定了一维 数组能够存储多少个元素,也就是数组长度。如果我们不知道数组是如何分配内存空间的,该如何获取数组长度呢?我们可以使用数组对象自带的length属性。语法如下:
arr. length
arr: 数组名。
length :数组长度属性,返回int值。
4.1public static void main(String[] args) { //主方法
// TODO Auto-generated method stub
char a[]= {'A','B','C','D'}; //创建一维数组
System.out.println("数组a的 长度为"+a.length); //输出a的长度
char b[]=a; //创建一维数组b,直接等于数组a
System.out.println("数组b的 长度为"+b.length); //输出b的长度
}
}
4.2int 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]+"天"); //输出的信息
}
}
}
二维数组可以看作是特殊的一维数组,因此,二维数组有两种声明方式:
数组元素类型 数组名字[ ] [ ];
数组元素类型 [ ][ ]数组名字; 声明二维数组。代码如下:
int tdarr1[ ] [ ];
char[ ] [ ] tdarr2;
同一维数组一样,二维数组在声明时也没有分配内存空间,同样要使用关键字new来分配内存,然后才可以访问每个元素。为二维数组分配内存有两种方式:
int a[ ][ ];
a = new int[2][4]; //直接分配行列
int b[ ][ ];
b = new int[2][ ]; //先分配行,不分配列
创建二维数组的时候,可以只声明“行”的长度,而不声明“列”的长度,例如:
int a[ ][ ] = new int[2][ ];// 可省略“列”的长度
但如果不声明“行”数量的话,就是错误的写法,例如:
int b[ ][ ] = new int[ ] [ ];//错误写法!
int c[ ][ ] = new int[ ] [2];//错误写法!
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.4 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("。,。,");//输出最后的标点
}
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++) {
System.out.print("a["+i+"]中有"+a[i].length+"个元素,分别是:");
for (int tmp:a[i]) { //foreach循环输出数组中元素
System.out.print(tmp+" ");
}
System.out.println();
}
}
}
4.4.1 遍历数组
遍历数组就是获取数组中的每个元素。通常遍历数组都是使用for 循环来实现的。遍历维数组很简单,也很好理解,下面详细介绍遍历二维数组的方法。
遍历二维数组需使用双层for循环,通过数组的length属性可获得数组的长度。
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(); //输出换行
}
}
}
数组中的元素定义完成后,可通过Arrays类的静态方法fill( )来对数组中的元素进行分配,可以起到填充和替换的效果。fill( )方法有两种参数类型,下面以int型数组为例介绍fill( )方法的使用。
1. fill(int[ ] a,int value)
该方法可将指定的int值分配给int型数组的每个元素。
语法如下:
Arrays. fill (int[ ] a,int value)
a: 要进行元素分配的数组。
value:要存储数组中所有元素的值。
public class shizhu {
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]);//输出数组中的元素
}
}
}
fill(int[ ]a, int fromIndex,int tolndex,int value)
该方法将指定的int值分配给int 型数组指定范围中的每个元素。填充的范围从索引fromIndex(包括)一直到索引 toIndex (不包括)。如果fromIndex = = toIndex,则填充范围为空。
语法如下:
Arrays.fill(int[ ] a,int fromIndex ,int toIndex,int value)
a:要进行分配的数组 。
fromIndex: 要使用指定值填充的第一个元素的索引 (包括)。
toIndex: 要使用指定值填充的最后一个元素的索引(不包括)。
value: 要存储在数组所有元素中的值。
注意:如果指定的索引位置大于或等于要进行分配的数组的长度,则会报出ArrayIndexOutOf-BoundsException(数组越界异常)异常。
import java.util.Arrays; //导入java.util.Arrays类
public class lerdwu {
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);
for(int i=0;i<arr.length;i++) { //使用fill()方法对数组进行填充
//将数组中的每个元素输出
System.out.println("第"+i+"个元素是:"+arr[i]); //输出数组中的元素
}
}
}
Arrarys类的copyOf0方法与copyOfRangeO方法可实现对数组的复制。copyOf0方法是复制数组至指定长度,copyOfRangeO方 法则将指定数组的指定长度复制到一个新数组中。
1. copyOf( )方法
该方法提供了多种使用方式,用于满足不同类型数组的复制。语法如下:
Arrays. copyOf (arr, int newlength)
arr: 要进行复制的数组。
newlength: int型常量,指复制后的新数组的长度。 如果新数组的长度大于数组 arr的长度,则用0填充(根据复制数组的类型来决定填充的值,整型数组用0填充,char型数组则使用null来填充);如果复制后的数组长度小于数组arr的长度,则会从数组arr的第一个元素开始截取至满足新数组长度为止。
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]); //将新数组输出
}
}
}
public static void main(String[] args) {
// TODO Auto-generated method stub
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次,因为最后一次循环只剩下一个数组元素,不需要对比,同时数组已经完成排序了。而内层循环主要用于对比数组中每个临近元素的大小,以确定是否交换位置,对比和交换次数以排序轮数而减少。
/**
* 冒泡排序法
* @param array
* 要排序的数组
*/
public void sort(int[] array) { //主方法
//比较相邻两个元素,较大的数往后冒泡
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);}//输出冒泡排序后的数组元素
/**
* x显示数组中所有的元素
*
* @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 };
BubbleSort sorter=new BubbleSort();
sorter.sort(array);//调用排序方法数组排序
}
}
4.12/**
* 直接选择排序法
* @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) {
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.13import java.util.Arrays;
public class shizhu {
public static void main(String[] args) { //主方法
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]+" ");//将排序后数组中各个元素输出
}
}
}