数组

数组概述

数组是多个相同类型数据的组合，实现对这些数据的统一管理。

数组属引用类型，数组型数据是对象(Object)，数组中的每个元素相当于该对象的成员变量。

数组中的元素可以是任何数据类型，包括基本类型和引用类型。

一维数组声明

一维数组的声明方式： type var[] 或 type[] var；

例如：

int a[];

int[] a1;

double b[];

Mydate []c; //对象数组

Java语言中声明数组时不能指定其长度(数组中元素的数)， 例如： int a[5]; //非法

数组元素的引用

Java中使用关键字 new 创建数组对象

定义并用运算符 new 为之分配空间后，才可以引用数组中的每个元素；

数组元素的引用方式：数组名[数组元素下标]

数组元素下标可以是整型常量或整型表达式。如a[3] , b[i] , c[6*i];

数组元素下标从0开始；长度为n的数组合法下标取值范围: 0 - n-1；

如int a[]=new int[3]; 可引用的数组元素为a[0]、a[1]、a[2]

每个数组都有一个属性 length 指明它的长度，例如：a.length 指明数组 a 的长度(元素个数)

数组元素的默认初始化

数组是引用类型，它的元素相当于类的成员变量，因此数组一经分配空间，其中的每个元素也被按照成员变量同样的方式被隐式初始化。

例如：

public class Test {

public static void main(String argv[]) {

int a[]= new int[5];

System.out.println(a[3]);//a[3]的默认值为0

}

}

数组元素的默认初始值

创建基本数据类型数组

Java中使用关键字new 创建数组对象

public classTest {public static voidmain(String args[]) {int[] s;

s= new int[10];for ( int i=0; i<10; i++) {

s[i]=2*i+1;

System.out.println(s[i]);

}

}

}

创建对象数组

1、

classMyDate{private intday;private intmonth;private intyear;public MyDate(int d, int m, inty){

day= d; month = m; year =y;

}public voiddisplay(){

System.out.println(day+ "-" + month + "-" +year);

}

}

2、

public classTest {public static voidmain(String args[]) {

MyDate[] m;

m= new MyDate[10];for ( int i=0; i<10; i++) {

m[i]=new MyDate(i+1, i+1,1990+i);

m[i].display();

}

}

}

数组初始化

动态初始化：数组定义与为数组元素分配空间并赋值的操作分开进行。

inta[];

a= new int[3];

a[0] = 3;

a[1] = 9;

a[2] = 8;

MyDate dates[];

dates= new MyDate[3];

dates[0] = new MyDate(22, 7, 1964);

dates[1] = new MyDate(1, 1, 2000);

dates[2] = new MyDate(22, 12, 1964);

静态初始化：在定义数组的同时就为数组元素分配空间并赋值。

int a[] = { 3, 9, 8};

MyDate dates[]={new MyDate(22, 7, 1964),new MyDate(1, 1, 2000),new MyDate(22, 12, 1964)

};

练习

1、数组的常见操作

//1. 数组的声明//int i = 0;

int [] a = null; //推荐使用此种方式进行声明.

int b [] = null;//注意: Java语言中声明数组时不能指定其长度(数组中元素的数)//int [5] c = null;//注意: 若没有为数组变量分配指向的内存空间, 就调用其属性, 会在运行时发生 "空指针异常"//System.out.println(a.length);//2. 为数组分配内存空间

a = new int[10];//3. 获取数组的长度

System.out.println(a.length); //10//5. 对数组元素进行初始化

for(int i = 0; i < a.length; i++){

a[i]= 100 +i;

}//4. 访问数组的元素: 数组名[数组元素下标]. 注意: 下标从 0 开始, 所以最大值是 lengh - 1, 而不是length;//数组元素会进行默认的初始化:

for(int i = 0; i < a.length; i++){

System.out.println(a[i]);

}//若访问数组的下标超过合法范围, 则在运行时会抛出ArrayIndexOutOfBoundsException//a[10] = 10;//数组的静态初始化

int [] c = {1, 2, 3, 4, 5};int [] d = new int[]{2, 3, 4, 5, 6};for(int i = 0; i < d.length; i++){

System.out.println(d[i]);

}//声明一个二维数组

int [][] aa = new int[5][];//对二维数组的元素进行初始化: 二维数组的元素是一个一维数组!//遍历需要使用嵌套的 for 循环.

for(int i = 0; i < aa.length; i++){

aa[i]= new int[i + 1];for(int j = 0; j < aa[i].length; j++){

aa[i][j]= 1 + i *j;

}

}//对二维数组进行遍历

for(int i = 0; i < aa.length; i++){for(int j = 0; j < aa[i].length; j++){

System.out.print(aa[i][j]+ " ");

}

System.out.println();

}

2、从键盘读入学生成绩，找出最高分，并输出学生成绩等级。

成绩>=最高分-10 等级为’A’ 成绩>=最高分-20 等级为’B’

成绩>=最高分-30 等级为’C’ 其余 等级为’D’

提示：先读入学生人数，根据人数创建int数组，存放学生成绩。

/*** 2.从键盘读入学生成绩，找出最高分，并输出学生成绩等级。

* 成绩>=最高分-10 等级为’A’ 成绩>=最高分-20 等级为’B’

* 成绩>=最高分-30 等级为’C’ 其余 等级为’D’

* 提示：先读入学生人数，根据人数创建int数组，存放学生成绩。*/

//1. 创建 Scanner 类

Scanner scanner = newScanner(System.in);//2. 读入要录入的学生人数

System.out.print("请输入学生人数");int count =scanner.nextInt();//3. 创建一个 int 类型的数组, 用于存放学员的成绩, 数组的长度为 2 所录入数值

int [] scores = new int[count];//4. 利用循环录入学生的成绩, 同时得到最高分. 把学生成绩录入到 3 声明的数组中.

int highScore = 0;for(int i = 0; i < scores.length; i++){

scores[i]=scanner.nextInt();if(scores[i] >highScore){

highScore=scores[i];

}

}//5. 遍历 3 声明的数组, 根据最高分, 获取学生的升级等级.

for(int i = 0; i < scores.length; i++){if(scores[i] >= highScore - 10){

System.out.println("student " + i + " score is " + scores[i] + " grade is A");

}else if(scores[i] >= highScore - 20){

System.out.println("student " + i + " score is " + scores[i] + " grade is B");

}else if(scores[i] >= highScore - 30){

System.out.println("student " + i + " score is " + scores[i] + " grade is C");

}else{

System.out.println("student " + i + " score is " + scores[i] + " grade is D");

}

}

多维数组

二维数组举例：

int [][] a = {{1,2},{3,4,0,9},{5,6,7}};

Java中多维数组被做为数组的数组处理

Java中多维数组的声明和初始化应按从高维到低维的顺序进行

int t [][] = new int [4][];//t有4行，第一个维数不空即可

t[0] = new int[5]; //每一行都是一个有5个元素的一维数组

t[1] = new int[5];

int t1[][] = new int [][4]; //非法

Java中多维数组不必须是规则矩阵形式

int[][] tt = new int[4][];

tt[0] = new int[2];

tt[1] = new int[4];

tt[2] = new int[6];

tt[3] = new int[8];

int tt[][] = new int[4][5];//tt是一个4行5列的二维数组

int [][] aa = new int[4][];

aa[0] = new int[5];

aa[1] = new int[1];

aa[2] = new int[3];

//…

多维数组初始化

静态初始化

int intArray[][] = {{1,2},{2,3},{3,4,5}};

int intArray1[3][2] = {{1,2},{2,3},{4,5}};

//illegal，等号左边不能指定维数

动态初始化

int a[][] = new int[4][5];

int b[][] = new int[3][]

b[0] = new int[2];

b[1] = new int[3];

b[2] = new int[5];

数组排序

Java.util.Arrays类的 sort() 方法提供了数组元素排序功能：

1 import java.util.*;2 public classSort {3 public static voidmain(String[] args) {4 int [] number = {5,900,1,5,77,30,64,700};5 Arrays.sort(number);6

7 for(int i = 0; i < number.length; i++)8 System.out.println(number[i]);9 }10 }

使用二维数组打印 10 行的杨辉三角, 杨辉三角实际上是二项式展开式的系数

/*** 1 (a+b)^0

* 1 1 (a+b)^1

* 1 2 1 (a+b)^2

* 1 3 3 1 (a+b)^3

* 1 4 6 4 1

* 1 5 10 10 5 1

* ...

* 1. 什么是杨辉三角: 二项式展开式的系数

* 2. 为什么使用的是 二维数组: 因为杨辉三角由行和列组成, 每一行是一个一维数组, 而杨辉三角则是有一维数组组成的数组, 即二维数组.

* 3. 杨辉三角的具体特点:

* 3.1 第 n 行有 n 个元素(n >= 1)

* 3.2 每一行的第一个元素和最后一个元素都是 1

* 3.3 不等于 1 的那些元素的值为上一行的对应列和对应列的前一列的元素的和.*/

//1. 先声明一个二维数组: 二维数组有 10 个元素

int [][] yh = new int[10][];//2. 对二维数组的元素进行初始化: 第 i 个元素(i 从 0 开始) 为长度为 i + 1 的一维数组.

for(int i = 0; i < yh.length; i++){//二维数组的每一个元素是一维数组, 而一维数组时引用类型, 其默认值为 null//System.out.println(yh[i]);

yh[i]= new int[i + 1];//3. 对具体的每一个元素进行初始化(是 1 的元素): yh[i][0] = 1, yh[i][i] = 1

yh[i][0] = 1;

yh[i][i]= 1;//4. 对具体的每一个元素进行初始化(不是 1 的元素): yh[i][j] = yh[i-1][j] + yh[i-1][j-1];//(i > 1 && j > 0 && j < i)

if(i > 1){for(int j = 1; j < i; j++){

yh[i][j]= yh[i-1][j] + yh[i-1][j-1];

}

}

}//打印

for(int i = 0; i < yh.length; i++){for(int j = 0; j < yh[i].length; j++){

System.out.print(yh[i][j]+ "\t");

}

System.out.println();

}