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 的长度(元素个数)

数组元素的默认初始化

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

1 2 3 4 5 6

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

创建对象数组

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

数组初始化

动态初始化

数组定义与为数组元素分配空间并赋值的操作分开进行。

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

示例

 

package com.uncleyong;
 
public class TestArray {
    public static void main(String[] args) {
 
        //1. 数组的声明
        //int    i = 0;
        int [] a = null; //推荐使用此种方式进行声明.
        int b [] = null;
 
        //注意: Java语言中声明数组时不能指定其长度(数组中元素的数)
        //int [5] c = null;
 
        //注意: 若没有为数组变量分配指向的内存空间, 就调用其属性, 会在运行时发生 "空指针异常"
        //System.out.println(a.length);
 
        //2. 为数组分配内存空间，new后面必须指定数组长度
        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 [][] 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 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];

示例

 

package com.uncleyong;
 
public class TestArray {
    public static void main(String[] args) {
        //声明一个二维数组
        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();
        }
 
    }
}

数组排序

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

package com.uncleyong;
 
import java.util.Arrays;
 
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.print(number[i] + " ");
    }
}

 摘要：声明，本文转载自 全栈测试笔记 https://www.cnblogs.com/UncleYong/p/10971923.html 感谢大神的分享。