首页 > 代码库 > Java 基本语法----数组

Java 基本语法----数组

数组

数组概述

数组是多个相同类型数据的组合,实现对这些数据的统一管理。
数组属引用类型,数组型数据是对象(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 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]);
  }
 }
}


创建对象数组

1、

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);
    }
}


2、

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();
        }
    }
}


数组初始化

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

    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);


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

    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 = 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];

  //…

技术分享


多维数组初始化

静态初始化
  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 class Sort {
 3     public static void main(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();
  }

 

Java 基本语法----数组