7.数组

数组：同一种类型数据的集合，其实数组就是一个容器
可以自动给数组中的元素从0开始编号，方便操作这些元素
格式1：
需要一个容器，但是不明确容器的具体数据
元素类型 [] 数组名 = new 元素类型[元素个数或数组长度];
int [] arr = new int[5];
格式2：
需要一个容器，存储已知的具体数据
元素类类型 [] 数组名 = new 元素类型[]｛元素，元素，…｝;
int [] arr = new int []{3,5,7};
int [] arr = {3,5,7};
局部代码块：限定局部变量的生命周期
｛
int a=3;
｝

内存的划分：
1.寄存器
2.本地方法区
3.方法区
4.栈内存
存储的都是局部变量
而且变量所属的作用域一旦结束，该变量就自动释放
5.堆内存
存储的是数组和对象（其实数组就是对象），凡是new都建立在堆中
特点：
1.每一个实体都有首地址值
2.堆内存中的第一个变量都 有默认初始化值，根据类型的不同而不同，
3.垃圾回收机制

取数组数据时不能数组越界！
class test{
public static ovid main(String [] args){
int [ ] arr = new int [3];
int arr [0] = 15;
System.out.println(arr[0]);
}
}

对数组操作最基本的协作就是存和取。
核心思想：对数组操作就是对角标的操作。
遍历：
arr.length 取数组成员数！

class Test{
		public static void mian(String [] args){
				int [] arr={12,13,14,15};
				System.out.println(arr.length);
				for(i=0;i<arr.length;i++){                   //用for循环遍历显示数组里面的数
						System.out.pritnln("arr["+i+"]="+arr.length);
				}
		}
]

案例：数组中的最值操作
1.判断数组中的最大值

public class Test {
	public static void main(String[]args) {
		int []arr= {15,55,35,88,22};
		int max=getMax(arr);
		System.out.println(max);	
	}
	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;
	}
}

Arrays.sort(arr); 调用系统自带的排序方法
对数组中的数据进行从小到大排序：
选择排序

public class Test {
	public static void main(String[]args) {
		int []arr= {15,55,35,88,22};
		printArray(arr);
			selectSort(arr);
		printArray(arr);
	}
	public static void selectSort(int []arr) {
		for (int i = 0; i < arr.length; i++) {
			for (int j = i+1; j < arr.length; j++) {
				if (arr[i]>arr[j]) {
					int temp = arr[i];
					arr[i]=arr[j];
					arr[j]=temp;
					//可以用 swap(arr,i,j);
				}
			}
		}
	}
	public static void printArray(int[]arr) {
		System.out.print("[");
		for (int i = 0; i < arr.length; i++) {
			if (i!=arr.length-1) {
				System.out.print(arr[i]+",");
			}else 
				System.out.println(arr[i]+"]");
		}
	}
}

冒泡排序：

public static void dubbleSort(int []arr) {
		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;
					//可以用：swap(arr,i,j);
				}
			}
		}
	}

代码的封装，可以提高代码的复用性，减少代码量

public static void swap(int [] arr,int a,int b ){
	int temp=arr[a];
	arr[a]=arr[b];
	arr[b]=temp;
}

对于排序性能快的一种方法：
针对元素比较多的情况下，再考虑排序性能的问题
代码如下：

public static void selectSort_2(int [] arr){
		for(int x=0;x<arr.length-1;x++){
				int num=arr[x];
				int index=x;
				for(int y=x+1;y<arr.length;y++){
						if(num>arr[y]){
								num=arr[y];
								index=y;	
						}
				}
				if(index!=x){
						swap(arr,x,index);	
				}
		}
}

对数组的查找：
调用方法：
int [] arr=[1,2,35,10]
getIndex(arr,10);
如果数组里面元素相同，只会显示第一个元素的下标

public static int getIndex(int[] arr,int key){
		for(int x=0;x<arr.length;x++){
				if(arr[x]==key){
						return x;	
				}
				return -1; //表示元素不存在
		}
}

二分查找法：
方法1
方法2：