java8 jdk1.8 lambda表达式(一) 入门篇

更快速度!!!

java8 jdk1.8 lambda表达式(一) 入门篇
java8 jdk1.8 lambda表达式(二) 语法篇
java8 jdk1.8 lambda表达式(三) 四大核心函数式接口

在jdk1.8中对hashMap等map集合的数据结构优化。

• hashMap数据结构的优化 :
  原来的hashMap采用的数据结构是哈希表（数组+链表），hashMap默认大小是16，一个0-15索引的数组，如何往里面存储元素，首先调用元素的
  hashcode 方法，计算出哈希码值，经过哈希算法算成数组的索引值

• 如果对应的索引处没有元素，直接存放, 如果有对象在，那么比较它们的equals方法比较内容
  ,如果内容一样，后一个value会将前一个value的值覆盖，如果不一样，在1.7的时候，后加的放在前面，形成一个链表，形成了碰撞，在某些情况下如果链表
  无限下去，那么效率极低，碰撞是避免不了的

• 加载因子：0.75，
  数组扩容，达到总容量的75%，就进行扩容，但是无法避免碰撞的情况发生 . 在1.8之后，在数组+链表+红黑树来实现hashmap，当碰撞的元素个数大于8时 & 总容量大于64，会有红黑树的引入 .

• 除了添加之后，效率都比链表高，1.8之后链表新进元素加到末尾 ConcurrentHashMap
  (锁分段机制)，concurrentLevel,jdk1.8采用CAS算法(无锁算法，不再使用锁分段)，数组+链表中也引入了红黑树的使用

Lambda

   lambda表达式本质上是一段匿名内部类，也可以是一段可以传递的代码

直接开始吧,看看下面个方法有啥区别~

匿名内部类

    @Test
    public void test1(){
        Comparator<Integer> com = new Comparator<Integer>() {
            @Override
            public int compare(Integer x, Integer y) {
                return Integer.compare(x,y);
            }
        };

        TreeSet<Integer> treeSet = new TreeSet<>(com);
    }

lambda 表达式

    public void test2(){
        Comparator<Integer> com = (x,y) -> Integer.compare(x,y);
        TreeSet<Integer> treeSet  = new TreeSet<>(com);
    }

注: 匿名内部类 和 Lambda 表达式的只有 Integer.compare(x,y) 是重要的,lambda表达式减少了代码量

---

---

---

看看这些吧~

创建一个实体类

package lambda;

import jdk.nashorn.internal.objects.annotations.Getter;
import jdk.nashorn.internal.objects.annotations.Setter;

/**
 * @author xyy
 * @date 2021年04月23日 11:03
 */

public class Person {
    private String name;
    private int age;
    private double salary;

    public Person(){
    }

    public Person(String name, int age, double salary) {
        this.name = name;
        this.age = age;
        this.salary = salary;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", salary=" + salary +
                '}';
    }
}

在测试类中声明一个数组

    List<Person> personList = Arrays.asList(
            new Person("张三",18,111.111),
            new Person("李四",28,222.222),
            new Person("王五",38,333.333),
            new Person("赵六",48,444.444),
            new Person("申七",58,555.555),
            new Person("老八",68,666.666)
    );

获取上面数组中年龄大于20的人

    @Test
    public void test3(){
        List<Person> personList = filterPerson(this.personList);
        for (Person ps: personList) {
            System.out.println(ps);
        }
    }
    
    public List<Person> filterPerson(List<Person> list){
        List<Person> personList = new ArrayList<>();
        for (Person ps: list) {
            if(ps.getAge()>20){
                personList.add(ps);
            }
        }
        return personList;
    }

运行结果

Person{name='李四', age=28, salary=222.222}
Person{name='王五', age=38, salary=333.333}
Person{name='赵六', age=48, salary=444.444}
Person{name='申七', age=58, salary=555.555}
Person{name='老八', age=68, salary=666.666}

---

---

---

test3 代码优化的四种方式:

1. 策略设计模式:

创建MyPerdicate接口:

@FunctionalInterface
public interface MyPerdicate<T> {
    public boolean test(T t);
}

创建 age (年龄)有关的实现类: 判断年龄大于35的

public class filterPersonByAge implements MyPerdicate<Person>{
    public boolean test(Person person) {
        return person.getAge()>35;
    }
}

创建 salary(工资) 有关的实现类,判断工资高于500的

public class filterPersonBySalary implements MyPerdicate<Person>{
    @Override
    public boolean test(Person person) {
        return person.getSalary()>500;
    }
}

对方法重写:

    public List<Person> filterPerson(List<Person> list,MyPerdicate<Person> perdicate){
        List<Person> personList = new ArrayList<>();
        for (Person ps: list) {
            if(perdicate.test(ps)){
                personList.add(ps);
            }
        }
        return personList;
    }

编写测试方法

    @Test
    public void test4(){
        List<Person> ps = filterPerson(personList, new filterPersonByAge());
        for (Person p: ps) {
            System.out.println(p);
        }
        System.out.println("-----------------------------------------------------");
        List<Person> ps1 = filterPerson(personList, new filterPersonBySalary());
        for (Person p: ps1) {
            System.out.println(p);
        }

    }

注:根据filterPerson方法所传的实现类来判断执行那个方法

是不是感觉麻烦的一批???
是不是感觉麻烦的一批???
是不是感觉麻烦的一批???

看看下面这个ba~

---

2. 匿名内部类 : 只需要接口!!!不需要实现方法~

    @Test
    public void test5(){
        List<Person> personList = filterPerson(this.personList, new MyPerdicate<Person>() {
            @Override
            public boolean test(Person person) {
                return person.getSalary() <= 300;
            }
        });
        for (Person p: personList) {
            System.out.println(p);
        }
    }

是不是还是感觉麻烦???
是不是还是感觉麻烦???
是不是还是感觉麻烦???
继续!!!

---

3:Lambda 表达式 : 无需接口 无需实现类

    @Test
    public void test6(){
        List<Person> personList = filterPerson(this.personList, person -> person.getAge() > 35);
        personList.forEach(System.out::println);
    }

是不是很简单了???
是不是很简单了???
是不是很简单了???

肘子~

---

4: Stream API :流,链式操作

    @Test
    public void test7(){
        personList.stream().
                filter(person -> person.getAge()>40)
                .limit(2)
                .forEach(System.out::println);
        System.out.println("-------------------------------");
        personList.stream()
                .map(Person::getName)
                .forEach(System.out::println);
    }

嘟嘟嘟嘟~
第一部分完事了~~~