java数组的基本知识

数组的概念

数组是一组连续的存储空间,存储多个相同数据类型的值

数组的创建

（1）数组的声明：指定数组的数据类型和数组名称
格式：数组数据类型[] 数组名称；
例： int[] arr;
（2）分配空间：制定数组的长度
简单来说也就是表明数组中可以存放多少个数据，格式如下：
数组名=new 数据类型[长度];
例如： arr=new int[5];
（3）数组的下标
数组的下标范围是：0~数组长度-1
以上方的数组arr为例，其数组长度length为：5，所以下标范围是0~4
（4）数组的访问
也就是对数组进行赋值和提取，数组赋值的方式：
数组名[有效下标]=数据；
数组的数据提取：
数组名[有效下标]；这里可以通过定义一个变量进行接收
例：int n=arr[0];
注意：访问数组时，一定要在数组的有效下标范围内，否则会运行报错
java.lang.ArrayIndexOutOfBoundsException(数组下标越界)
因此在访问数组时一定要注意数组下标的有效范围。
（5）数组具有默认值：
整数型：0
浮点型：0.0
字符型：\u0000
布尔型：false
引用型：null
（6） 数组其他定义方式：
a. 声明的同时分配空间：
数据类型[] 数组名= new 数据类型[长度];
b. 声明并初始化：
数据类型[] 数组名= new 数据类型[]{值1,值2,值3};
注意：此时不能手动指定数组的长度，长度由{}中数值的个数来确定。
c. 声明并初始化：
数据类型[] 数组名= {值1,值2,值3};
注意：初始化{}必须和声明写在一起。
错误的写法： int[] a;
a={1,2,3};

数组的常用操作

1、数组元素的添加

数组元素的添加有许多方式，最简单的方式就是通过访问下标的方式进行添加

public class TestArray{
	public static void main(String[] args) {
		int[] arr=new int[5];
		arr[0]=1;
		arr[1]=2;
		arr[2]=3;
		arr[3]=4;
		arr[4]=5;

	}

}

2、数组的遍历

就是将数组中的元素进行打印输出，数组中的元素可以通过“数组名[下标]”的方式进行访问，因此只需要将数组有效下标对应的数据依次输出即可

// 数组遍历
public static void printArray(int[] arr) {
		System.out.print("[");
		for(int i=0;i<arr.length;i++) {
			if(i==arr.length-1) {
				System.out.println(arr[i]+"]");
			}
			else {
				System.out.print(arr[i]+" ,");
			}
			}
	}

还有一种方式是利用jdk提供的工具类进行遍历：Arrays.toString(数组名)

import java.util.Arrays;
class ArrayTest4{
	public static void main(String[] args){
		
		//定义数组,静态初始化
		int[] arr= {1，2，3，4，5} ;
		
		//将数组直接输出
		System.out.println(Arrays.toString(arr)) ;
	}
}

3、求最值

数组求最大/最小值的方法是；将数组中的元素进行依次比较，得到最值。
以求最大值为例：在这里我们可以先定义一个默认的最大值变量，然后与数组中其他元素进行比较，如果其他元素大于这个默认值就将该元素的值赋给该最值变量，依次执行得到结果。
具体代码如下：

public static int getMax(int[] arr){
		//定义一个参照物
		int max = arr[0] ;
		for(int x = 1 ; x < arr.length ; x ++){
			//判断如果后面的元素值大于最大值
			if(arr[x] > max){
				max = arr[x] ;
			}
		}
		return max ;
	}

4、数组元素的逆序

元素逆序:将数组中的元素位置按以下方式进行互换
将索引值0对应的元素和arr.length-1对应的元素互换
将索引值1对应的元素和arr.length-1-1对应的元素进行互换
…
以“int[] arr={1,2,3,4,5};”为例，通过
arr[0]与arr[4]互换
arr[1]与arr[3]互换
就可以达到元素逆序的目的，这里我们只需要互换arrr.length/2即可，在程序中可以通过循环进行互换

public static void reverse(int[] arr){
		//for循环
		for(int x = 0 ; x < arr.length/2; x ++){
			//互换
			int temp = arr[x] ;
			arr[x] = arr[arr.length-1-x] ;
			arr[arr.length-1-x] = temp ;
		}
	}

5、数组元素的查找

获取数组中某个元素第一次出现的索引值的方法，找到对应元素就返回该元素的索引值，找不到返回-1

public static int getIndex2(int[] arr,int key){
		//假设找不到
		int index = -1 ;
		//遍历数组
		for(int x = 0 ; x < arr.length ; x ++){
			//进行判断
			if(arr[x] == key){
				index = x ;
				break ;
			}
		}
		return index ;
	}
}

6、数组的排序

这是数组中很重要的一个知识点，数组的排序主要有以下几种方式：
方式一：冒泡排序
冒泡排序的思想:
两两比较,大的往后放,第一次比较完毕,最大值就出现在最大索引处，依次这样执行,----->数组排序 如图：

代码如下：

public static void bubbleSort(int[] arr){
		for(int x = 0 ; x < arr.length-1 ; x ++){ //比较的次数
			for(int y = 0 ; y < arr.length-1-x; y ++){
				//判断:两两比较,大的往后放..
				if(arr[y] > arr[y+1]){
					int temp = arr[y] ;
					arr[y] = arr[y+1] ; 
					arr[y+1] = temp ;
				}
			}
		}
	}

比较的轮数为：数组长度-1次
每轮比较次数：数组长度-1-轮次
方式二：选择排序：
1).固定值与其他值比较大小，互换位置。
2).记忆：外层 length - 1 ；同时外层i作为固定值，内层的j = i+1作为其他值的起始
示例：

 public class ArraysXuanZe {
		public static void main(String[] args) {
			int[] a = { 1,3,2,7,5 };
                        for(int i=0;i<a.length-1;i++){ 	//外层循环进行几次排序
				for(int j=i+1;j<a.length;j++){ //内层循环控制比较内容
					if(a[i]<a[j]){
						int t=a[i];
						a[i]=a[j];
                        a[j]=t;
				}
			}
		}
		｝

方式三：快速排序：利用jdk提供的工具类进行排序
java.util.Arrays.sort(数组名);
该方法默认是从小到大排列的。

import java.util.Arrays;
          public class Test {
		public static void main(String[] args) {
			int[] arrays = { 12, 5, 58, 4, 5, 8989, 74, 55 };
			Arrays.sort(arrays);
				for (int i = 0; i < arrays.length; i++) {
					System.out.print(arrays[i]+" ");
				}
			}
		}