- 1Java+MySQL基于Springboot+vue的化妆品美妆销售商城网站#毕业设计_美妆销售平台设计
- 2WSL ubuntu xfce4桌面远程连接_wsl ubuntu xrdp
- 3plt.imshow()的用法和参数介绍
- 4BufferedInputStream、BufferedOutputStream关于write(),read()方法的使用_java中bufferedoutputstream的write()方法
- 5Redis篇----第一篇
- 6什么是基于存内计算的计算硬件
- 7Windows下‘gbk‘ codec can‘t decode byte 0xae问题出现的原因及解决方法_gbk' codec can't decode byte 0xae in position 8: i
- 8【Spring连载】使用Spring Data访问 MongoDB----对象映射之基于类型的转换器
- 9如何快速构建自己的AI客服 将GPT接入淘宝，抖店，拼多多，美团等电商平台 实现当前最强的客服机器人_轻简客服
- 10GPT与文心一言大模型的比较与展望_文心一言 参数数量
Java基础之java8 新特性
赞
踩
Java基础之java8 新特性
一、Lambda 表达式
Lambda 表达式是在 Java8 中引入的，并号称是 Java8 的最大的特点。Lambda 表达式有利于函数式编程，简化了开发了很多。
语法：parameter -> expression body
操作符 “->” 称为箭头操作符或 Lambda 操作符
箭头操作符将 Lambda 表达式拆分成两部分：
左侧：Lambda 表达式的参数列表
右侧：Lambda 表达式中所需执行的功能， 即 Lambda 体
案例：集合排序
public class Demo { public static void main(String[] args) { List<Entity> list = new ArrayList<>(); list.add(new Entity("张一", 18)); list.add(new Entity("张二", 25)); list.add(new Entity("张三", 14)); list.add(new Entity("张四", 19)); list.add(new Entity("张五", 23)); list.sort(new Comparator<Entity>() { @Override public int compare(Entity o1, Entity o2) { return o1.age > o2.age ? 1 : o1.age < o2.age ? -1 : 0; } }); System.out.println(list); } } class Entity { String name; Integer age; public Entity(String name, Integer age) { this.age = age; this.name = name; } }
- 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
转化后的排序变成一行代码：两个参数一条语句（大括号和 return 可以不写），Lambda 表达式的参数列表的数据类型可以省略不写，因为 JVM 编译器通过上下文推断出，数据类型，即“类型推断”。
list.sort((o1, o2) -> o1.age > o2.age ? 1 : o1.age < o2.age ? -1 : 0);
- 1
idea 一般都会自动提示普通写法和 lambda 相互转化，（alt + 回车）一般按照提示转化即可。
案例：Runnable ：lambda 表达式一般可以操作加 @FunctionalInterface 注解的接口（函数式接口）
Runnable r = new Runnable() {
@Override
public void run() {
System.out.println("Hello lambda!");
}
};
r.run();
//变成
Runnable r1 = () -> System.out.println("Hello Lambda!");
r1.run();
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
案例：forEach 遍历 list
List<Entity> list = new ArrayList<>();
list.add(new Entity("张一", 18));
list.add(new Entity("张二", 25));
list.add(new Entity("张三", 14));
list.add(new Entity("张四", 19));
list.add(new Entity("张五", 23));
list.forEach(new Consumer<Entity>() {
@Override
public void accept(Entity entity) {
System.out.println(entity);
}
});
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
转化为 Lambda 后，当方法的参数只有一个时前面的括号可以省略。
list.forEach(entity -> System.out.println(entity));
- 1
案例：forEach 遍历 map
Map<String, Object> map = new HashMap<>();
map.put("id", 1);
map.put("name", "张三");
map.put("password", "123456");
map.forEach((k, v) -> {
System.out.println(k);
System.out.println(v);
});
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
二、Stream 初体验
Java 8 API 添加了一个新的抽象称为流 Stream，可以让你以一种声明的方式处理数据。 Stream 使用一种类似用 SQL 语句从数据库查询数据的直观方式来提供一种对 Java 集合运算和表达的高阶抽象。 Stream API 可以极大提高 Java 程序员的生产力，让程序员写出高效率、干净、简洁的代码。 这种风格将要处理的元素集合看作一种流， 流在管道中传输， 并且可以在管道的节点上进行处理， 比如筛选， 排序，聚合等。
元素流在管道中经过中间操作（intermediate operation）的处理，最后由最终操作（terminal operation）得到前面处理的结果。
流程：
stream of elements -> filter -> sorted -> map -> collect
- 1
map
map 方法用于映射每个元素到对应的结果。
案例：使用 map 输出了元素对应的平方数：
List<Integer> numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5);
// 获取对应的平方数
List<Integer> squaresList = numbers.stream().map( i -> i*i).collect(Collectors.toList());
- 1
- 2
- 3
filter
filter 方法用于通过设置的条件过滤出元素。
案例：使用 filter 方法过滤出空字符串：
List<String>strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");
// 获取空字符串的数量
long count = strings.stream().filter(string -> string.isEmpty()).count();
- 1
- 2
- 3
limit
limit 方法用于获取指定数量的流。
案例：使用 limit 方法获取前 3 条不为空的数组数据：
List<String>strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");
List<String> collect = strings.stream().filter(string -> string != "").limit(3).collect(Collectors.toList());
- 1
- 2
sorted
sorted 方法用于对流进行排序。
案例：使用 sorted 方法对集合数据进行排序：
List<String>strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");
List<String> collect = strings.stream().filter(string -> string != "").sorted().collect(Collectors.toList());
- 1
- 2
distinct
distinct 方法用于对流进行去重。
案例：
List<String>strings = Arrays.asList("bc", "", "bc", "efg", "abcd","", "jkl");
List<String> collect = strings.stream().filter(string -> string != "").distinct().collect(Collectors.toList());
- 1
- 2
count
count 方法用于对流进行计数。
List<String>strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");
long count = strings.stream().filter(string -> string.isEmpty()).count();
- 1
- 2
扩展案例：
Random random = new Random(); //生成 10 个[0,100] 的随机数 List<Integer> collect = random.ints(0, 101).boxed().limit(10).collect(Collectors.toList()); System.out.println(collect); //生成一个从0开始到10的集合 List<Integer> list = IntStream.range(1, 11).boxed().collect(Collectors.toList()); System.out.println(list); //计算上面集合的平均值 Double avarage = list.stream().collect(Collectors.averagingInt(item -> item)); System.out.println(avarage); //对列表元素进行统计 IntSummaryStatistics iss = list.stream().collect(Collectors.summarizingInt(value -> value)); System.out.println(iss); //{count=10, sum=55, min=1, average=5.500000, max=10} //根据 List 创建 Map Map<Integer, Integer> map = list.stream().collect(Collectors.toMap(p -> p, q->q*3)); System.out.println(map); //获取列表的最大值 Optional<Integer> max = list.stream().reduce(Math::max); max.ifPresent(value -> System.out.println(value));
- 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
注意：
1.boxed 用于将 IntStream 转化成 Stream。
2.Math::max 称为方法引用。
三、方法引用
在 Java8 中，你可以使用 class::methodName 语法引用类或对象的方法。让我们来学习一下 Java 8 中不同类型的方法引用。Java 8 中包含了四种类型的方法引用。
方法引用 描述 例子
静态方法引用 用于引用类的静态方法 Math::max 相当于 Math.max(x,y)
从对象中引用实例方法 使用对象的引用来调用实例方法 System.out::println 相当于 System.out.println(x)
从类中引用实例方法 在上下文提供的对象的引用上调用实例方法 String::length 相当于 str.length()
引用构造函数 引用构造函数 ArrayList::new```相当于new ArrayList()`
- 1
- 2
- 3
- 4
- 5
引用静态方法 - Class::staticMethodName
一个使用 Math.max() 静态方法的例子。
List<Integer> integers = Arrays.asList(1,12,433,5);
Optional<Integer> max = integers.stream().reduce( Math::max );
max.ifPresent(value -> System.out.println(value));
//433
- 1
- 2
- 3
- 4
- 5
从对象中引用实例方法 - ClassInstance::instanceMethodName
在上面的例子中，我们使用了 System.out.println(value) 打印集合中的最大值，我们可以使用 System.out::println 打印这个值。
List<Integer> integers = Arrays.asList(1,12,433,5);
Optional<Integer> max = integers.stream().reduce( Math::max );
max.ifPresent( System.out::println );
//433
- 1
- 2
- 3
- 4
- 5
引用特定类型的实例方法 - Class::instanceMethodName
在这个例子中 s1.compareTo(s2) 被简写为 String::compareTo。
List<String> strings = Arrays
.asList("how", "to", "do", "in", "java", "dot", "com");
List<String> sortedAlt = strings
.stream()
.sorted(String::compareTo)
.collect(Collectors.toList());
System.out.println(sortedAlt);
- 1
- 2
- 3
- 4
- 5
- 6
- 7
引用构造函数 - Class::new
使用 lambda 表达式修改第一个例子中的方法，可以非常简单的创建一个从1到100的集合(不包含100)。创建一个新的 ArrayList 实例，我们可以使用 ArrayList::new。
List<Integer> integers = IntStream
.range(1, 100)
.boxed()
.collect(Collectors.toCollection( ArrayList::new ));
Optional<Integer> max = integers.stream().reduce(Math::max);
max.ifPresent(System.out::println);
//99
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
案例：
public class User { private String username; private Integer age; public User() { } public User(String username, Integer age) { this.username = username; this.age = age; } @Override public String toString() { return "User{" + "username='" + username + '\'' + ", age=" + age + '}'; } // Getter&Setter } public static void main(String[] args) { // 使用双冒号::来构造静态函数引用 Function<String, Integer> fun = Integer::parseInt; Integer value = fun.apply("123"); System.out.println(value); // 使用双冒号::来构造非静态函数引用 String content = "Hello JDK8"; Function<Integer, String> func = content::substring; String result = func.apply(1); System.out.println(result); // 构造函数引用 BiFunction<String, Integer, User> biFunction = User::new; User user = biFunction.apply("mengday", 28); System.out.println(user.toString()); // 函数引用也是一种函数式接口，所以也可以将函数引用作为方法的参数 sayHello(String::toUpperCase, "hello"); } // 方法有两个参数，一个是 private static void sayHello(Function<String, String> func, String parameter){ String result = func.apply(parameter); System.out.println(result); }
- 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
四、默认方法
Java 8 新增了接口的默认方法。简单说，默认方法就是接口可以有实现方法，而且不需要实现类去实现其方法。
我们只需在方法名前面加个 default [dɪˈfɔːlt]关键字即可实现默认方法。为什么要有这个特性？
首先，之前的接口是个双刃剑，好处是面向抽象而不是面向具体编程，缺陷是，当需要修改接口时候，需要修改全部实现该接口的类，目前的 java 8 之前的集合框架没有 foreach 方法，通常能想到的解决办法是在 JDK 里给相关的接口添加新的方法及实现。然而，对于已经发布的版本，是没法在给接口添加新方法的同时不影响已有的实现。所以引进的默认方法。他们的目的是为了解决接口的修改与现有的实现不兼容的问题。
案例：
public interface Moveable {
default void move(){
System.out.println("I am moving");
}
}
- 1
- 2
- 3
- 4
- 5
Moveable 接口定义了一个 move() 方法并且提供了默认的实现。如果任意一个 class 实现这个接口都没有必要去实现这个 move() 方法，能够直接使用 instance.move() 进行调用。
案例：
public class Animal implements Moveable{
public static void main(String[] args){
Animal tiger = new Animal();
tiger.move();
}
}
// I am moving
- 1
- 2
- 3
- 4
- 5
- 6
- 7
如果该 class 想要自定义一个 move() 也能提供自定义的实现去覆写这个 move 方法。
五、Optional 类
是一个可以为 null 的容器对象。如果值存在则 isPresent() [ˈpreznt , prɪˈzent] 方法会返回 true，调用 get() 方法会返回该对象。
Optional 是个容器：它可以保存类型 T 的值，或者仅仅保存 null。Optional 提供很多有用的方法，这样我们就不用显式进行空值检测。
Optional 类的引入很好的解决空指针异常。
案例：
import java.util.Optional; public class OptionalTester { public static void main(String args[]) { Integer value1 = null; Integer value2 = new Integer(10); // Optional.ofNullable - 允许传递为 null 参数 Optional<Integer> a = Optional.ofNullable(value1); // Optional.of - 如果传递的参数是 null，抛出异常 NullPointerException Optional<Integer> b = Optional.of(value2); System.out.println(sum(a, b)); } public static Integer sum(Optional<Integer> a, Optional<Integer> b) { // Optional.isPresent - 判断值是否存在 System.out.println("第一个参数值存在: " + a.isPresent()); System.out.println("第二个参数值存在: " + b.isPresent()); // Optional.orElse - 如果值存在，返回它，否则返回默认值 3 Integer value1 = a.orElse(new Integer(3)); //Optional.get - 获取值，值需要存在 Integer value2 = b.get(); return value1 + value2; } }
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
使用示例：求和时如遇空数字则使用默认值 0 参与运算。
import java.util.Optional; public class OptionalTester { public static void main(String args[]) { Integer value1 = null; Integer value2 = new Integer(10); //同样都是求和，如果数据为空则使用默认值 0 参与计算 System.out.println(sum(value1, value2)); System.out.println(sum(Optional.ofNullable(value1), Optional.ofNullable(value2))); } public static Integer sum(Optional<Integer> a, Optional<Integer> b) { return a.orElse(0) + b.orElse(0); } public static Integer sum(Integer a, Integer b) { if (a == null && b == null) return 0; if (a == null) return 0 + b; if (b == null) return a + 0; return a + b; } }
- 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
六、Base 64
Base64 是一种用 64 个字符来表示任意二进制数据的方法，有些人也叫 Base64 加密。
用记事本打开 exe、jpg、pdf 这些文件时，我们都会看到一大堆乱码，因为二进制文件包含很多无法显示和打印的字符，所以，如果要让记事本这样的文本处理软件能处理二进制数据，就需要一个二进制到字符串的转换方法。Base64 是一种最常见的二进制解编码方法。
Base64 的原理很简单，首先，准备一个包含 64 个字符的数组：
['A', 'B', 'C', ... 'a', 'b', 'c', ... '0', '1', ... '+', '/']
- 1
然后，对二进制数据进行处理，每 3 个字节一组，一共是 3x8=24bit，划为 4 组，每组正好 6 个 bit：
这样我们得到 4 个数字作为索引，然后查表，获得相应的 4 个字符，就是编码后的字符串。
所以，Base64 编码会把 3 字节的二进制数据编码为 4 字节的文本数据，长度增加 33%，好处是编码后的文本数据可以在邮件正文、网页等直接显示。 如果要编码的二进制数据不是 3 的倍数，最后会剩下 1 个或 2 个字节怎么办？Base64 用 \x00 字节在末尾补足后，再在编码的末尾加上 1 个或 2 个 = 号，表示补了多少字节，解码的时候，会自动去掉。
java8 在 Base64 加解码上已经提供一套标准的工具
String base64encodedString = Base64.getEncoder().encodeToString(byte数组);
byte[] base64decodedBytes = Base64.getDecoder().decode(base64字符串);
字符串获取 byte 数组时 .getBytes(“utf-8”); 解决中文乱码问题。
案例：
String string = Base64.getEncoder().encodeToString("hello word,你好，世界".getBytes());
System.out.println(string);
byte[] bytes = Base64.getDecoder().decode(string);
System.out.println(new String(bytes));
- 1
- 2
- 3
- 4
案例：
import java.io.FileInputStream; import java.io.IOException; import java.util.Arrays; import java.util.Base64; public class Hello { public static void main(String[] args) throws IOException { FileInputStream inputStream = new FileInputStream("c:/下载.png"); byte[] bytes = new byte[10240000]; int read = inputStream.read(bytes); if (read < 10240000){ String base64encodedString = Base64.getEncoder().encodeToString(Arrays.copyOfRange(bytes,0,read)); System.out.println(base64encodedString); } } }
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
七、字符串拼接
从 Java7 到目前为止，我们可以通过向 String.split() 方法中传递参数的方式来分割一个字符串，然后把分割后的字符串列表以数组的形式返回。
但是，如果需要连接字符串或者通过分隔符连接的字符串来创建一个 CSV 文件，则必须遍历字符串列表或数组， 然后使用 StringBuilder 或 StringBuffer 对象拼接这些字符串，最后得到 CSV。
在 Java8 中使得字符串拼接任务变得容易。现在你可以使用 String.join() 方法， 其中第一个参数是分隔符，然后可以传递多个字符串或实现了 Iterable 接口的实例作为第二个参数，下面的示例将返回。
import java.time.ZoneId;
public class StringJoinDemo {
public static void main(String[] args){
String joined = String.join("/","usr","local","bin");
System.out.println(joined);
String ids = String.join(", ", ZoneId.getAvailableZoneIds());
System.out.println(ids);
}
}
//usr/local/bin
//Asia/Aden, America/Cuiaba, Etc/GMT+9, Etc/GMT+8.....
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
八、== equals 与 instanceof
== 判断内存地址是否相同（如果是简单类型则比较他们的值是否相等）
equals 调用对象的 equals 方法判断两个对象是否相等，如果对象的类没有重写 equals 方法，则使用 object 的 equals 方法，object 的 equals 方法是比较内存地址。
instanceof：关键字用来确定对象所属的类，或父类。
System.out.println(student instanceof Student);//true
九、final
final 中文意思：最后的，最终的。
final 可以修饰变量、方法或者类
- 当不希望父类的某个方法被子类覆盖（override）时，可以用 final 关键字修饰。
- 当不希望类的某个变量的值被修改，可以用 final 修饰。如果一个变量是 final，则必须赋初值，否则编译出错。
- 当类不希望被继承时，可以在类前面用 final 修饰。
注意：
final 修饰的变量又叫常量，一般用全大写下划线命名。（ Integer.MAX_VALUE ）
final 修饰的变量在定义时，必须初始化，并且以后不能再赋值。
章节练习：
1.遍历集合：使用 Lambda 表达式遍历如下的集合，代码尽可能精简。
List<Employee> emps = Arrays.asList(new Employee(101, "张三", 18, 9999.99),
new Employee(102, "李四", 59, 6666.66),new Employee(103, "王五", 28, 3333.33),
new Employee(104, "赵六", 18, 7777.77),new Employee(105, "田七", 38, 5555.55));
- 1
- 2
- 3
2.遍历 map：使用 Lambda 表达式遍历如下的 Map，代码尽可能精简。
Map<String, Employee> map = new HashMap<>();
map.put("101", new Employee(101, "张三", 18, 9999.99));
map.put("102", new Employee(102, "李四", 59, 6666.66));
map.put("103", new Employee(103, "王五", 28, 3333.33));
map.put("104", new Employee(104, "赵六", 8, 7777.77));
map.put("105", new Employee(105, "田七", 38, 5555.55));
- 1
- 2
- 3
- 4
- 5
- 6
3.获取集合里面的某属性：使用 Stream 获取第一题里面的全部 id 的集合。
4.字符串的 base64：使用 base64 加密与解密如下字符串：“abcd1234”。
5.文件的 base64：使用 base64 算法获取 C:/Windows/win.ini 的 base64 字符串。
6.乱序集合：创建一个方法 void shuffle(List arr)，使其能在代码最精简，且最省内存的情况下完成数组的乱序。
参考代码：
import org.junit.Test; import java.io.FileInputStream; import java.io.IOException; import java.io.InputStream; import java.util.*; import java.util.stream.Collectors; import java.util.stream.IntStream; public class Demo { /** * 1.遍历集合 */ @Test public void t1() { List<Employee> list = Arrays.asList(new Employee(101, "张三", 18, 9999.99), new Employee(102, "李四", 59, 6666.66), new Employee(103, "王五", 28, 3333.33), new Employee(104, "赵六", 18, 7777.77), new Employee(105, "田七", 38, 5555.55)); list.forEach(System.out::println); } /** * 2.遍历 map */ @Test public void t2() { Map<String, Employee> map = new HashMap<>(); map.put("101", new Employee(101, "张三", 18, 9999.99)); map.put("102", new Employee(102, "李四", 59, 6666.66)); map.put("103", new Employee(103, "王五", 28, 3333.33)); map.put("104", new Employee(104, "赵六", 8, 7777.77)); map.put("105", new Employee(105, "田七", 38, 5555.55)); map.forEach((k, v) -> System.out.println(k + "=" + v)); } /** * 3.获取集合里面的某属性 */ @Test public void t3() { List<Employee> list = Arrays.asList(new Employee(101, "张三", 18, 9999.99), new Employee(102, "李四", 59, 6666.66), new Employee(103, "王五", 28, 3333.33), new Employee(104, "赵六", 18, 7777.77), new Employee(111, "田七", 38, 5555.55)); List<Integer> collect = list.stream().map(Employee::getId).collect(Collectors.toList()); System.out.println(collect); } /** * 4.字符串的 base64 */ @Test public void t4() { String s1 = "abcd1234"; String string = Base64.getEncoder().encodeToString(s1.getBytes()); System.out.println(string); byte[] decode = Base64.getDecoder().decode(string); System.out.println(new String(decode)); } /** * 5.获取文件的 base64 */ @Test public void t5() throws IOException { InputStream stream = new FileInputStream("C:/Windows/win.ini"); byte[] bytes = new byte[1024]; int n = stream.read(bytes); String string = Base64.getEncoder().encodeToString(Arrays.copyOfRange(bytes, 0, n)); System.out.println(string); byte[] decode = Base64.getDecoder().decode(string); System.out.println(new String(decode)); stream.close(); } /** * 6.乱序集合 */ @Test public void t6() { List<Integer> list = IntStream.range(1, 11).boxed().collect(Collectors.toList()); System.out.println(list); shuffle(list); System.out.println(list); } public void shuffle(List<Integer> arr) { for (int i = 0; i < arr.size(); i++) { int index = (int) (Math.random() * arr.size()); int temp = arr.get(i); arr.set(i, arr.get(index)); arr.set(index, temp); } } } class Employee { private Integer id; private String name; private Integer age; private Double sal; public Employee(Integer id, String name, Integer age, Double sal) { this.id = id; this.name = name; this.age = age; this.sal = sal; } @Override public String toString() { return "Employee{" + "id=" + id + ", name='" + name + '\'' + ", age=" + age + ", sal=" + sal + '}'; } }
- 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
