2019-08-16 java ArrayList操作，lambda表达式（闭包）

数组基本分类

/**
 * 数组：储存多个对象
 * int[] score = {1,2,3};
 * int[] score = new int[10];
 * 弊端：数组长度不可变 内容可变
 *
 * 实际开发中需要一个能够随时改变的数组-> 集合collection
 * Collection抽象接口 定义集合的相关操作
 *  |--List 列表 数组  特点：有序 可重复
 *    |--ArrayList
 *    |--LinkedArrayList
 *  |--Set 集合 特点：无序 不可重复
 *    |--HashSet
 *  Map接口 映射关系 Key-Value 键值对 键不能相同 值可以相同
 *   |--HashMap
 *  集合的元素个数是可变的
 *  添加元素
 *   add
 *   addall
 *  删除元素
 *  插入元素
 *  访问元素
 * */

一.java ArrayList操作

部分方法使用示例：

public  class MyClass {
    public static void main(String[] args){
       Collection t1 =new ArrayList();
        ((ArrayList) t1).add("little jack");
        ((ArrayList) t1).add("merry");
        System.out.println(t1);

        //删除一个对象
        t1.remove("little jack");
        System.out.println(t1);

        //获取元素个数
        System.out.println(t1.size());

        //判断是否包含一个元素
        if(t1.contains("merry")){
            System.out.println("has merry");

        }else {
            System.out.println("not merry");
        }

        //判断是否为空
        if(t1.isEmpty()){
            System.out.println("is empty");
        }else {
            System.out.println("not empty");
        }

        //判断两个集合是否相同
        Collection t2 = new ArrayList();
        t2.add("merry");
        t2.add("jack");

        if(t1.equals(t2)){
            System.out.println("same");

        }else {
            System.out.println("different");
        }

        //清空
        t2.clear();
        System.out.println(t2);

集合的遍历：

//集合的遍历
        //1.使用Iterator来遍历
        // hasNext 判断是否有元素
        // next 获取下一个对象
        //remove 删除当前遍历过后的对象
        Iterator iterator = t2.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }
       
        //2.for-each 增强for循环 快速循环
        for(String obj:t2){
            System.out.println(obj);
        }

注意：

 while(iterator.next()!=null){
            System.out.println(iterator.next());
       }

相当于提前就直接进行了指针指向下一个元素的操作，打印的也是当前指向的下一个元素，输出的一直是从第二个元素开始的偶数位元素。

建议：在遍历数组的同时尽量不要同时进行删除元素的操作(foreach写法是对实际的Iterable、hasNext、next方法的简写)

---

---

二.lambda表达式（闭包）

Lambda 允许把函数作为一个方法的参数（函数作为参数传递进方法中）。

使用 Lambda 表达式可以使代码变的更加简洁紧凑。

语法:

lambda 表达式的语法格式如下：

(parameters) -> expression或

(parameters) ->{ statements; }

以下是lambda表达式的重要特征:

可选类型声明：不需要声明参数类型，编译器可以统一识别参数值。

可选的参数圆括号：一个参数无需定义圆括号，但多个参数需要定义圆括号。

可选的大括号：如果主体包含了一个语句，就不需要使用大括号。

可选的返回关键字：如果主体只有一个表达式返回值则编译器会自动返回值，大括号需要指定明表达式返回了一个数值。

Lambda 表达式的简单例子:

// 1. 不需要参数,返回值为 5  
() -> 5  

// 2. 接收一个参数(数字类型),返回其2倍的值  
x -> 2 * x  

// 3. 接受2个参数(数字),并返回他们的差值  
(x, y) -> x – y  

// 4. 接收2个int型整数,返回他们的和  
(int x, int y) -> x + y  

// 5. 接受一个 string 对象,并在控制台打印,不返回任何值(看起来像是返回void)  
(String s) -> System.out.print(s)

用于不用lambda表达式打印一个数组的区别：

  //1.使用方式 定义一个类实现接口
        ArrayClass ac = new ArrayClass();
        int[] num ={1,2,3,4,5,6};
        Access as = new Access();
        ac.test(num,as);

        //2.使用匿名类
        ArrayClass ac = new ArrayClass();
        int[] num ={1,2,3,4,5,6};
        Access as = new Access();
        ac.test(num, new Show() {
            @Override
            public void customShow(int element) {
                System.out.println(element);
            }
        });

        //3.
        ArrayClass ac = new ArrayClass();
        int[] num ={1,2,3,4,5,6};
        ac.test(num,(int element)->{
            System.out.println(element);
        });
        //5.如果代码块里面只要一行语句 大括号可以省略
                ArrayClass ac = new ArrayClass();
        int[] num ={1,2,3,4,5,6};
        ac.test(num,(int element)->System.out.println(element));
//闭包 Closure 把函数作为一个方法的参数
class ArrayClass{
    public void test(int[] target,Show s){
        for(int element:target){
            s.customShow(element);
        }
    }

}
// 必须是接口 这个接口里面只能有一个方法
interface Show{
    void customShow(int element) ;
}
class Access implements Show{
    @Override
    public void customShow(int element){
        System.out.println(element);
    }
}

Lambda 表达式主要用来定义行内执行的方法类型接口

Lambda 表达式免去了使用匿名方法的麻烦，并且给予Java简单但是强大的函数化的编程能力。