Java中的数组

Java中的数组

数组的定义

• 相同类型数据的有序集合
• 相同类型的若干个数据，按照一定顺序排列组合而成
• 每一个数据称作元素，可以用下标来访问

数组的声明与创建

int[] num1;
int num2[];

有以上两种方式声明

常用的是第一种方式声明

第二种是为了迎合C/C++的风格

//计算所有元素的和
int[] nums = new int[10];
int sum = 0 ;
Scanner scanner = new Scanner(System.in);
for( int i = 0 ; i<nums.length ; i++) {
    if ( scanner.hasNextInt() ) {
        nums[i] = scanner.nextInt();
	}
}
for ( int x : nums) {
	sum += x;
}
System.out.println("sum=" + sum);

下标越界

int[] nums = new int[10];

注意：下标是从0开始的，nums[10]属于越界，会报一下错误

ArrayIndexOutOfBoundError

数组下表越界错误

---

内存分析

Java内存分析

• 堆
  • 存放new的对象和数组
  • 可被所有线程共享
  • 不存放别的对象引用
• 栈
  • 存放基本变量类型
    • 会包含这个基本类型的具体数值
  • 引用对象的变量
    • 会存放这个对象的引用，也就是这个对象的地址
• 方法区
  • 可以被所有的线程共享
  • 包含了所有的class和static变量

---

数组的初始化

静态初始化

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

动态初始化

int[] a = new int[9];

动态分配，每个默认赋值为0

数组的基本特点

• 长度固定，创建后无法改变
• 每个元素类型相同
• 元素可以是任意类型，即基本类型和引用类型
• 数组变量属于引用类型
  • 数组本身就是一个对象
  • java中对象是在堆当中的
  • 数组的元素不论是基本类型还是引用类型，数组本身是在堆当中的

数组的使用

普通遍历

int[] a = {1,2,3,4,5,6,7,8,9};
for (int i=0 ; i<a.length ; i++) {
    System.out.println(a[i]);
}

Each for遍历

int[] a = {1,2,3,4,5,6,7,8,9};
for (int i : a) {
    System.out.println(i);
}

反转数组

public class Demo02 {
    public static void main(String[] args) {
        int[] a = {1,2,3,4,5,6,7,8,9};
        reverse(a);	//这里也体现了数组的引用传递
        for (int i: a) {
            System.out.println(i);
        }
    }
    //将数组的值反转
    public static void reverse(int[] array) {
        for (int i=0 ,tmp = 0; i<array.length/2 ; i++) {
            tmp = array[i];
            array[i] = array[array.length-i-1];
            array[array.length-i-1] = tmp;
        }
    }
}

注意：array[array.length-i-1]，这里非常容易越界，报ArrayIndexOutOfBoundException

---

多维数组

二位数组声明

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

二维数组初始化

int[][] a = {{0,1},{2,3},{4,5},{6,7},{8,9}};
for (int[] x: a) {
    for(int y: x) {
        System.out.print(y + "\t");
    }
    System.out.println();
}

Arrays类的使用

import java.util.Arrays;

public class Demo04 {
    public static void main(String[] args) {
        int[] a = {3,515,2521,111,224,845,31313,2545,45,88};
        System.out.println(a);	//打印哈希码
        System.out.println(Arrays.toString(a));	//打印数组
        Arrays.fill(a,8);	//填充8
        System.out.println(Arrays.toString(a));	//打印数组
    }
}

打印结果

[I@34a245ab
[3, 515, 2521, 111, 224, 845, 31313, 2545, 45, 88]
[8, 8, 8, 8, 8, 8, 8, 8, 8, 8]

---

排序

冒泡排序

import java.util.Arrays;
public class Demo05 {
    public static void main(String[] args) {
        int[] a = {3,515,2521,111,224,845,31313,2545,45,88};
        System.out.println(Arrays.toString(a));
        sequence(a);
        System.out.println(Arrays.toString(a));
    }
    public static void sequence(int[] array) {
        for( int i=0 ; i<array.length-1 ; i++) {
            boolean flag = true;
            for( int j=0 , tmp = 0; j<array.length-i-1 ; j++) {
                if ( array[j] > array[j+1]) {
                    tmp = array[j] ;
                    array[j] = array[j+1] ;
                    array[j+1] = tmp;
                    flag = false;
                }
            }
            if (flag) {
                break;
            }
        }
    }
}

输出结果

[3, 515, 2521, 111, 224, 845, 31313, 2545, 45, 88]
[3, 45, 88, 111, 224, 515, 845, 2521, 2545, 31313]

只需要修改第10行中的'<'为‘>’就是逆向排序