数组
一、数组概述
1、什么是数组？
数组是相同类型数据的有序集合。数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成。其中，每一个数据称作一个元素，每个元素可以通过一个索引(下标)来访问它们。
2、数组的特点
- 长度是确定的。数组一旦被创建，它的大小就是不可以改变的。
- 其元素必须是相同类型，不允许出现混合类型。元素的类型可以是java 支持的任意类型。
- 数组类型可以是任何数据类型，包括基本类型和引用类型。
- 数组的元素在堆内存中被分配空间，并且是连续分配的
- 使用new 关键字对数组进行 内存的分配。每个元素都会被jvm 赋予默认值。默认规则：整数：0 浮点数：0.0 字符：\u0000
布尔：false 引用数据类型：null。 - 数组的元素都是有序号的，序号从0开始，0序的。称作数组的下标、索引、角标。
3、数组的声明
- 声明的时候并没有实例化任何对象，只有在实例化数组对象时，JVM才分配空间，这时才与长度有关。
- 声明一个数组的时候并没有数组真正被创建。
- 构造一个数组，必须指定长度。
4、数组的格式
元素类型[ ] 数组名 = new 元素类型 [元素个数或数组长度]
元素类型 数组名[ ] = new 元素类型 [元素个数或数组长度]
int[] intArray=new int[4];
int intArrays[]=new int[4];
- 元素类型：是指数组存储的数据的数据类型
- []：代表这是数组类型。
- 数组名：一个合法的标识符，命名规范 和 局部变量 规范一致。
- new：是java 的关键字。用来向JVM申请内存的。
- 元素类型[元素个数] ：决定了向JVM申请的内存空间的大小（大小：元素类型字节数 * 元素个数）
- 元素的个数：只要是一个合法的java 表达式就可以。 返回一个int 类型的值即可
5、数组的创建
- 声明数组时，给出了数组的初始值，这种创建方法叫做创建静态数组
int[] intArray={1,2,3,4};
String[] strArray= {"Java","C","C++",".NET"};
- 声明数组时，没有给出数组的初始值，但是指定了数组的长度，这种创建方法叫做创建动态数组。可以通过数组下标找到数组元素，给指定的元素赋值
int intArrays[]=new int[4];
intArrays[0]=1;
intArrays[1]=2;
intArrays[2]=3;
intArrays[3]=4;
6、二维数组
二维数组其实是一位数组的嵌套（每一行看做一个内层的一维数组）
示例：
int[][] arr = {{1, 2}, {3, 4}, {5, 6}};//创建静态二维数组
int[][] arr1 = new int[3][2];//创建动态二维数组
arr1[0] = new int[]{1, 2};
arr1[1] = new int[]{3, 4};
arr1[2] = new int[]{5, 6};
7、数组的注意事项
- 数组下标必须是int、short、byte，或是char
- 数组下标从0开始计数
- 元素的个数就是数组的长度，可以通过arrayName.length引用
- 数组下标最大值为arrayName.length
-1如果超过最大值，程序将会抛出数组下标越界异常（ArrayIndexOutOfBoundsException）
8、数组的优缺点
优点：
- 可以保存若干个数据。
- 随机访问的效率很高。根据下标访问元素效率高（元素连续分配空间）。
缺点：
- 数组的元素的类型必须一致。元素类型必须一致。
- 连续分配空间在堆中，如果数组的元素很多，对内存的要求更加的严格。
- 根据内容查找元素效率比较低，需要逐个比较。
- 删除元素、插入元素效率比较低，需要移动大量的元素。
- 数组定长，不能自动扩容。
- 数组没有封装，数组对象只提供了一个数组长度的属性，但是没有提供方法用来操作元素。
二、数组的应用
1、求数组中最大值
int arr[] = {1, 8, 7, 4, 5, 9};
int k = arr[0];
for(int i=0; i<arr.length; i++){
if(arr[i]>k){
k = arr[i];
}
}
System.out.println(k);
2、求数组中的最小值
int arr[] = {1, 2, 7, 4, 0, 9};
int k = arr[0];
for(int i=0; i<arr.length; i++){
if(arr[i]<k){
k = arr[i];
}
}
System.out.println(k);
3、数组排序
int[] a={1,4,-1,5,0};
Arrays.sort(a);//数组a[]的内容变为{-1,0,1,4,5}
for(int i=0;i<a.length;i++){
System.out.print(a[i]+" ");
}
4、数组成员10个,找出数组中最大数连同位置一起输出
int[] n = new int[]{1, 2, 3, 4, 5, 6, 0};
int max = n[0];
int index=0;
for (int i = 0; i < n.length;i++){
if(max<n[i]){
max=n[i];
index=i;
}
}
System.out.println("最大值是："+max);
System.out.println("最大值位置是："+index);
5、冒泡排序
冒泡排序就是重复的遍历要排序的数列，每次比较相邻的两个元素，如果他们的顺序不满足排序条件就把他们交换过来。遍历数列的工作是重复地进行直到不再需要交换（排序已完成）。
算法原理：（比如从小到大排）
- 比较相邻的元素。如果第一个比第二个大，就交换他们的顺序。
- 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
- 针对所有的元素重复以上的步骤，除了最后一个。
- 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
//冒泡排序法
int arr[] = {1, 9, 7, 4, 0};
for(int i=0; i<arr.length-1;i++){
for(int j=0; j<arr.length-i-1;j++){
if(arr[j]>arr[j+1]){
int temp = arr[j+1];
arr[j+1] = arr[j];
arr[j] = temp;
}
}
}
//以下代码是将数组中的所有元素输出到控制台
for(int i=0; i<arr.length; i++){
System.out.println(arr[i]);
}
三、数组扩容
方法一：定义一个新数组，将原数组内容放到新数组中，然后将新数组赋值给原数组，从而实现数组扩容。
//定义原数组
int[] a={1,2,3,4,5};
//定义新数组
int[] b=new int[a.length*2];
//循环获取原数组内容并赋值给新数组
for (int i = 0; i < a.length; i++) {
b[i]=a[i];
}
//将新数组赋值给原数组
a=b;
//展示原数组
System.out.println(Arrays.toString(a));
输出结果为：
[1, 2, 3, 4, 5, 0, 0, 0, 0, 0]
方法二：使用Arrays类中的copyof()方法进行扩容
//定义原数组
int[] a={1,2,3,4,5};
//使用Arrays类中的copyof()方法进行扩容
a=Arrays.copyOf(a, a.length*2);
//展示原数组
System.out.println(Arrays.toString(a));
输出结果为：
[1, 2, 3, 4, 5, 0, 0, 0, 0, 0]
方法三：使用System类中arraycopy()方法进行扩容
//定义原数组
int[] a={1,2,3,4,5};
//定义新数组
int[] b=new int[a.length*2];
/*
* arraycopy()方法本质是循环遍历a数组，并将a数组中的内容放到b数组中
* src:旧数组(在本例中为数组对象a)
* srcPos：从旧数组的哪个下标开始(在本例中为数组对象a的起始位置)
* dest:新的数组(在本例中为数组对象b)
* destPos: 从新的数组哪个下标开始接收数据(在本例中为数组对象b的起始位置)
* length: 要复制的长度为多少(在本例中为数组对象a的长度)
* */
System.arraycopy(a, 0, b, 0, a.length);;
//将新数组赋值给原数组
a=b;
//展示原数组
System.out.println(Arrays.toString(a));
输出结果为：
[1, 2, 3, 4, 5, 0, 0, 0, 0, 0]
注：三个方法中，最简单的为第一个方法，将数组进行替换和增加容量，并且使用循环来完成，个人推荐第二种方法，使用数组工具类Arrays中的copyof()方法来完成数据的扩容。不推荐第一种和第三种方法，因为这两种方法需要一个新的数组，且将新的数组的地址重新再赋给旧数组，这样一来不仅麻烦，而且繁琐。
