1 数组No11
数组：存放一组相同类型数据的数据结构
数组本身是引用数据类型，数组中的元素可以是基本数据类型，也可以是引用数据类型
【
Java中的数组以对象的形式存在，或者说数组本身是引用数据类型，数组中的元素(数组中的每一个数据)类型可以是基本数据类型，也可以是引用数据类型
】
1.1 声明
如何使用：
1.声明：
元素类型[] 引用名; 或 （引用声明，并未产生数组，等价）
元素类型引用名[];
元素类型变量名[10];不合法，不能在声明时指定数组长度
（因为引用中只是存放了对象的首地址，不可能存放长度信息）
1.2 创建
2.创建：
数组的动态初始化：
new 元素类型[数组长度]; （创建数组对象时会为每个元素开辟空间，并且赋以初值，
int 0 ，double 0.0, float0.0F, short 0 , long 0L Boolean false,
char 0, 引用类型 null）
（2）数组的静态初始化，声明、创建、初始化在一句语句中完成
元素类型【】引用名 = {值1,值2,值3………值n}；
这种方式同时完成创建和初始化，创建的数组的长度就是大括号中的值得个数，
每一个值之间用逗号，分隔，每个元素的值就是大括号中的值
《注意：静态初始化声明必须和初始化写在一句语句中，否则会出错。》
创建指定长度，指定元素类型的数组，创建好了的数组长度不能改变，可通过数组对象的length属性来获得长度，这种方式创建的数组，其中的元素的值为默认值（如：int为0，double为0.0,引用类型为null）
数组的静态初始化：
元素类型[] 引用={元素1,元素2,元素3...};
虽然没有new关键字，但是创建了一个数组对象；创建后自动初始化为{}中的值；数组长度为大括号内元素的个数
元素为引用数据类型的数组每个元素都是引用
1.3 访问
3.访问：
数组引用名[数字下标]（下标范围从0到length-1，超出范围，会报越界异常<会报数组指针越界异常：java.lang.ArrayIndexOutOfBoundsException>）
可以通过这种方式访问打印，也可以进行对元素的初始化
访问数组可以对元素进行赋值：数组引用名【数组下标】=元素值
数组的访问和赋值可以用到循环赋值
数组的长度可以用其length属性来动态获得
数组的长度在数组创建后不能更改，如果实在需要一个长度不同的数组，
只能再创建一个
1.4 排序
排序（升序：随着下标增加，元素越来越大；降序，越来越小）：
1. 冒泡排序
（排序，将原来没有顺序的杂乱数组，变成从小到大（升序）或从大到小(降序)的顺序。）
《升序：将相邻的元素进行比较，如果左边的大，则将它们互换位置，如此不断循环向右判断，直到最大的数字冒到最右边。》
2. 选择排序
3. 插入排序
【实际开发中，使用Arrays.sort(…..)进行排序】
查找：告诉你某个值，在数组中查找出这个值对应的下标
查找：在数组中根据值查找元素，返回找到的元素的下标，如果一个都不符合返回-1.
1、 顺序查找
从头到尾遍历数组，如果符合这个值就返回下标，如果一个都不符合返回-1.
2、 二分法查找（必须是排过序的数据）
找到数组中间位置的元素和目标值比较，如果目标值大，就扔掉小的那就扔掉小的那一半数据(中间位置左边的)，如果目标值小，就扔掉大的那一半(中间位置右边的)；接下来对以上操作进行循环执行，直到中间位置元素等于目标值，就将其下标返回。
【】可变长数组
元素类型………引用名
《表示在方法的形参中声明一个可变长的数组，实参是用逗号隔开的一个单个元素(元素类型是形参数组的元素类型，)，而是这个可变长数组形参使用时还是将其当作数组用》
【
main方法的参数
在应用程序启动时可以传入参数，这些参数会自动转换为字符串数组，
我们可以在main方法中通过main方法的形参数组访问这些参数
】
数组的拷贝
【用=号进行数组拷贝并不是真正的拷贝，只是将两个引用指向同一个对象
】
2 二维数组和异常机制N12
2.1 二维数组的使用
二维数组：数组中的元素也是数组
1.声明：
元素类型[][] 引用名; 或
元素类型 引用名[][];
在声明时不能在中括号中指定长度
2.初始化：
①静态初始化：
元素类型[][] 引用名={
{元素1，元素2，元素3...},{...},{...}...};（每个子数组的元素可以各不一样）
静态初始化必须和声明在同一语句中
②动态初始化：
(1) new 元素类型[长度1][长度2];
【长度1：表示这个二维数组中有几个子数组
长度2：表示每个子数组中有几个元素(这样的话每个子数组长度一样)
(这样初始化出的每个元素的值为类型对应的默认值)】
【
New 元素类型[长度1][]
长度1表示
长度2没有写，表示这几个子数组并未创建出来
】
（注意：不能写成new[] [2]）
2.2 二维数组的拷贝
二维数组的拷贝：
【
System.arraycopy 是浅克隆，浅拷贝
深度克隆、深拷贝：将数组中的每个元素进行逐一拷贝。
】
长度1表示子数组个数，可以简单认为是行数，长度2表示每个子数组的长度，可以简单认为是列数——————用这种方式初始化每个子数组的长度都一样
(2)new 元素类型[长度1][]
长度1表示子数组个数，或者行数；长度2不写（不能只写长度2，不写长度1）
必须要手动创建各个子数组对象，并将各元素引用分别指向它们
每个子数组的长度可以不一样
3.访问：
引用名[下标1][下标2]表示二维数组的下标1的子数组的下标2的元素，如arr[0][1]就是第一个子数组的第二个元素
引用名[下标1]表示二维数组的下标为1的元素、子数组的对象
可以通过循环访问二维数组中的所有元素
2.3 异常机制
Throwale(是Java中所有的异常、错误的父类，直接子类有：Error、Exception)
异常Exception（广义、体系）
Throwable 可抛的，是所有异常和错误的父类
Error 严重的问题，不需要程序去处理(错误)
Exception（狭义）是Throwable的子类，我们的应用程序需要去处理可能需要程序去处理
RuntimeException 运行时异常，它和它的子类都是《非受检异常：unchecked exception》，它以及它的子类异常可以通过编写代码时严密的逻辑避免掉，不一定要通过要通过异常处理机制去处理
非受检异常：可以不对其进行异常处理，通过严谨的编码逻辑就可以避免的异常
如：ArrayIndexOutofBoundsException数组指针越界、NullPointerException:空指针、ClassCastException：类型转换、AarithmaticException：数学...：
受检异常<checked exception>：只要是Exception的子类但不是RuntimeException的子类《支系》，都是受检异常，受检异常必须要进行异常处理<受检异常只能用异常处理机制来处理，否则编译不能通过>
如：FileFoundException、IOException、MalformedURLException、ClassNotFoundException...
【受检就是一定要检查要处理异常处理，非受检就是不一定要检查，这是辨别受检还是非受检的最直接途径】
异常处理：try catch finally
如何处理异常：try,catch,finally
try：尝试运行可能出现异常的代码
catch：捕捉某一类型的异常对其进行处理
try{
代码1
}catch(异常类型异常引用名){ //catch片段可以有多个
代码2
}finally{
代码3
}
【尝试运行语句1，如果语句1执行中铺捉了catch小括号中所声明的类型的异常，
那么就中断try中语句的执行，而去执行语句2】
《
注意：
1：catch小括号中的异常类型可以是铺捉到的异常类型的父类
2:try后可跟多个catch
3:多个catch层级处理，异常层级要从想到大进行处理
》
Finally 最终
Try{
语句1
}catch(异常类型引用){
语句2
}finally{
语句3
} //无论任何情况，语句3都会执行，一般在finally中进行释放资源的操作，因为finally
可以保证执行。
throws: 将方法定义中，将方法中产生的异常抛给方法的调用者去解决 (对外抛出)
【[修饰符] 返回类型 方法名(参数列表) throws 异常类型{
}】
throw: 产生一个(创建好了的)异常
异常可以自定义，定义一个类继承Exception(受检异常)、RuntimeException(非受检异常)
代码1是要尝试运行的可能出现异常的代码
代码2是捕捉到某种类型（小括号里的类型）异常要执行的处理逻辑
代码3是无论任何情况都会被最终执行的代码，用于收尾工作
1.catch()的异常类型可以是实际异常类型的父类
2.一个try可以对应多个并列的catch，表示出现某种类型异常要进行的对应的异常处理
3.如果多个catch中的异常类型有继承关系，那么父类必须写在后面
4.异常出现后同一层级的代码不会被运行
5.即使遇到不能处理的异常，finally中的代码也会被执行
throws：将方法或构造方法出现的异常向上抛到调用者那里，让它去处理
throw：产生异常的源头（和创建异常（newException()）不一样,throw是产生一个创建好了的异常，让其出现在运行的程序中）
2.4 代码片段总结
数组元素深度克隆、拷贝(循环拷贝数组中的每个元素)
1：【
int[] array ={1,2,5,25,4,5};
int[] array2 =new int[array.length]; //创建一个相同长度的数组
for(int i=0;i<array2.length;i++ ){
// 将数组的每个元素赋值为旧数组对应的值
array2[i] = array[i];
}
array[0]=458;
】
2：【
int[] array ={1,2,5,25,4,5};
int[] array2 =new int[array.length];
//参数说明：
//一：原数组
//三：目标数组
//2：原数组起始位置 4：目标数组起始位置
//拷贝的长度
System.
array[0]=458;
】
3：二维数组拷贝
【
int[][] array ={
{1,2,3},{4,5,6}};int[][] array2=new int[array.length][array[0].length];
// System.arraycopy(array, 0, array2, 0, array.length);
for(int i=0;i<array.length;i++){
System.
}
array[0][0] = 7;
】
4：可变长数组
【
public static void main(String[] args) {
// TODO Auto-generatedmethod stub
int[] array={4,5,8,7,5,4,4,4,4,1,5,4};//可任意变
}
//这个方法的形参就是一个可变长数组
public static void test(int... arr){
System.
for(int i=0;i<arr.length;i++){
System.
}
}
】
动态创建数组：
1：【
int[][] array = new int[3][4];
】
2：【
int[][] array = new int[4][];
int ni =1;
int k=1;
for(int i=0;i<array.length;i++){//循环
//每次都手动创建长度为4的子数组对象，并用二维数组的元素去指向
array[i] = new int[ni];
ni++;
}
】
异常处理机制
1：【
public class TestExample {
public static void main(String[] args) {
}
public static void county(){
try{
}catch(Exception e){
System.
}
}
public static void town() throws Exception{
}
public static void village() throws Exception{
throw new Exception();
}
}
】
2：【
public class TestThrow2 {
public static void main(String[] args) {
try{
}catch(Exception e){
e.printStackTrace();
}
}
//让test的调用者处理，向上抛出
public static void test() throws Exception{
//产生一个异常
throw new Exception();
}
}
】
3：【
public class IllegalArrayLengthException extends RuntimeException {
public IllegalArrayLengthException(String msg){
super(msg);
}
}
public static void main(String[] args) {
int[] array = {};
System.
}
public static int getMin(int[] array) throws IllegalArrayLengthException{
if(array.length == 0){
throw new IllegalArrayLengthException(
"数组长度不能为0");
}
int minIndex = 0;
for(int i=0;i<array.length;i++){
if(array[i]<array[minIndex]){
minIndex = i;
}
}
return array[minIndex];
}
】
4:自定义异常与综合应用
【
public class ViolentException extends Exception {
private String name;
private String address;
public ViolentException(String message){
super(message);
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
}
public class TestViolent {
public static void main(String[] args) {
}
public static void county(){
try{
}catch(ViolentException e){
System.
System.
System.
}
}
public static void town()throws ViolentException{
}
public static void village() throws ViolentException{
ViolentException e = new ViolentException("暴力抗拆");
e.setName("张小龙");
e.setAddress("北滨");
throw e;
}
}
】