jdk8新特性-Lambda表达式与Stream流实战_18stream69

这部分会详细的写jdk1.8新特性，lambda表达式的使用以及stream流的使用。

准备工作

@FunctionalInterface
public interface GreetAble {
    void greet();
}

public class Human {
    public void sayHello(){
        System.out.println("hello");
    }
}

public class Husband {
    public void marry(RichAble richAble){
        richAble.buy();
    }
    public void  buyHouse(){
        System.out.println("买套房子!");
    }
    public void beHappy(){
//        marry(()-> System.out.println("买套房子"));
        marry(this::buyHouse);
    }
}

public class Man extends Human {
    @Override
    public void sayHello() {
        System.out.println("大家好，我是Man!");
    }
    
    
    public void method(GreetAble greetAble){
        greetAble.greet();
    }
    public void show(){
        //method(()->new Human().sayHello());
        //使用super代替父类对象
        method(super::sayHello);
    }
}

public class Person {
    private String name;

    public String getName() {
        return name;
    }

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

    }
    public Person(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return this.getClass().getName()+"["+name+"]";
    }
}


@FunctionalInterface
public interface RichAble {
    void buy();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

1. Lambda表达式及方法引用

/**怎么编写lambda表达式?
 * 1：看参数
 * 2：看返回值
 *
 * 下面的是函数式接口:Object中的方法除外，static方法除外，default方法除外
 * jdk1.8之前的一些函数式接口
 * java.lang.Runnable
 * java.util.concurrent.Callable<V>
 * java.util.Comparator<T>
 * 下面介绍几个常用的：都在java.util.function包下。
 * Supplier<T>:代表一个输出
 * Consumer<T>:代表一个输入
 * Predicate<T>:输入是T，输出是boolean
 * BiConsumer<T, U>:代表两个输入
 * Function<T, R>:代表一个输入和输出
 * BiFunction<T, U, R>:代表两个输入和一个输出。
 * UnaryOperator<T>:代表一个输入，一个输出，但是，输入和输出是相同类型。
 * BinaryOperator<T>:代表两个输入，一个输出，但是全都是相同类型。
 * 其他的都与上面的类似，属于上面的基础上进行的扩展。
 * @author 12706
 *
 *1、静态方法的引用
 *2、实例方法的引用
 *3、对象方法的引用
 *4、构造方法的引用
 */
public class LambdaExpress {
    /**
     * lambda的使用
     * 1、看参数
     * 2、看返回值
     */
    @Test
    public void testLambda() throws Exception {
        //1、无参无返回值,没有参数括号是不能省的，只有一句代码那么{}就可以省了
        Runnable r = () -> System.out.println("hello world");

        //2、无参有返回值，只有一句话那么return就可以省了
        Callable c = () -> 5;
        Supplier<String> supplier = () -> "world";

        //3、有参无返回值
        Consumer<String> consumer = s -> System.out.println(s+":world");

        //4、有参有返回值
        Function<String,Integer> function = s -> Integer.valueOf(s);
        r.run();
        System.out.println(c.call());
        System.out.println(supplier.get());
        consumer.accept("tom");
        System.out.println(function.apply("101"));
    }
    @Test
    public void testFunction() throws Exception {
        /*
        最基础的：Consumer<T>,Supplier<>,Predicate<T>返回boolean用来测试，比如filter的参数,Function<T,U>
        双重：BiConsumer<T,U>两个输入，BiFunction<T, U, R>T,U表示输入，R表示输出
            BiPredicate<T, U>两个输入
        UnaryOperator<T>:代表一个输入，一个输出，但是，输入和输出是相同类型。继承Function
        BinaryOperator<T>:代表两个输入，一个输出，但是全都是相同类型。继承BiFunction
        IntConsumer输入int,IntSupplier输入int,IntFunction<R>输入int,IntPredict输入int
        此外还有Doublexxx,Longxxx等，另外还有些感觉用不到的，看源代码即可。
        比如ToLongFunction<T>输入是T，输出是Long
         */
        Predicate<String> predicate = str -> str.charAt(0)>'a';
        BiConsumer<Integer,String> biConsumer = (num,str)->System.out.println(num+":"+str);
        BiFunction<Integer,String,Integer> biFunction = (num,str)->Integer.valueOf(str)+num;
        BiPredicate<Integer,Integer> biPredicate = (num1,num2)->num1>num2+3;
    }
    /*
    通过对象名引用成员方法  实例方法的引用
    使用前提是对象名是已经存在的,成员方法也是已经存在  实例对象的方法能满足函数式接口的实现
    就可以使用对象名来引用成员方法
    */
    public String pop(){
        return "hello";
    }
    @Test
    public void objMethodRefTest(){
        Supplier<String> supplier = () -> {
            LambdaExpress express = new LambdaExpress();
            return  express.pop();
        };
        //使用实例方法引用改造
        //对象存在  express
        //方法存在 pop
        LambdaExpress express = new LambdaExpress();
        Supplier<String> supplier2 = express::pop;
        System.out.println(supplier.get());
        System.out.println(supplier2.get());
    }
    /**
     * 静态方法的引用
     */
    @Test
    public void staticMethodRefTest(){
        Function<Integer,Integer> f1 = num1 -> Math.abs(num1);
        //静态方法引用
        //类存在 Math
        //静态方法存在 abs
        Function<Integer,Integer> f2 = Math::abs;
        System.out.println(f1.apply(-10));
        System.out.println(f2.apply(-10));
    }
    /**
     * 构造方法的引用
     */
    @Test
    public void constructorMethodRefTest(){
        Function<String,Person> f1 = name -> new Person(name);
        Function<String,Person> f2 = Person::new;
        System.out.println(f1.apply("tom"));
        System.out.println(f2.apply("tom"));
    }
    /**
     * 通过super引用成员方法
     */
    @Test
    public void superMethodRefTest(){
        Man man = new Man();
        man.show();
    }
    /**
     * 通过this引用成员方法
     */
    @Test
    public void thisMethodRefTest(){
        Husband husband = new Husband();
        husband.buyHouse();
    }

    /**
     * 数组的构造器引用
     */
    @Test
    public void arrayConsMethodRefTest(){
        Function<Integer,int[]> f1 = int[]::new;
        System.out.println(f1.apply(10).length);
    }
    /**
     * 对象方法的引用
     * 抽象方法的第一个参数刚好是实例的类型，后面的参数和实例方法的参数类型一致（即输入参数类型和返回类型一致）
     * 类名::方法名， 和静态方法引用的写法一样
     * 了解就好，前面两个是重点
     * 注:要求函数一定要求有参数像Suppier就不行
     * 真的很诡异
     *
     */
    public void sayHello(String name){
        System.out.println("hello,我的名字叫:"+name);
    }
    @Test
    public void abstractMethodRefTest(){
        LambdaExpress express = new LambdaExpress();
        BiConsumer<LambdaExpress,String> biConsumer = (l, name)->l.sayHello(name);
        biConsumer.accept(express,"jinBingmin");

        BiConsumer<LambdaExpress,String> biConsumer2 = LambdaExpress::sayHello;
        biConsumer2.accept(express,"Jack");
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162

2.stream流的使用

/**
 * 创建Stream
 * @author 12706
 *
 *终止操作:
 *循环:forEach
 *计算:max,min,count,average
 *匹配:anyMatch,allMatch,noneMatch,findFirst,findAny
 *汇聚:reduce
 *收集器:toArray,collect
 *
 *中间操作:
 *过滤:filter
 *去重 :distinct
 *排序:sorted
 *截取:limit,skip
 *转换:map/flatMap
 *其他:peek
 *
 */
public class StreamTest {
    /**
     * 1、使用数组创建 int数组不行，泛型会是int[]
     * stream.of(泛型数组)
     */
    static void gen1(){
       Integer[] arr = {1,2,3,4};
        Stream<Integer> s = Stream.of(arr);
        s.forEach(System.out::println);
    }
    /**
     * 2、使用集合  collection.stream()
     */
    static void gen2(){
        Stream<Character> stream = Arrays.asList('a', 'b', 'c', 'd').stream();
        stream.forEach(System.out::println);
    }
    /**
     * 3、使用generate
     */
    static void gen3(){//不限制10条则会一直打印2
        Stream<Integer> stream = Stream.generate(() -> 2).limit(10);
        stream.forEach(System.out::println);
    }
    /**
     * 4、使用iterate
     * * @param seed the initial element
     * @param f a function to be applied to to the previous element to produce
     *          a new element
     * @return a new sequential {@code Stream}
     *public static<T> Stream<T> iterate(final T seed, final UnaryOperator<T> f)
     *
     */
    static void gen4(){
        Stream<Integer> stream = Stream.iterate(1, x -> x + 1).limit(10);
        stream.forEach(System.out::println);
    }
    /**
     * 5、其他api创建
     * @throws IOException
     */
    static void gen5() throws IOException {//打印97-101
        String s = "abcde";
        IntStream chars = s.chars();
        chars.forEach(System.out::println);

        //一行一行读取
        Stream<String> lines = Files.lines(Paths.get("D:\\workspaces\\maven-test2\\src\\main\\resources\\hello.txt"));
        lines.forEach(System.out::println);
    }

    public static void main(String[] args) throws IOException {
//        StreamTest.gen5();
        //      *终止操作:
//      *循环:forEach
//      *计算:max,min,count,average
//      *匹配:anyMatch,allMatch,noneMatch,findFirst,findAny
//      *汇聚:reduce
//      *收集器:toArray,collect
        //先介绍下中间操作filter:具有延迟计算特性，必须终止才执行 打印偶数
        Arrays.asList(1,2,3,4,5,6).stream().filter(x->x%2==0).forEach(System.out::println);
        //偶数求和sum()  注:sum()是InteStream才有的函数,Stream是没有的所以要转mapToInt
        int s = Arrays.asList(1, 2, 3, 4, 5, 6).stream().filter(x -> x % 2 == 0).mapToInt(x -> x).sum();
        System.out.println(s);
        //求偶数最小值(最大值也一样)
        Optional<Integer> minVal = Arrays.asList(1, 2, 3, 4, 5, 6).stream().filter(x -> x % 2 == 0).min((a, b) -> a - b);
        if(minVal.isPresent()) System.out.println(minVal.get());

        //找出第一个满足条件的
        Optional<Integer> fVal = Arrays.asList(1, 2, 3, 4, 5, 6).stream().filter(x -> x % 2 == 0).findFirst();//或者findAny

        //从1-50里面的所有偶数找出来，放到一个list里面
        List<Integer> list = Stream.iterate(1, x -> x + 1).limit(50).filter(x -> x % 2 == 0).collect(Collectors.toList());

        //      *中间操作:
//      *过滤:filter
//      *去重 :distinct
//      *排序:sorted
//      *截取:limit,skip
//      *转换:map/flatMap
//      *其他:peek
//      */
        //去重排序后找最小的
        Optional<Integer> first = Arrays.asList(3, 2, 10, 8, 10, 4, 4).stream().distinct().sorted().findFirst();

        //自定义排序
        List<String> list1 = Arrays.asList("aaa", "abbdf", "a", "aa").stream().sorted((s1, s2) -> s1.length() - s2.length()).collect(Collectors.toList());
        System.out.println(list1);

        //去重distinct,或者使用toSet
        List<Integer> list2 = Arrays.asList(1, 1, 2, 2, 3, 3, 4, 5).stream().distinct().collect(Collectors.toList());
        Set<Integer> set = Arrays.asList(1, 1, 2, 2, 3, 3, 4, 5).stream().collect(Collectors.toSet());

        //skip(10)表示忽略前十个,limit和skip可以用来做分页。
        //skip(0)，limit(10)，表示取第一页，取10个.skip(10)表示第二页
        List<Integer> list3 = Stream.iterate(1, x -> x + 1).limit(50).filter(x -> x % 2 == 0).skip(5).limit(5).collect(Collectors.toList());

        //转换操作
        //将字符串分割，依次转换成int，然后求和  map要求传入的是Function
        /*
         * IntStream mapToInt(ToIntFunction<? super T> mapper);
         * 而ToIntFunction要求实现int applyAsInt(T value);即传入T，返回Integer
         */
        String str = "11,22,33,44,55";
        int sum = Stream.of(str.split(",")).map(Integer::valueOf).mapToInt(x -> x).sum();
        System.out.println(sum);
        //或者一步到位
        Stream.of(str.split(",")).mapToInt(Integer::valueOf).sum();

        //字符串转换为对象map
        String str2 = "tomcat,nginx,apache,jetty";
        Stream.of(str2.split(",")).map(Person::new).forEach(System.out::println);
        //其他 类似于记个日志,把每个元素取出来做个操作
        Stream.of(str2.split(",")).peek(System.out::println).map(Person::new).forEach(System.out::println);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137

3. stream实战

public class StreamInAction {
    static class Book{
        private int id;
        private String name;
        private double price;
        private String type;
        private LocalDate date;
        public Book(int id,String name,double price,String type,LocalDate localDate){
            this.id = id;
            this.name = name;
            this.price = price;
            this.type = type;
            this.date = localDate;
        }

        @Override
        public String toString() {
            return this.getClass().getName()+"["+this.getId()+","+this.getName()+","+this.getPrice()+","+this.getType()+","+this.getDate()+"]";
        }

        public String getName() {
            return name;
        }

        public int getId() {
            return id;
        }

        public String getType() {
            return type;
        }

        public double getPrice() {
            return price;
        }

        public LocalDate getDate() {
            return date;
        }
    }
    private static final List<Book> BOOK_LIST = books();
    private static List<Book> books() {
        List<Book> books = new ArrayList<>();
        books.add(new Book(1,"tomcat",50d,"服务器",LocalDate.parse("2014-05-17")));
        books.add(new Book(2,"nginx",60d,"服务器",LocalDate.parse("2014-06-17")));
        books.add(new Book(3,"java",70d,"编程语言",LocalDate.parse("2013-03-17")));
        books.add(new Book(4,"ruby",50d,"编程语言",LocalDate.parse("2014-05-27")));
        books.add(new Book(5,"hadoop",80d,"其它",LocalDate.parse("2015-11-17")));
        books.add(new Book(6,"spark",45d,"其它",LocalDate.parse("2012-03-17")));
        books.add(new Book(7,"storm",55d,"其它",LocalDate.parse("2014-10-17")));
        books.add(new Book(8,"kafka",60d,"其它",LocalDate.parse("2016-03-14")));
        books.add(new Book(9,"lucene",70d,"其它",LocalDate.parse("2012-05-17")));
        books.add(new Book(10,"solr",35d,"其它",LocalDate.parse("2013-05-17")));
        books.add(new Book(11,"jetty",90d,"服务器",LocalDate.parse("2014-05-17")));
        books.add(new Book(12,"设计模式",60d,"其它",LocalDate.parse("2015-05-17")));
        books.add(new Book(13,"数据结构",70d,"其它",LocalDate.parse("2011-05-17")));
        books.add(new Book(14,"敏捷开发",50d,"其它",LocalDate.parse("2010-05-17")));
        books.add(new Book(15,"算法导论",20d,"其它",LocalDate.parse("1999-05-17")));
        books.add(new Book(16,"算法导论",90d,"其它",LocalDate.parse("2017-05-17")));
        return books;
    }
    @Test
    public void  t1(){
        BOOK_LIST.stream().forEach(x-> System.out.println(x.getName()));
    }
    //ip地址中的参数转换为map index.do?itemId = 1 & userId = 19202 & token = 1111
    @Test
    public void  t2(){
        String queryStr = "itemId = 1 & userId = 19202 & token = 1111";
        List<String[]> list = Arrays.asList(queryStr.split("&")).stream().map(x -> x.split("=")).collect(Collectors.toList());
        list.forEach(x->{
            System.out.println(Arrays.toString(x));
        });
    }
    @Test
    public void t3(){
        String queryStr = "itemId = 1 & userId = 19202 & token = 1111";
        Map<String, String> map = Arrays.asList(queryStr.split("&")).stream().map(x -> x.split("=")).collect(Collectors.toMap(x -> x[0], x -> x[1]));
        System.out.println(map);
    }
    //非常常见
    @Test
    public void t4(){
        //把所有书的id取出来放到list中
        List<Integer> list = BOOK_LIST.stream().map(x -> x.getId()).collect(Collectors.toList());
        System.out.println(list);//[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]

        //转换成(1,2,3,4,5)这种形式  这种形式必须转为string
        String s = BOOK_LIST.stream().map(x -> x.getId() + "").collect(Collectors.joining(",", "(", ")"));
        System.out.println(s);
    }
    @Test
    public void t5(){
        //类型全部取出来并且去重 distinct或者set
        List<String> list = BOOK_LIST.stream().map(x -> x.getType()).distinct().collect(Collectors.toList());
        System.out.println(list);
    }
    @Test
    public void t6(){
        //价格由高到低排序
        List<Book> list = BOOK_LIST.stream().sorted((a, b) -> (int) (b.getPrice() - a.getPrice())).collect(Collectors.toList());
        list.forEach(x-> System.out.println(x.getPrice()));
        System.out.println("=========================");
        /**   LocalDate a = LocalDate.of(2012, 6, 30);源码这样解释的
         *   LocalDate b = LocalDate.of(2012, 7, 1);
         *   a.isAfter(b) == false
         *   a.isAfter(a) == false
         *   b.isAfter(a) == true*/
        //价格相同的由时间由近到远排
//      Compares its two arguments for order. Returns a negative integer, zero, or
//      a positive integer as the first argument is less than, equal to, or greater
//      than the second.   compare(a,b)方法  也就是说如果是-1就表示前面的比较小，他要排到前面
        Comparator<Book> comparator = (a,b)->(int)(b.getPrice()-a.getPrice());
        /*
        可以这样来看：a.date在b.date后面的时候返回-1，说明此时a排在了b前面，再回来看
        a.date此时是after  b.date的，说明时间近的a排在了时间远的b前面  符合
         */
        List<Book> list1 = BOOK_LIST.stream().sorted(comparator.thenComparing((a, b) -> a.getDate().isAfter(b.getDate()) ? -1 : 1)).collect(Collectors.toList());
        list1.forEach(x->{
            System.out.println(x.getPrice()+":"+x.getDate());
        });

        System.out.println("=================================");
        //使用Comparator(comparing要求传入的是Function，代表被排序的类型和按照上面排序，但是它判断不出来传入的类型)
        List<Book> list2 = BOOK_LIST.stream().sorted(Comparator.comparing((Book b) -> b.getPrice()).reversed().thenComparing((Book b) -> b.getDate())).collect(Collectors.toList());
        list1.forEach(x->{
            System.out.println(x.getPrice()+":"+x.getDate());
        });

    }
    @Test
    public void t7(){
        //转为map,key为数的id
        Map<Integer, Double> map = BOOK_LIST.stream().collect(Collectors.toMap(x -> x.getId(), x -> x.getPrice()));
        System.out.println(map);
    }
    @Test
    public void t8(){
        //求平均价格
        OptionalDouble average = BOOK_LIST.stream().map(x -> x.getPrice()).mapToDouble(x -> x).average();
        if(average.isPresent()) System.out.println(average.orElseGet(()->0.0));

        Double price = BOOK_LIST.stream().collect(Collectors.averagingDouble(x -> x.getPrice()));
        System.out.println(price);
    }
    @Test
    public void t9(){
        //找最大最小
        Optional<Book> book = BOOK_LIST.stream().collect(Collectors.maxBy(Comparator.comparing((Book x) -> x.getPrice())));
        Optional<Book> book1 = BOOK_LIST.stream().collect(Collectors.minBy(Comparator.comparing((Book x) -> x.getPrice())));
        System.out.println(book.get().getPrice()+":"+book1.get().getPrice());

        //时间最早的
        Optional<Book> book2 = BOOK_LIST.stream().collect(Collectors.maxBy(Comparator.comparing((Book x) -> x.getDate())));
        System.out.println(book2.get().getDate());

        //最贵的，时间是最早的
        Comparator<Book> comparator1 = Comparator.comparing((Book x)->x.getPrice());
        Comparator<Book> comparator2 = Comparator.comparing((Book x) -> x.getDate()).reversed();
        Optional<Book> book3 = BOOK_LIST.stream().collect(Collectors.maxBy(comparator1.thenComparing(comparator2)));
        System.out.println(book3.get().getDate()+":"+book3.get().getPrice());

    }
    @Test//分组
    public void t10(){
        //按照类别分组  对象方法的引用在这里使用到了
        Map<String, List<Book>> map = BOOK_LIST.stream().collect(Collectors.groupingBy(Book::getType));
        map.entrySet().forEach(x->{
            System.out.println(x.getKey()+":"+x.getValue());
        });
        //分组后计算数量   第二个参数也是传入一个Collectors
        Map<String, Long> map1 = BOOK_LIST.stream().collect(Collectors.groupingBy(x -> x.getType(), Collectors.counting()));
        map1.entrySet().forEach(x->{
            System.out.println(x.getKey()+":"+x.getValue());
        });

        //分组后计算价格  对象方法引用看来还是有用的
        Map<String, Double> map2 = BOOK_LIST.stream().collect(Collectors.groupingBy(Book::getType, Collectors.summingDouble(Book::getPrice)));
        map2.entrySet().forEach(x->{
            System.out.println(x.getKey()+":"+x.getValue());
        });

        //分组和计算平均
        Map<String, Double> map3 = BOOK_LIST.stream().collect(Collectors.groupingBy(Book::getType, Collectors.averagingDouble(Book::getPrice)));
        map2.entrySet().forEach(x->{
            System.out.println(x.getKey()+":"+x.getValue());
        });

        //分组后最贵的那本
        Map<String, Optional<Book>> map4 = BOOK_LIST.stream().collect(Collectors.groupingBy(Book::getType, Collectors.maxBy(Comparator.comparing((Book x) -> x.getPrice()))));
        map4.entrySet().forEach(x->{
            System.out.println(x.getKey()+":"+x.getValue().get());
        });

        //分组后最晚出售的
        Map<String, Optional<Book>> map5 = BOOK_LIST.stream().collect(Collectors.groupingBy(Book::getType, Collectors.maxBy(Comparator.comparing((Book x) -> x.getDate()))));
        map5.entrySet().forEach(x->{
            System.out.println(x.getKey()+":"+x.getValue().get());
        });

    }
    @Test//价格大于80，日期由近到远
    public void t11(){
        List<Book> list = BOOK_LIST.stream().filter(x -> x.getPrice() >= 80).sorted(Comparator.comparing((Book x) -> x.getDate()).reversed()).collect(Collectors.toList());
        list.forEach(System.out::println);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208