数组的定义！！！！！
数组？什么是数组？
在我印象中的数组是应该这样的：通过new关键字创建并组装他们，通过使用整形索引值访问它的元素，并且它的尺寸是不可变的！
但是这只是数组的最表面的东西！深一点？就是这样：数组是一个简单的复合数据类型，它是一系列有序数据的集合，它当中的每一个数据都具有相同的数据类型，我们通过数组名加上一个不会越界下标值来唯一确定数组中的元素。
不管在其他语言中数组是什么，在java中它就是对象。一个比较特殊的对象。
数组就是一片地址连续且空间大小一致的存储空间(但是每个空间存的还是其他数据的地址)
数组的使用方法！！！！！！
通过上面算是对数组是什么有了一个初步的认识，下面将简单介绍数组的使用方法。
数组的使用方法无非就是四个步骤：声明数组、分配空间、赋值、处理。
声明数组：就是告诉计算机数组的类型是什么。有两种形式：int[] array、int array[]。
分配空间：告诉计算机需要给该数组分配多少连续的空间，记住是连续的。array = new int[10];
赋值：赋值就是在已经分配的空间里面放入数据。array[0] = 1 、array[1] = 2……其实分配空间和赋值是一起进行的，也就是完成数组的初始化。有如下三种形式：
int a[] = new int[2]; //默认为0,如果是引用数据类型就为null
int b[] = new int[] {1,2,3,4,5};
int c[] = {1,2,3,4,5};
创建数组时必须明确规定大小或内容
数据类型[] 数组名=new 数据类型[长度];
创建数组只指定长度但不指定内容
数据类型[] 数组名=new 数据类型[]{1,2,3,4,5}；
创建数组指定内容(指定长度)
数据类型[] 数组名={1,2,3,4,5};
创建数组指定内容(指定长度)
[]表示是一维数组
[][]表示二维数组
数组内存分析！！！！！！
数组声明后实际上是在栈内存中保存了此数组的名称，接下来便是要在堆内存中分配数组所需的内存，其中“元素的个数”（数组的长度）是告诉编译器，所声明的数组要存放多少个元素，而“new”则是命令编译器根据括号里的长度开辟空间。
数组名 = new 元素类型[元素的个数];
我们为上面声明的socre数组开辟空间：
score = new int[3];
数组操作中，在栈内存中保存的永远是数组的名称，只开辟了栈内存空间数组是永远无法使用的，必须有指向的堆内存才可以使用，要想开辟新的堆内存则必须使用new关键字，之后只是将此堆内存的使用权交给了对应的栈内存空间，而且一个堆内存空间可以同时被多个栈内存空间指向，即：一个人可以有多个名字，人就相当于堆内存，名字就相当于栈内存。
数组常见错误！！！！！！！
ArrayIndexOutOfBoundsException 数组角标越界
NullPointerException 空指针异常
基本数组操作！！！！！！！！
遍历
数组的元素类型和数组的大小都是确定的，所以当处理数组元素时候，我们通常使用基本循环，尤其是for循环。JDK 1.5 引进了一种新的循环类型，被称为 foreach 循环或者加强型循环，它能在不使用下标的情况下遍历数组。
public static void Test2() {
double[] arr = {1.5, 2.5, 3.5, 3.5, 5.5};
// 打印所有数组元素
for (double element: arr) {
System.out.println(element);
}
}
赋值
Java中我们定义的元素是默认被赋予初值的
-
int类型：0
-
double类型：0.0
-
布尔类型：false
-
引用数据类型：null
我们使用数组名.length来读取数组的长度
import java.util.Scanner;
public class Text08{
public static void main(String []args) {
int []num = new int[10];
Scanner in = new Scanner(System.in);
for (int i = 0;i<10;i++) {
num[i] = in.nextInt();
}
for (int i = 0;i<10;i++) {
System.out.println(num[i]);
}
}
}
数组通过角标来访问元素的具体计算方式是 所要访问数据的地址=首元素地址+角标*数据类型大小
最大值/最小值
我们读取数组的最大值最小值依然采用遍历的方法来判断，例如我们先给数组赋值，然后调用函数求最大值：
import java.util.Scanner;
public class Text08{
public static int max(int []a){
int max = a[0];
for (int i =0;i<a.length;i++) {
if (a[i]>max) max = a[i];
}
return max;
}
public static void main(String []args) {
int []num = new int[]{1,2,3,4,5,6,7,8,9,10};
Scanner in = new Scanner(System.in);
int max= max(num);
System.out.println(max);
}
}
我们通过函数将num数组中最大值通过遍历找出来，最后返回主函数输出。
调用函数求最小值：
import java.util.Scanner;
public class Text08{
public static int min(int []a){
int min = a[0];
for (int i =0;i<a.length;i++) {
if (a[i]<min) min = a[i];
}
return min;
}
public static void main(String []args) {
int []num = new int[]{1,2,3,4,5,6,7,8,9,10};
Scanner in = new Scanner(System.in);
int min= min(num);
System.out.println(min);
}
}
查找操作！！！！！！！！
线性查找
线性查找就是把数组遍历一遍，看数组中有没有需要查找的数值，如果有，就输出第几个，否则输出没找到。
import java.util.Scanner;
class Text08{
public static void main(String []args) {
int []num = new int[]{1,2,3,4,5,6,7,8,9,10};
Scanner in = new Scanner(System.in);
int key = 11;
int m = 0 ;
boolean find = false;
for (int i = 0;i<num.length;i++) {
if (num[i]==key) {
find = true;
m = i+1;
}
}
if(find) {
System.out.println("第"+m+"个");
}else {
System.out.println("没找到");
}
}
}
线性查找效率相对来说较低，我们一般查找采用二分查找
二分查找
二分查找的条件是：待查找的数组首先需要有序。
二分查找一般使用递归方法
二分查找就是每次取数组中间的数值，数组的可以取到的数值随查找的进行而改变。
我们要查找8这个元素，第一次先找中间是5，比8小，第二次我们找5右半部分的中间，是8就找到了
代码如下：
import java.util.Scanner;
class Text08{
public static void main(String []args) {
int []num = new int[]{1,2,3,4,5,6,7,8,9,10};
Scanner in = new Scanner(System.in);
int key = 2;
int left = 0;
int right = num.length-1;
int mid = (left+right)/2;
boolean flag = true;
while (num[mid]!=key) {
if (num[mid]>key) {
right = mid-1;
mid = (left+right)/2;
}
if (num[mid]<key) {
left = mid+1;
mid = (left+right)/2;
}
if (left>right) {
flag = false ;
break;
}
}
if (flag) {
System.out.print(mid);
}else {
System.out.print("no find");
}
}
}
二分查找大大提高了查找效率，适用于数据较多时的查找。
*斐波那契查找
斐波那契数列，又称黄金分割数列，指的是这样一个数列：1、1、2、3、5、8、13、21、····，在数学上，斐波那契被递归方法如下定义：F(1)=1，F(2)=1，F(n)=f(n-1)+F(n-2) （n>=2）。该数列越往后相邻的两个数的比值越趋向于黄金比例值（0.618）。
斐波那契查找就是在二分查找的基础上根据斐波那契数列进行分割的。在斐波那契数列找一个等于略大于查找表中元素个数的数F[n]，将原查找表扩展为长度为Fn，完成后进行斐波那契分割，即F[n]个元素分割为前半部分F[n-1]个元素，后半部分F[n-2]个元素，找出要查找的元素在那一部分并递归，直到找到。
