Java 数组

　　程序=算法+数据结构，所谓数据结构，简单说就是把数据按照特定的某种结构来保存，设计合理的数据结构是解决问题的前提，数组就是最基本的一种数据结构。

1.数组介绍

　　相同数据类型的元素组成的集合，如20个成绩、100个账号。

　　元素按线性顺序排列，所谓线性顺序是指除第一个元素外，每一个元素都有唯一的前驱元素；除最后一个元素外，每一个元素都有唯一的后继元素（一个跟一个）。

　　可以通过元素所在位置的顺序号（下标）做标识来访问每一个元素，下标从0开始，到最大元素个数-1。

　　数组是一种数据类型，引用类型。

2.定义基本类型数组

　　声明数组的语法：数据类型[] 数组名 = new 数据类型[大小];  如:int[] arr = new int[10];表示声明int类型数组，长度为10，即包含10个元素。

1）定义基本类型数组的要点

• 确切的数据类型
• 整体的数组名字
• 不能缺少[]
• 执行new语句才使得数组分配到了指定大小的空间
• int[] arr和int arr[]两种写法都可以，推荐第一种写法
• 声明数组时不规定数组长度，new关键字分配空间时需指定分配的空间大小。

2）初始化数组

• 基本类型的数组创建后，其元素的初始值如下列表：

数据类型	初始值
byte	0
short	0
char	0
int	0
long	0
float	0.0
double	0.0
boolean	false

 

 

 

 

 

 

 

 

 

 

• 可以在数组声明的同时对数组的元素进行初始化，例如:int[] arr = {1,2,3,4,5};  元素的个数即为数组的长度，此种写法只能用于声明时的初始化，不能用于赋值，如下写法会有编译错误，int[] arr;  arr = {1,2,3,4,5};
• 先声明数组再初始化：int[] arr; arr = new int[]{1,2,3,4,5};

总结：数组声明与初始化如下

//数组的初始化
int[] arr = new int[4];   //默认值是0,0,0,0
arr[0] = 1;
arr[1] = 2;
arr[2] = 3;
arr[3] = 4;               //给元素赋值

int[] brr = {1,2,3,4};   //声明同时给元素赋值
int[] crr = new int[]{1,2,3,4,5};  //声明同时给元素赋值

int[] drr;
//drr = {1,2,3,4,5};  编译错误
drr = new int[]{1,2,3,4,5};  //正确

3.数组的访问

1）获取数组的长度

• 通过length获取

public class Test {
	public static void main(String[] args) {
	int[] arr = new int[10];
	int l = arr.length;
	System.out.println(l);
	}
}

//运行结果：10

2）通过下标来访问数组元素

public class Test {
	public static void main(String[] args) {
	int[] arr = new int[10];
	int temp = arr[1];   //默认是0
	System.out.println(temp);
	arr[1] = 5;   //将第2个元素赋值为5，下标从0开始
	temp = arr[1];
	System.out.println(temp);
　　　　 temp = arr[arr.length-1]; 
　　　　//获取最后一个元素的值

　　　　 System.out.println(temp);

	}
}

3）遍历数组

　　遍历数组，通常选择for循环语句，循环变量作为访问数组元素的下标，即可访问数组中的每一个元素。

案例1：遍历数组，正序输出

public class Test {
	public static void main(String[] args) {
	int arr[] = {1,2,3,4,5,6,7,8,9,0};
	for(int i=0;i<arr.length;i++){
		System.out.print(arr[i]);
	}
	}
}


//运行结果：1234567890

案例2：遍历数组，倒序输出

public class Test {
	public static void main(String[] args) {
	int arr[] = {1,2,3,4,5,6,7,8,9,0};
	for(int i=arr.length-1;i>=0;i--){
		System.out.print(arr[i]);
	}
	}
}

//运行结果：0987654321

4）数组的复制

• 使用System.arraycopy()方法可以实现数组的复制。

该方法如下：

public static void arraycopy(Object src,int srcPos,Object dest,int destPos,int length)

src:源数组

srcPos:源数组中的起始位置

dest:目标数组

destPos:目标数组中的起始位置

length：要复制的数组元素的数量

案例1：复制数组第2到第5个元素

import java.util.Arrays;

public class Test {
	public static void main(String[] args) {
	int[] arr =new int[]{1,2,3,4,5,6,7,8,9,0};
	int[] brr = new int[6];   //默认值为0,0,0,0,0,0
　　　　 //将arr从第2个元素开始复制给brr的第1个元素，依次复制5个
	System.arraycopy(arr, 1, brr, 0, 5);
	System.out.println(Arrays.toString(brr));
	}
}

//运行结果：[2, 3, 4, 5, 6, 0]

• 使用Arrays.copyOf方法复制数组

　　使用java.util.Arrays类的copyOf方法可以实现数组的复制，语法如下：

　　类型[] newArr = Arrays.copyOf(类型[] original , int newLength);

特点：

• 生成的新数组是原始数组的副本，如果newLength小于源数组，则进行截取；如果newLength大于源数组，则用0或null进行填充。

所以产生的新数组可以大于源数组的长度。

• 数组的长度在创建后是不可变的，使用这个命令可以实现数组的扩容，所谓的扩容是指创建一个更大的新数组并将原有数组的内容复制到其中，同理也可以实现数组的缩容。

案例2：使用Arrays.copyOf复制数组

import java.util.Arrays;

public class Test {
	public static void main(String[] args) {
	int[] arr =new int[]{1,2,3,4,5,6,7,8,9,0};
	int[] brr = Arrays.copyOf(arr, 14);
	System.out.println(Arrays.toString(brr));
	}
}

//运行结果：[1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 0, 0, 0, 0]

案例3：实现数组扩容

import java.util.Arrays;

public class Test {
	public static void main(String[] args) {
	int[] arr =new int[]{1,2,3,4,5,6,7,8,9,0};
	arr = Arrays.copyOf(arr, arr.length+1);
	System.out.println(Arrays.toString(arr));
	}
}

//运行结果：[1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 0]

 

5）数组的排序

　　排序是对数组施加的最常用的算法，排序是指将数组元组按照从小到大或从大到小的顺序重新排列，对于元素较多的数组，排序算法的优劣至关重要。一般情况下，通过排序过程中数组元素的交换次数来衡量排序算法的优劣，常用的排序算法有：插入排序、冒泡排序、快速排序等。

• 冒泡排序

　　冒泡排序的原则：比较相邻的元素，如果违反最后的顺序准则，则交换。

　　排序过程：a.第一次找到所有元素中最大的一个放在最后一个位置上，不再变动。 b.第二次找到剩余所有元素中最大的放在倒数第二个位置上，不再变动，以此类推，直到排序完成。

案例1：随机生成10个整数并进行冒泡排序

import java.util.Arrays;
import java.util.Random;

public class Test {
    public static void main(String[] args) {
        //声明数组包含10个元素
        int[] arr = new int[10];
        //生成随机整数
        Random random = new Random();
        //for循环生成随机数组
        for(int i=0;i<10;i++){
            arr[i] = random.nextInt(100);  //生成100以内的整数
        }
        System.out.println("=====生成的随机数组===== 
"+Arrays.toString(arr));  //查看生成的数组内容
        //进行冒泡排序
        System.out.println("=====冒泡排序开始=====");
        for(int i=0;i<arr.length-1;i++){  //控制循环次数
            int tmp;  //用于元素交换临时存储
            System.out.println("=====第"+(i+1)+"次交换结果=====");
            for(int j=0;j<arr.length-i-1;j++){  //用于元素比较交换
                if(arr[j]>arr[j+1]){
                    tmp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = tmp;                    
                }
                System.out.println(Arrays.toString(arr));
            }
        }
        System.out.println("=====最终排序===== 
"+Arrays.toString(arr));
    }
}


/*
运行结果：
=====生成的随机数组===== 
[31, 32, 26, 25, 90, 98, 12, 90, 62, 98]
=====冒泡排序开始=====
=====第1次交换结果=====
[31, 32, 26, 25, 90, 98, 12, 90, 62, 98]
[31, 26, 32, 25, 90, 98, 12, 90, 62, 98]
[31, 26, 25, 32, 90, 98, 12, 90, 62, 98]
[31, 26, 25, 32, 90, 98, 12, 90, 62, 98]
[31, 26, 25, 32, 90, 98, 12, 90, 62, 98]
[31, 26, 25, 32, 90, 12, 98, 90, 62, 98]
[31, 26, 25, 32, 90, 12, 90, 98, 62, 98]
[31, 26, 25, 32, 90, 12, 90, 62, 98, 98]
[31, 26, 25, 32, 90, 12, 90, 62, 98, 98]
=====第2次交换结果=====
[26, 31, 25, 32, 90, 12, 90, 62, 98, 98]
[26, 25, 31, 32, 90, 12, 90, 62, 98, 98]
[26, 25, 31, 32, 90, 12, 90, 62, 98, 98]
[26, 25, 31, 32, 90, 12, 90, 62, 98, 98]
[26, 25, 31, 32, 12, 90, 90, 62, 98, 98]
[26, 25, 31, 32, 12, 90, 90, 62, 98, 98]
[26, 25, 31, 32, 12, 90, 62, 90, 98, 98]
[26, 25, 31, 32, 12, 90, 62, 90, 98, 98]
=====第3次交换结果=====
[25, 26, 31, 32, 12, 90, 62, 90, 98, 98]
[25, 26, 31, 32, 12, 90, 62, 90, 98, 98]
[25, 26, 31, 32, 12, 90, 62, 90, 98, 98]
[25, 26, 31, 12, 32, 90, 62, 90, 98, 98]
[25, 26, 31, 12, 32, 90, 62, 90, 98, 98]
[25, 26, 31, 12, 32, 62, 90, 90, 98, 98]
[25, 26, 31, 12, 32, 62, 90, 90, 98, 98]
=====第4次交换结果=====
[25, 26, 31, 12, 32, 62, 90, 90, 98, 98]
[25, 26, 31, 12, 32, 62, 90, 90, 98, 98]
[25, 26, 12, 31, 32, 62, 90, 90, 98, 98]
[25, 26, 12, 31, 32, 62, 90, 90, 98, 98]
[25, 26, 12, 31, 32, 62, 90, 90, 98, 98]
[25, 26, 12, 31, 32, 62, 90, 90, 98, 98]
=====第5次交换结果=====
[25, 26, 12, 31, 32, 62, 90, 90, 98, 98]
[25, 12, 26, 31, 32, 62, 90, 90, 98, 98]
[25, 12, 26, 31, 32, 62, 90, 90, 98, 98]
[25, 12, 26, 31, 32, 62, 90, 90, 98, 98]
[25, 12, 26, 31, 32, 62, 90, 90, 98, 98]
=====第6次交换结果=====
[12, 25, 26, 31, 32, 62, 90, 90, 98, 98]
[12, 25, 26, 31, 32, 62, 90, 90, 98, 98]
[12, 25, 26, 31, 32, 62, 90, 90, 98, 98]
[12, 25, 26, 31, 32, 62, 90, 90, 98, 98]
=====第7次交换结果=====
[12, 25, 26, 31, 32, 62, 90, 90, 98, 98]
[12, 25, 26, 31, 32, 62, 90, 90, 98, 98]
[12, 25, 26, 31, 32, 62, 90, 90, 98, 98]
=====第8次交换结果=====
[12, 25, 26, 31, 32, 62, 90, 90, 98, 98]
[12, 25, 26, 31, 32, 62, 90, 90, 98, 98]
=====第9次交换结果=====
[12, 25, 26, 31, 32, 62, 90, 90, 98, 98]
=====最终排序===== 
[12, 25, 26, 31, 32, 62, 90, 90, 98, 98]

*/

• Java提供的排序方法Arrays.sort

　　JDK提供的Arrays.sort()方法封装了数组的排序算法。

案例2：随机生成10个整数并使用Arrays.sort()方法进行数组排序

import java.util.Arrays;
import java.util.Random;

public class Test {
    public static void main(String[] args) {
        //声明数组包含10个元素
        int[] arr = new int[10];
        //生成随机整数
        Random random = new Random();
        //for循环生成随机数组
        for(int i=0;i<10;i++){
            arr[i] = random.nextInt(100);  //生成100以内的整数
        }
        System.out.println("=====生成的随机数组===== 
"+Arrays.toString(arr));  //查看生成的数组内容
        //使用Arrays.sort()方法进行排序
        Arrays.sort(arr);
        System.out.println("=====最终排序===== 
"+Arrays.toString(arr));
    }
}


/*
运行结果：
=====生成的随机数组===== 
[23, 68, 40, 67, 72, 96, 32, 61, 62, 85]
=====最终排序===== 
[23, 32, 40, 61, 62, 67, 68, 72, 85, 96]

*/