Java数组2 ----学习笔记整理
目录
一，维数组的声名
1.1、第一种声明方式 推荐
1.2、第二种声明方式
1.3、注意事项
二、数组元素的引用
三、数组元素的默认初始化
四、创建基本数据类型数组
五、创建数组对象
六、数组初始化化
6.1、数组动态初始值示例
6.2、数组静态初始值示例
6.3.数组练习
七、多维数组
八、多维数组初始化
8.1、静态初始化
8.2、动态初始化
九、数组排序
一，维数组的声名
1.1、第一种声明方式 推荐
数组元素类型 素组名[];
Int a[]
Double a[]
1.2、第二种声明方式
数组元素类型 []数组名
Int []a1
Double []a1
1.3、注意事项
Java中声明数组不能指定数组长度
例：int a[5] //非法
二、数组元素的引用
- Java中使用new关键字创建数组对象
- 定义并用运算符new为它分配空间后，才可以引用数组中的每个元素
- 数组元素的引用方式：数组名[数组下标]
- 数组下标可以是常量，整型表达式a[3],b[i],c[6*i]。
- 数组下标从0开始。
- 每一个数组都有一个length属性。a.length代表数组a的长度
三、数组元素的默认初始化
（1） 数组是引用类型，它的元素相当于类的成员变量，因此数组一经分配空间，其中的每个元素也被按照成员变量同样的方式被隐式初始化。
public class Test {
public static void main(String argv[]) {
int a[]= new int[5];
System.out.println(a[3]); //a[3]的默认值（默认的索引值）为0
}
}
（2）数组元素默认初始化值
四、创建基本数据类型数组
Java中使用关键字new创建数组对象
public class Test {
public static void main(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]);
}
}
}
五、创建数组对象
class MyDate{
private int day;
private int month;
private int year;
public MyDate(int d, int m, int y){
day = d; month = m; year = y;
}
public void display(){
System.out.println(day + "-" + month + "-" + year);
}
}
public class Test {
public static void main(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();
}
}
}
六、数组初始化化
- 动态初始化：数组定义与为数组元素分配空间并赋值的操作分开进行。
- 静态初始化：在定义数组的同时就为数组元素分配空间并赋值。
6.1、数组动态初始值示例
int a[];
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);6.2、数组静态初始值示例
int a[] = { 3, 9, 8};
MyDate dates[] = {
new MyDate(22, 7, 1964),
new MyDate(1, 1, 2000),
new MyDate(22, 12, 1964)
};
数组的常见操作 //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();
}6.3.数组练习
从键盘读入学生成绩，找出最高分，并输出学生成绩等级。
成绩>=最高分-10 等级为’A’ 成绩>=最高分-20 等级为’B’
成绩>=最高分-30 等级为’C’ 其余 等级为’D’
提示：先读入学生人数，根据人数创建int数组，存放学生成绩。
/**
* 2.从键盘读入学生成绩，找出最高分，并输出学生成绩等级。
* 成绩>=最高分-10 等级为’A’ 成绩>=最高分-20 等级为’B’
* 成绩>=最高分-30 等级为’C’ 其余 等级为’D’
* 提示：先读入学生人数，根据人数创建int数组，存放学生成绩。
*/
//1. 创建 Scanner 类
Scanner scanner = new Scanner(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];
八、多维数组初始化
8.1、静态初始化
int intArray[][] = {{1,2},{2,3},{3,4,5}};
int intArray1[3][2] = {{1,2},{2,3},{4,5}};
//illegal，等号左边不能指定维数8.2、动态初始化
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() 方法提供了数组元素排序功能：
import java.util.*;
public class Sort {
public static void main(String[] args) {
int [] number = {5,900,1,5,77,30,64,700};
Arrays.sort(number);
for(int i = 0; i < number.length; i++)
System.out.println(number[i]);
}
}使用二维数组打印 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();
}