Java数组

crainyday

Java / JavaSE

发布于：2019年3月18日

字数：1.2k字

时长：5分钟

Java基本语法续

Java数组

一.一维数组

数组: 相同数据类型的数据的组合.

//如: 多个int
int score1 = 72;
int score2 = 90;
int score3 = 59;
//使用数组存储
int[] scores1 = new int[]{72,90,59};
//静态初始化:声明并初始化数组与给数组相应的元素赋值操作同时进行
int scores2[] = new int[3];//动态初始化:声明并初始化数组与数组相应的元素赋值操作分开进行
scores2[0] = 72;
scores2[1] = 90;
scores2[2] = 59;
int[] arr = {72,90,59};//这样可以
//声明数组的错误写法:
/*
String[] names = new String[5]{"AA","BB","CC"};//这样用时不能指定大小
int i[10];
int i = new int[];//i是int型
int[] arr;arr = {10,11,12};//两句分开不行, 合并为一句可以
*/
System.out.println(scores2.length);//求数组长度
for(int i = 0;i < scores1.length;i++){//遍历数组
    System.out.println(scores1[i]);
}

注意

1.不管是动态还是静态初始化数组, 一定在创建的时候, 就指明了数组的长度
2.如何引用数组元素: 通过数组的下角标的方式. 下角标从0开始, 到n-1结束.其中n为数组的长度

3.关于数组元素的默认初始化值

byte short int long 而言:0

float double 而言:0.0

char而言:空格

boolean而言:false

引用类型变量而言:null

4.数组的内存结构

内存结构图:

在JAVA中, 凡是new出来的东西, 都会被默认初始化并赋值. new 出来的东西都存放在堆中

对于数组来讲:

字符串: 面向对象之后再看

二.二维数组

//1.声明并初始化
//一维:类型后一个[]
int[] i = new int[12];
i[0] = 12;
int[] j = new int[]{12,3};
//二维:类型后两个[]
String[][] str = new String[4][3];//4行3列
String[][] str1 = new String[4][];//4行, 每行的列可能不一样
str1[0] = new String[3];
//...
str1[3] = new String[5];
int[][] arr = new int[][]{{1,2,3},{4,5},{6}};
//2.如何引用二维数组的元素
arr[1][0] = 12;
//3.二维数组的长度:
arr.length;//3
arr[1].length;//2
//4.遍历二维数组
for(int i = 0;i < arr.length;i++){
    for(int j = 0;j < arr[i].length;j++){
        System.out.print(arr[i][j] + "\t");	
    }
    System.out.println();
 }

5.二维数组的结构:

三.数组中常见的异常

//1.数组下标越界的异常:java.lang.ArrayIndexOutOfBoundsException
int[] i = new int[10];
//i[0] = 90;
//i[10] = 99;//最大i[9]
//for(int m = 0;m <= i.length;m++){
//    System.out.println(i[m]);//最大i[i.length-1]
//}

//2.空指针的异常:NullPointerException
//第一种:
//boolean[] b = new boolean[3];
//b = null;
//System.out.println(b[0]);//b已经为空

//第二种:
//String[] str = new String[4];
//System.out.println(str[3].toString());//没有初始化str[3]

//第三种:
int[][] j = new int[3][];
//j[2][0] = 12;//j的第二维还未初始化

四.数组中常用的算法

求数组元素的最大值&最小值&和&平均数

数组的复制和反转

情况1: 浅复制, 两个数组的引用指向同一片内存空间, 改变一个的内容另一个也会改变

1 2	int[] arr1 = new int[]{10,11,12}; int[] arr2 = arr1;

情况2: 深复制, 将一片内存里的内容, 复制到另一片内存里(如何实现复制)

int[] arr1 = new int[]{10,11,12};
int[] arr2 = new int[arr1.length];
for(int i = 0;i < arr1.length;i ++){
    arr2[i] = arr1[i];
}

数组的反转：
数组元素的反转

//①
for(int i = 0;i < arr.length/2;i++){
    int temp = arr[i];
    arr[i] = arr[arr.length-1 - i];
    arr[arr.length - 1 - i] = temp;
}
//②
for (int x = 0, y = arr.length - 1; x < y; x++, y--) {
    int temp = arr[x];
    arr[x] = arr[y];
    arr[y] = temp;
}

拓展:String str = “abcdefg”;

数组的排序

插入排序: 直接插入排序、折半插入排序、Shell排序

交换排序: 冒泡排序、快速排序(或分区交换排序)

选择排序: 简单选择排序、堆排序

归并排序

基数排序

使用冒泡排序使数组元素从小到大排列

for (int i = 0; i < arr.length - 1; i++) {
    for (int j = 0; j < arr.length - 1 - i; j++) {
        if (arr[j] > arr[j + 1]) {
            int temp = arr[j];
            arr[j] = arr[j + 1];
            arr[j + 1] = temp;
        }
    }
}

使用直接选择排序使数组元素从小到大排列

for(int i = 0; i < arr.length - 1; i++){
    int t = i;//默认i处是最小的
    for(int j = i;j < arr.length;j++){
        //一旦在i后发现存在比其小的元素，就记录那个元素的下角标
        if(arr[t] > arr[j]){
            t = j;
        }
    }
    if(t != i){
        int temp = arr[t];
        arr[t] = arr[i];
        arr[i] = temp;
    }
}