Java中的数组
1 数组No11
数组：存放一组相同类型数据的数据结构
数组本身是引用数据类型，数组中的元素可以是基本数据类型，也可以是引用数据类型
【
Java中的数组以对象的形式存在，或者说数组本身是引用数据类型，数组中的元素(数组中的每一个数据)类型可以是基本数据类型，也可以是引用数据类型
】
如何使用：
1.声明：
元素类型[]引用名;或（引用声明，并未产生数组，等价）
元素类型引用名[];
元素类型变量名[10];不合法，不能在声明时指定数组长度
（因为引用中只是存放了对象的首地址，不可能存放长度信息）
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关键字，但是创建了一个数组对象；创建后自动初始化为{}中的值；数组长度为大括号内元素的个数
元素为引用数据类型的数组每个元素都是引用
3.访问：
数组引用名[数字下标]（下标范围从0到length-1，超出范围，会报越界异常<会报数组指针越界异常：java.lang.ArrayIndexOutOfBoundsException>）
可以通过这种方式访问打印，也可以进行对元素的初始化
访问数组可以对元素进行赋值：数组引用名【数组下标】=元素值
数组的访问和赋值可以用到循环赋值
数组的长度可以用其length属性来动态获得
数组的长度在数组创建后不能更改，如果实在需要一个长度不同的数组，
只能再创建一个
排序（升序：随着下标增加，元素越来越大；降序，越来越小）：
1.冒泡排序
（排序，将原来没有顺序的杂乱数组，变成从小到大（升序）或从大到小(降序)的顺序。）
《升序：将相邻的元素进行比较，如果左边的大，则将它们互换位置，如此不断循环向右判断，直到最大的数字冒到最右边。》
2. 选择排序
3. 插入排序
【实际开发中，使用Arrays.sort(…..)进行排序】
查找：告诉你某个值，在数组中查找出这个值对应的下标
查找：在数组中根据值查找元素，返回找到的元素的下标，如果一个都不符合返回-1.
1、顺序查找
从头到尾遍历数组，如果符合这个值就返回下标，如果一个都不符合返回-1.
2、二分法查找（必须是排过序的数据）
找到数组中间位置的元素和目标值比较，如果目标值大，就扔掉小的那就扔掉小的那一半数据(中间位置左边的)，如果目标值小，就扔掉大的那一半(中间位置右边的)；接下来对以上操作进行循环执行，直到中间位置元素等于目标值，就将其下标返回。
【】可变长数组
元素类型………引用名
《表示在方法的形参中声明一个可变长的数组，实参是用逗号隔开的一个单个元素(元素类型是形参数组的元素类型，)，而是这个可变长数组形参使用时还是将其当作数组用》
【
main方法的参数
在应用程序启动时可以传入参数，这些参数会自动转换为字符串数组，
我们可以在main方法中通过main方法的形参数组访问这些参数
】
数组的拷贝
【用=号进行数组拷贝并不是真正的拷贝，只是将两个引用指向同一个对象
】
二维数组：数组中的元素也是数组
1.声明：
元素类型[][] 引用名; 或
元素类型 引用名[][];
在声明时不能在中括号中指定长度
2.初始化：
①静态初始化：
元素类型[][]引用名={{元素1，元素2，元素3...},{...},{...}...};
（每个子数组的元素可以各不一样）
静态初始化必须和声明在同一语句中
②动态初始化：
(1)new元素类型[长度1][长度2];
【长度1：表示这个二维数组中有几个子数组
长度2：表示每个子数组中有几个元素(这样的话每个子数组长度一样)
(这样初始化出的每个元素的值为类型对应的默认值)】
【
New元素类型[长度1][]
长度1表示
长度2没有写，表示这几个子数组并未创建出来
】
（注意：不能写成new[] [2]）
二维数组的拷贝：
【
System.arraycopy是浅克隆，浅拷贝
深度克隆、深拷贝：将数组中的每个元素进行逐一拷贝。
】
长度1表示子数组个数，可以简单认为是行数，长度2表示每个子数组的长度，可以简单认为是列数——————用这种方式初始化每个子数组的长度都一样
(2)new 元素类型[长度1][]
长度1表示子数组个数，或者行数；长度2不写（不能只写长度2，不写长度1）
必须要手动创建各个子数组对象，并将各元素引用分别指向它们
每个子数组的长度可以不一样
3.访问：
引用名[下标1][下标2]表示二维数组的下标1的子数组的下标2的元素，如arr[0][1]就是第一个子数组的第二个元素
引用名[下标1]表示二维数组的下标为1的元素、子数组的对象
可以通过循环访问二维数组中的所有元素
Throwale(是Java中所有的异常、错误的父类，直接子类有：Error、Exception)
异常Exception（广义、体系）
Throwable可抛的，是所有异常和错误的父类
Error严重的问题，不需要程序去处理(错误)
Exception（狭义）是Throwable的子类，我们的应用程序需要去处理可能需要程序去处理
RuntimeException运行时异常，它和它的子类都是《非受检异常：unchecked exception》，它以及它的子类异常可以通过编写代码时严密的逻辑避免掉，不一定要通过要通过异常处理机制去处理
非受检异常：可以不对其进行异常处理，通过严谨的编码逻辑就可以避免的异常
如：ArrayIndexOutofBoundsException数组指针越界、NullPointerException:空指针、ClassCastException：类型转换、AarithmaticException：数学...：
受检异常：只要是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是产生一个创建好了的异常，让其出现在运行的程序中）
数组元素深度克隆、拷贝(循环拷贝数组中的每个元素)
1：【
int[]array={1,2,5,25,4,5};
int[]array2=newint[array.length];//创建一个相同长度的数组
for(inti=0;i
//将数组的每个元素赋值为旧数组对应的值
array2[i] =array[i];
}
array[0]=458;
】
2：【
int[]array={1,2,5,25,4,5};
int[]array2=newint[array.length];
//参数说明：
//一：原数组
//三：目标数组
//2：原数组起始位置4：目标数组起始位置
//拷贝的长度
System.arraycopy(array, 0,array2, 0,array.length);
array[0]=458;
】
3：二维数组拷贝
【
int[][]array={{1,2,3},{4,5,6}};
int[][]array2=newint[array.length][array[0].length];
// System.arraycopy(array, 0, array2, 0, array.length);
for(inti=0;i
System.arraycopy(array[i], 0,array2[i], 0,array[i].length);
}
array[0][0] = 7;
】
4：可变长数组
【
publicstaticvoidmain(String[]args) {
//TODOAuto-generatedmethod stub
int[]array={4,5,8,7,5,4,4,4,4,1,5,4};//可任意变
test(array);
}
//这个方法的形参就是一个可变长数组
publicstatic voidtest(int... arr){
System.out.println("arr的长度是:"+arr.length);
for(inti=0;i
System.out.println(i);
}
}
】
动态创建数组：
1：【
int[][] array = new int[3][4];
】
2：【
int[][]array=newint[4][];
intni=1;
intk=1;
for(inti=0;i
//每次都手动创建长度为4的子数组对象，并用二维数组的元素去指向
array[i] =newint[ni];
ni++;
}
】
异常处理机制
1：【
publicclassTestExample {
publicstaticvoidmain(String[]args) {
county();
}
publicstaticvoidcounty(){
try{
town();
}catch(Exceptione){
System.out.println("给钱");
}
}
publicstaticvoidtown()throwsException{
village();
}
publicstaticvoidvillage()throwsException{
thrownewException();
}
}
】
2：【
publicclassTestThrow2 {
publicstaticvoidmain(String[]args) {
try{
test();//调用者遇到异常则进行trycatch处理
}catch(Exceptione){
e.printStackTrace();
}
}
//让test的调用者处理，向上抛出
publicstaticvoidtest()throwsException{
//产生一个异常
thrownewException();
}
}
】
3：【
publicclassIllegalArrayLengthExceptionextendsRuntimeException {
publicIllegalArrayLengthException(Stringmsg){
super(msg);
}
}
publicstaticvoidmain(String[]args) {
int[]array= {};
System.out.println(getMin(array));
}
publicstaticintgetMin(int[]array)throwsIllegalArrayLengthException{
if(array.length== 0){
thrownewIllegalArrayLengthException(
"数组长度不能为0");
}
intminIndex= 0;
for(inti=0;i
if(array[i]
minIndex=i;
}
}
returnarray[minIndex];
}
】
4:自定义异常与综合应用
【
publicclassViolentExceptionextendsException {
privateStringname;
privateStringaddress;
publicViolentException(Stringmessage){
super(message);
}
publicString getName() {
returnname;
}
publicvoidsetName(Stringname) {
this.name=name;
}
publicString getAddress() {
returnaddress;
}
publicvoidsetAddress(Stringaddress) {
this.address=address;
}
}
publicclassTestViolent {
publicstaticvoidmain(String[]args) {
county();
}
publicstaticvoidcounty(){
try{
town();
}catch(ViolentExceptione){
System.out.println("打听名字:"+e.getName());
System.out.println("打听地址:"+e.getAddress());
System.out.println("给钱");
}
}
publicstaticvoidtown()throwsViolentException{
village();
}
publicstaticvoidvillage()throwsViolentException{
ViolentExceptione=newViolentException("暴力抗拆");
e.setName("张小龙");
e.setAddress("北滨");
throwe;
}
}
】
