#数组的及常见用法

#数组的基本使用

首先：思考一下计算1000个任意整数的和

计算1000个任意整数的和

public static int add(定义1000个变量){

int sum = a+b+c+d+.....

return sum;

}
 形参和实参太长，使用不方便，可读性太差

 可以定义一个变量容器，存放多个数据

思考:又或者说定义一个1-1000的数呢,那我们在java里面存放多个数据是用什么来实现的？可以使用 数组，接下来我们来学习什么是数组？

数组可以理解成在计算机中的多个连续的存储空间，里面可以按顺序存放多个类型相同的数据。


1. 数组名 ： 数组的名字

2. 数组元素 ：就是存放在数组里面的数据

3. 数组索引 ：就是数组里面连续存储空间的编号，从0开始

4. length ：数组的属性长度 数组名.length拿到数组的长度

其实所谓的数组指的就是一组相关类型的变量集合，并且这些变量可以按照统一的方式进行操作。数组本身属于引用数据类型，那么既然是引用数据类型，这里面实际又会牵扯到内存分配，而数组的定义语法有如下两类。

1 动态创建之声明的同时赋值

数据类型 [] 数组变量名 = new 数据类型[数组长度];

int[] arr = new int[10];

1. 动态创建之先声明后赋值

数据类型 [] 数组变量名;

数组变量名 = new 数据类型[数组长度];

2. 静态创建之复杂写法

1. 推荐写法：

a. 声明的同时赋值

数据类型 [] 数组变量名 = new 数据类型[] {多个以英文逗号分隔的数据};

b. 先声明后赋值

数据类型 [] 数组变量名;

数组变量名 = new 数据类型[] {多个以英文逗号分隔的数据};

2. 不推荐写法

a. 声明的同时赋值

数据类型 数组变量名 [] = new 数据类型[] {多个以英文逗号分隔的数据};

b. 先声明后赋值

数据类型 数组变量名 [];

数组变量名 [] = new 数据类型[] {多个以英文逗号分隔的数据};

2_1 静态创建简写方式

1. 声明的同时赋值

数据类型[] 数组变量名 = {多个以英文逗号分隔的数据};//接下来学习中最常用

2. 先声明后赋值[编译器不允许，错误写法]

数据类型[] 数组变量名;

数组变量名 = {多个以英文逗号分隔的数据};

范例： 定义一个int型数组

动态创建:

public class ArrayTest {
	public static void main(String args[]) {
		int[] arr = new int[3]; /*开辟了一个长度为3的数组*/
		arr[0] = 10; // 第一个元素
		arr[1] = 20; // 第二个元素
		arr[2] = 30; // 第三个元素
		for(int x = 0; x < data.length; x++) {
			System.out.println(data[x]); //通过for循环控制索引
		}
	}
}

静态态创建一个数组:

public class ArrayTest {
	public static void main(String args[]) {
		int[] arr ={11,22,33,44}; /*开辟了一个长度为4的数组*/
		arr[0] = 11; // 第一个元素
		arr[1] = 22; // 第二个元素
		arr[2] = 33; // 第三个元素
        arr[23] = 44; // 第三个元素
		for(int x = 0; x < data.length; x++) {
			System.out.println(data[x]); //也可以通过for循环控制索引  只是创建方式不一样
		}
	}
}

数组属于引用数据类型，所以在数组使用之前一定要开辟控件（实例化,对象会说到,就是创建对象），如果使用了没有开辟空间的数组，则一定会出现 NullPointerException 异常信息：

数组引用传递

既然数组属于引用数据类型，那么也一定可以发生引用传递。在这之前首先来研究一下数组的空间开辟。

public class _1{
    public static void main(String args[]) {
        int arr[] = null;
      arr = new int[3]; //开辟一个长度为3的数组
        arr[0] = 10;
        arr[1] = 20;
        arr[2] = 30;
    }
}
没有指向推中的地址的引用

数组的二分查找和冒泡排序

1.1. 冒泡排序


希望写一段代码：执行完毕之后，上面的数组中的数据变成从小到大的排序，怎么写？

1. 观察手动排序，如果数据量太大，数据值也比较大，就很难去比较大小了

2. 希望有一个严谨的比较规则：先相邻的两个格子进行比较，把较大的放在靠后的位置

3. 代码实现

4. 第一轮比较5次，把最大的数放到最后

//第一次

if(a[0] > a[1]){

​ int t = a[0];

​ a[0] = a[1];

​ a[1] = t;

}

//第二次

if(a[1] > a[2]){

​ int t = a[1];08

​ a[1] = a[2];

​ a[2] = t;

}

第三次

第四次

优化上面代码，使用for 循环

5. 第二轮比较4次，把最大的数放到最后

第三轮比较3次，把最大的数放到最后

第四轮比较2次，把最大的数放到最后

第五轮比较1次，把最大的数放到最后

优化上面代码，使用嵌套循环

6. 上面的代码只能排列数组长度为 6 的数组，我们希望是任意数组的长度怎么做

数组变量.length

这就是 冒泡排序

查询一个整数在整型数组中第一次出现的位置

1. 定义一个方法search,循环找到第一次出现的元素索引

2. 二分查找

前提： 被查找的数组中的元素必须是有序的

1. 定义一个方法，名字为binarySearch(int ele,int[] src)

2. 先查找数组中间位置（索引）出的元素和ele比较

3. 定义三个变量 

最小索引 minIndex

最大索引maxIndex

中间索引 (minIndex + maxIndex) / 2

4. 比较判断确定范围

if( ele < src[midIndex] ){

      maxIndex  = midIndex -1;

}else if(ele > src[midIndex]){

      minIndex = midIndex + 1;

}else{

     return midIndex; 

5. 

public static  int   binarySearch(int ele,int[] src){

		int minIndex = 0;//起始索引

		int maxIndex = src.length-1;//结束索引

		int midIndex = (minIndex + maxIndex)/2;//中间索引

		//循环不断缩小搜索区间

		while(minIndex <= maxIndex){

			if( ele < src[midIndex]  ){

				maxIndex  = midIndex -1;

			}else if( ele > src[midIndex]){

				minIndex = midIndex + 1;

			}else{

				return midIndex; 

			}

			midIndex = ( minIndex + maxIndex )/2;

		}

		return  -1;

}