Arrays 操作数组的工具类，内部类，Lambda 表达式，异常

Arrays 操作数组的工具类
    静态工厂

int[] arr1 = new int[]{3,1,5,4,2};
int[] arr2 = new int[]{3,1,5,4,2};
int[] arr5 = new int[10];

System.out.println(arr1==arr2); //false
//static boolean equals(int[] a, int[] a2) 如果两个指定的int数组彼此 相等 ，则返回 true 。
System.out.println(Arrays.equals(arr1,arr2));  //true
//static String toString(int[] a) 返回指定数组内容的字符串表示形式。
System.out.println(Arrays.toString(arr1));
System.out.println(arr1);

double[][] arr3 = new double[][]{{1.1,2.2,3.3},{4.4,5.5}};
double[][] arr4 = new double[][]{{1.1,2.2,3.3},{4.4,5.5}};
//static boolean deepEquals(Object[] a1, Object[] a2) 如果两个指定的数组彼此 深度相等 ，则返回 true 。
System.out.println(arr3==arr4);  //false
System.out.println(Arrays.equals(arr3,arr4));  //false
System.out.println(Arrays.deepEquals(arr3,arr4));  //true

//static String deepToString(Object[] a) 返回指定数组的“深层内容”的字符串表示形式。
System.out.println(Arrays.toString(arr3));
System.out.println(Arrays.deepToString(arr3));

//数组拷贝
//static int[] copyOf(int[] original, int newLength) 把参数1数组拷贝到指定长度(参数2)新数组中返回  新数组有copyOf方法内部创建
//拷贝
System.out.println(Arrays.toString(Arrays.copyOf(arr1,5))); //当新数组长度=原数组长度    原数组的拷贝诶
//截取
System.out.println(Arrays.toString(Arrays.copyOf(arr1,3))); //当新数组长度<原数组长度    默认从原数组索引为0的位置开始拷贝,拷贝参数2个
//填充
System.out.println(Arrays.toString(Arrays.copyOf(arr1,8))); //当新数组长度>原数组长度    最后的空余位置使用默认值填充


//static int[] copyOfRange(int[] original, int from, int to) 将指定数组的指定范围复制到新数组中。  新数组有copyOfRange方法内部创建
System.out.println(Arrays.toString(Arrays.copyOfRange(arr1,1,3)));  //结束索引位置数据一般不包含

//copyOf 默认从索引为0位置开始拷贝,copyOfRange可以实现拷贝原数组指定区间范围的数据
//copyOfRange与copyOf数组拷贝方法,新数组都是方法内部构建,如果自定义指定新数组,可以使用System.arraycopy方法进行拷贝
//static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length) 将指定源数组中的数组从指定位置开始复制到目标数组的指定位置。
System.arraycopy(arr1,1,arr5,5,3);
System.out.println(Arrays.toString(arr5));

内部类 
    类中定义类
    当一类中的成员,作为另外一种事物的时候,这个成员就可以定义为内部类

    分类:
        成员内部类
        静态内部类
        私有内部类
        局部内部类
        匿名内部类 
        

成员内部类
    一个类定义在外部类的成员位置就为成员内部类
    具有类的特点,继承,实现...
    成员内部类具有成员的特点,被成员修饰符修饰

注意:
    在成员内部类中不能定义静态内容,除了静态常量,静态内部类才能任意定义静态内容
    在成员内部类中可以使用外部类中的成员,包括私有的,静态的
    在外部类中可以跟随成员内部类的对象使用成员内部类的成员
    成员内部类的对象性需要通过外部类对象构建    
        外部类名.内部类类名 引用 = new 外部类().new 内部类();
    跟随内部类的对象使用内部类的成员,注意访问权限

public class Class001_Outer {
    //成员: 类中方法外
    private int i = 1;
    private static int j = 5;

    //成员内部类
    class Inner{
        private int a = 10;

        public void testInner(){
            System.out.println("成员内部类中的成员方法");
            System.out.println(i);
            System.out.println(j);

            //outer();
        }
    }

    public void outer(){
        System.out.println("成员方法");
        Inner in = new Inner();
        System.out.println(in.a);
        in.testInner();
    }
}

//测试成本员内部类使用
 //成员内部类的对象性需要通过外部类对象构建
 //1)
 Class001_Outer out = new Class001_Outer(); //外部类对象
 Class001_Outer.Inner in = out.new Inner();
 //2)
 Inner in = new Class001_Outer().new Inner();
 in.testInner();

静态内部类:
    可以定义静态内容(成员),成员内部类中不可以直接定义静态内容除了静态常量以外
    静态内部类中可以直接使用外部类中静态内容,需要通过外部类对象使用外部类中的成员(因为内部类本身是静态的)
    外部类中可以直接通过内部类对象使用内部类成员,可以通过内部类的类名使用内部类静态内容
    其他类中使用静态内部类中内容:
        静态内部类中的静态内容 : 外部类类名.内部类类名.静态内容
        静态内部类中的成员内容: new 外部类类名.内部类类名();  通过内部类对象调用它成员

public class Class004_Outer {
    //成员: 类中方法外
    private int i = 1;
    private static int j = 5;
    //静态内部类
    static class Inner{
        //成员变量
        int a = 1;
        //静态变量
        static int b = 10;

        //成员方法
        public void test(){
            System.out.println(j);
            System.out.println(new Class004_Outer().i);
        }
        //静态方法
        public static void testStatic(){
            System.out.println(j);
            System.out.println(new Class004_Outer().i);
        }

    }

    void outer(){
        //静态内部类对象
        Inner in = new Inner();
        System.out.println(in.a);
        System.out.println(in.b);
        System.out.println(Inner.b);

        Inner.testStatic();
        in.test();
    }

}

//测试静态内部类的使用
//静态内部类中的静态内容 : 外部类类名.内部类类名.静态内容
System.out.println(Class004_Outer.Inner.b);
Class004_Outer.Inner.testStatic();
//静态内部类中的成员内容: new 外部类类名.内部类类名();  通过内部类对象调用它成员
Class004_Outer.Inner in2 = new Class004_Outer.Inner();
in2.test();
System.out.println(in2.a);

私有内部类
    只能在当前外部类中通过内部类对象使用

局部内部类
    1.不能被成员修饰符等修饰(public,private,protected,static)
    2.局部内部类中不能定义静态内容,除了静态常量
    3.局部内部类中可以直接使用外部类成员,可以使用所在方法中的局部变量
    4.局部内部类只能在当前所在的方法中通过内部类对象使用,其他位置无法使用
    5.在局部内部类中使用了所在方法中的局部变量|形参,这个局部变量会默认被final修饰
        jdk8开始默认被final修饰
        jdk7及之前需要显示被final修饰

//成员位置
private int i = 1;
private static int j = 2;

public void test(){
    //局部位置
    int c  = 1;

    //c = 2;

    //局部内部类
    class Inner{
        static final int a = 1;
        int b = 2;

        void inner(){
            System.out.println("局部内部类中的成员方法");
            System.out.println(c);
            System.out.println(i);
            System.out.println(j);
        }
    }

    //1.测试所在方法中能够使用局部内部类中的内容
    Inner in = new Inner();
    System.out.println(in.b);
    in.inner();

//测试私有内部类的使用
//new Class005_Outer().new Inner();

匿名内部类
    作用: 用来简化没有本身自己作用的实现类|子类
        上层 : 接口 | 抽象类    

public class Class007_Outer {
    public static void main(String[] args) {
        //匿名对象 : 只能在当前行使用一次
        new String();

        //创建 实现类对象调用重写后的抽象方法
        new Demo().smoking();

        //匿名内部类
        //1) 匿名内部类对象 : 没有引用指向的匿名对象 :只能在当前行使用一次
        new Smoke() {//实现类的类体
            @Override
            public void smoking() {
                System.out.println("一边哈哈笑一边吸烟...");
            }
        }.smoking();

        //2. 引用指向的匿名内部类对象 : 通过引用后续使用多次
        Smoke s =  new Smoke(){
            @Override
            public void smoking() {
                System.out.println("一边吸气一边吸烟");
            }
        };

        s.smoking();
        s.smoking();

        //3.匿名内部类对象作为实参传递
        test( new Smoke(){
            @Override
            public void smoking() {
                System.out.println("一边吸气一边吸烟");
            }
        });

        //通过匿名 内部类简化子类
        Car car = new Car(){
            @Override
            void run() {
                System.out.println("run....");
            }
        };
        car.run();
    }

    static void test(Smoke smoke){
        smoke.smoking();
    }
}

//抽象类
abstract class Car{
    abstract void run();
}

//接口
interface Smoke{
    void smoking();
}

//实现类 ,重写抽象方法
class Demo implements Smoke{
    @Override
    public void smoking() {
        System.out.println("一边呲着牙一边吸烟...");
    }
}

Lambda 表达式  *****
    jdk8新增lambda表达式

    作用: 为了简化匿名内部类对象

    前提: 函数式接口
    函数式接口 : 只有一个必须被重写的抽象方法的接口
    强制检测是否为函数式接口:
                    注解: @FunctionalInterface

    语法:
        ()->{}
        () :  匹配要重写的抽象方法的参数列表
        -> : 箭头函数  箭头符号
        {} : 要重写的抽象方法的方法体

//lambda写法1 : ()->{}
  Run r = ()->{
      System.out.println("run....");
  };

  r.run();

  //lambda写法2: 当方法体只有一句 ,前后的{}可以省略
  Run r = ()->System.out.println("跑....");

  r.run();

  //lambda写法3: 当方法具有参数,参数的类型可以省略
  Run r = (a,b)->System.out.println("跑...."+(a+b));

  r.run(1,2);

  //lambda写法4: 当方法的参数只有一个 ,前后的()可以省略
  Run r = a -> System.out.println("跑...."+(a));

  r.run(1);

  //lambda写法5: 当方法存放返回值,并且{}中的语句体只有一句,就是return语句,前后的{}与return关键字可以一起省略
  Run r = a -> a>0;

  r.run(1);

异常:
    程序无法正常执行完毕

异常体系:
        Throwable
        /       \
     Error      Exception


   Error : 错误,一般由虚拟机生成并脱出,无需要程序猿管理
   Exception : 异常
     CheckedException 编译时异常|检查时异常:  发生在程序编译期间
        程序如果遇到编译时异常没有处理,程序无法正常运行
     RuntimeException 运行时异常 : 发生程序运行期间
        一般可以通过增强程序健壮性的代码处理 if

   注意 :
        如果程序遇到异常没有处理,无法继续执行

   常见的一些运行时异常:
    1.空指针异常 NullPointerException
    2.数组越界异常 ArrayIndexOutOfBoundsException
    3.数组长度负数异常 NegativeArraySizeException
    4.类型转换异常 ClassCastException
    5.数学异常 ArithmeticException
    6.数字格式异常 NumberFormatException