1.数组的概念：
一组相同类型的数据堆积在一起
2.数组的声明：
1）数据类型 【】 数组名；
2）数据类型 数组名【】；（不推荐）
注：数据类型
可以使简单数据类型，也可以使引用数据类型
简单数据类型在内存中的值为零值（boolean：false，int：0，Double：0,0），引用数据类型在内存中的默认值为null。
简单数据类型在内存中存储的是字面量，引用数据类型在内存中存储的第堆区中的地址
3）初始化
1））动态初始化
int【】 arr=new int【4】；//在堆区中开辟4个int类型的空间
将int类型的空间赋值为0
在栈区中声明数组变量，并将变量所指向内存置为null
将堆区中开辟的空间的首地址赋值给栈区的变量空间存储
int【】 arr=new int[]{1,2,3};//将括号内的值依次放置到堆区中存储。
2））静态初始化
int【】 arr={1,2,3}；//静态初始化只能在声明数组时对其赋值。例：
int【】 arr；
arr={1,2,3}；//错误
arr=new int[4]{1,2,3,4};//错误；不能指定长度
注：数组的元素是自动初始化的，初始化的值为0值。
4）访问方式
1））访问数组的元素：
语法：数组名【下标】，下标从零开始
数组的长度，数组名。length
数组的遍历：将数组的元素一个一个的取出
注：（System.exit(0) 终止JVM的运行，非0的状态码表示异常终止）
5）数组的复制与动态扩展算法
1））数组的赋值
例：int【】 arr1=new int【】{1,2,3}；
int【】 arr2=arr1；//arr1和arr2指向同一个数组对象，数据对象没有隔离性。
2））两个不同的数组
例：
int【】 arr=new int【】{1,2,3}；
int【】 arr1=new int【arr.length】;//使用原数组的长度定义新数组，复制了空间，赋值内容使用循环遍历
3））Object的clone（）方法
4））工具类 Arrays的API
5））数组拷贝效率更高的2中方式
1）））Static void System.arraycopy(Object[] arc,int srcpost,object[] dest,int destpost,length);//src:原数组，srcpost：原数组拷贝元素的起始位置，dest：目标数组，destpost:将原数组的元素拷贝到目标数组的第几个位置；length：将原数组的多少个元素拷贝到目标数组；object:对象类型，一切皆对象。
注：该方法由java的Api提供，底层由c++实现的，效率高，比for循环遍历拷贝的效率高
2）））Arrays.copyof(original,newLength)
src:原数组，newLength:新数组的长度
例：自拷贝（空间）扩容
String[] str=new String[]{"a","b","c"};
str=Arrays.copyof(str,str.length+1);//[a,b,c,null]
注：此时的str与原str的引用地址不一样，但堆区中里面的元素的地址仍指向同一对象，属于浅拷贝。在java中只有I/O属于深拷贝
2.总结：
先写子类，再写父类；先写方法的调用，再写方法的定义
定义参数时，优先考虑八大基本数据类型
当定义变量的需求过多，优先考虑数组类型
定义方法：根据逻辑定义功能
3.排序
1）概念：让数据有序的存储
2）分类：八大排序（选择，快速，冒泡，插入，归并和堆）
1））选择排序
1）））原理：固定一个位置，与其他位置作比较，满足条件交换位置
使用i表示第一个数据：0~arr.length-2
使用j表示后面部分的数据：i+1~arr.length-1; (j<arr.length,j++;i>j交换)
2））冒泡：
1）））原理：总是，相邻的两个位置作比较，如果满足条件，交换位置
注：i表示次数，0~arr.lenth-2
j表示比较的位置，0~arr.lenght-i-1
j=1 j<arr.length-i j++
if j-1>j 交换
3))插入：
1）））原理：将数组分成两段，一段放大的数据，一段放小的数据
注：j代表需要插入的元素的位置， 1~arr.lenght-1
i代表前一部分每一个元素的位置 0~j-1
示例：
for(int j=1;j<arr.length;j++){
int temp=arr[j];
int i=j-1;
for(;i>=0;i--){
if(arr[i]>temp){
arr[i+1]=arr[i];
}else{
break;
}
}
arr[i+1]=temp;
}
4.递归
1))本质：自己调用自己
2））递归是一种算法，基本思想：对于一个复杂的问题，将原问题分解为若干个相对简单的子问题，继续下去直到简单的问题能够解决求解，也就是找到问题的出口。
3））关键因素：
递归的出口
递归逐步的向出口推进
4））递归的应用场景：
当一次运算无法计算出结果，而且是自己调用自己，只有找到出口才拿到结果。然后返回来进行下一步的运算。
5））递归的特点：
递归的时候，按照递归的深度分配全部的临时变量，栈开销很大，性能较低，要注意不能超越栈空间的大小。并且要给出一定的结束条件，否则，会造成栈溢出。