• JAVA实训第二天


    目录

    JDK8新特性

    Java8介绍

    JAVA 8主要新特性 

     Java 8接口增强-默认方法

     接口

     接口的应用

    Lambda表达式介绍

    Lambda表达式的写法

    功能性接口Lambda表达式的应用

    函数接口


    JDK8新特性

    Java8介绍

    Java8 Java 发布以来改动最大的一个版本,其中主要添加了函数式编程、 Stream 、一些日期处理类。函数式编程 中新 加了一些概念: Lambda 表达式 、函数式接口、函数引用、默认方法、 Optional 类等; Stream 中提供了一些流式处理集合的方法,并提供了一些归约、划分等类的方法;日期中添加了 ZoneDateTime DataFormater 等线程安全的方法

    JAVA 8主要新特性 

    Lambda  表达式
    函数 接口
    Stream API
    方法 引用
    Date-Time API
    接口增强

     Java 8接口增强-默认方法

    Java 8 新增了接口的默认方法。
    简单说,默认方法就是接口可以有实现方法,而且不需要实现类去实现其方法。
    我们只需在方法名前面加个 default 关键字即可实现默认方法。

    为什么要有这个特性?

             首先,之前的接口是个双刃剑,好处是面向抽象而不是面向具体编程,缺陷是,当需要修改接口时候,需要修改全部实现该接口的类,目前的 java 8 之前的集合框架没有 foreach 方法,通常能想到的解决办法是在JDK里给相关的接口添加新的方法及实现。然而,对于已经发布的版本,是没法在给接口添加新方法的同时不影响已有的实现。所以引进的默认方法。他们的目的是为了解决接口的修改与现有的实现不兼容的问题。

    由于同一个方法可以从不同接口引入

    自然而然的会有冲突的现象,规则如下:

    1)一个声明在类里面的方法优先

    任何默认方法
    2)优先选取最具体的实现

    静态方法的使用区别于前两者

     接口

     接口的应用

    接口

    1. package shili22;
    2. /**
    3. * 接口特点:
    4. * 行为协议--标准:抽象方法
    5. * 不可以直接使用(不可以直接创建对象)---如何应用呢?
    6. * 实现类。
    7. *
    8. *
    9. * 接口引用:实现类。
    10. * @date : 2022/11/22 9:17
    11. */
    12. @FunctionalInterface
    13. public interface MyInterface {
    14. // 常量和抽象方法(jdk8之前):public 修饰
    15. // 常量 :public static。。。。
    16. public static final int MAX_VALUE = 10;
    17. // 抽象方法:(jdk8之前) public abstract ....
    18. public abstract void method1();
    19. }

    实现类1

    1. package shili22;
    2. /**
    3. *
    4. * @date : 2022/11/22 9:24
    5. */
    6. public class MyInterfaceImpl implements MyInterface {
    7. @Override
    8. public void method1() {
    9. System.out.println("oracle数据库执行操作");
    10. }
    11. }

    实现类2 

    1. package shili22;
    2. /**
    3. *
    4. * @date : 2022/11/22 9:25
    5. */
    6. public class MyInterfaceImpl2 implements MyInterface{
    7. @Override
    8. public void method1() {
    9. System.out.println("mysql功能处理2");
    10. }
    11. }

    实现类3与匿名内部类

    1. package shili22;
    2. /**
    3. * 当前这个类中所实现接口中的功能处理 仅仅在整个项目中只被应用一次 此时定义一个类 不合适---》如何处理呢? 匿名类
    4. * @date : 2022/11/22 9:32
    5. */
    6. //
    7. public class MyInterfaceImpl3 implements MyInterface{
    8. @Override
    9. public void method1() {
    10. System.out.println("查询订单。。。。个人订单----特殊情况下使用---假设整个系统中只被执行一次");
    11. }
    12. }
    13. class Demo01{
    14. public static void main(String[] args) {
    15. // 内部类的调用
    16. MyInterface myInterface2 = new MyInterfaceImpl3();
    17. myInterface2.method1();
    18. // 匿名内部类----》 匿名类 使用一次情况下常用
    19. MyInterface myInterface3 = new MyInterface() {
    20. @Override
    21. public void method1() {
    22. System.out.println("查询订单。。。。个人订单----特殊情况下使用---假设整个系统中只被执行一次");
    23. }
    24. };
    25. myInterface3.method1();
    26. }
    27. }

    测试类

    1. package shili22;
    2. /**
    3. *
    4. * @date : 2022/11/22 9:22
    5. */
    6. public class TestMyInterface {
    7. public static void main(String[] args) {
    8. // 访问接口中成员:
    9. // 常量:MyInterface.常量名,可直接调用静态常量
    10. System.out.println(MyInterface.MAX_VALUE);
    11. // 接口不可以直接进行实例化
    12. //接口特点: 行为协议--标准:抽象方法 不可以直接使用(不可以直接创建对象)---如何应用呢? 实现类。 接口引用:实现类。
    13. // MyInterface myInterface = new MyInterface();(错误示范)
    14. // 接口引用:实现类。
    15. MyInterface myInterface = new MyInterfaceImpl();
    16. myInterface.method1();
    17. }
    18. }

    Lambda表达式介绍

     

     正如你所看到的,使用Lambda表达式不仅让代码变的简单、而且可读、最重要的是代码量也随之减少很多

    代码对比 

    1. package lambda;
    2. /**
    3. *
    4. * @date : 2022/11/22 10:23
    5. */
    6. @FunctionalInterface
    7. //当有两个时,就不是功能型接口,就不能使用Lambda
    8. public interface MyInterface {
    9. public void method1();
    10. // public void method2(int a);
    11. }
    12. class Demo01{
    13. public static void main(String[] args) {
    14. /*MyInterface myInterface = new MyInterface() {
    15. @Override
    16. public void method1() {
    17. System.out.println("method1........");
    18. }
    19. };*/
    20. // lambda:代码简洁 可读性强
    21. MyInterface myInterface = ()-> {System.out.println("执行代码");};
    22. myInterface.method1();
    23. }
    24. }
    1. package lambda;
    2. import java.util.Comparator;
    3. import java.util.TreeSet;
    4. /**
    5. * @date : 2022/11/22 10:29
    6. */
    7. public class Demo02Lambda {
    8. public static void main(String[] args) {
    9. // 是否是所有接口都可以应用lambda表达式呢?
    10. // 观察:一个接口中定义多个抽象方法 再使用lambda表达式 就出现编译型问题---》改为函数式接口\功能性接口
    11. // 使用lambda表达式前提---必须是一个函数式接口\功能性接口
    12. // 函数式接口\功能性接口:只有一个抽象方法的接口才称为功能性接口
    13. // 如何检查是否是功能性接口:可以标注 @FunctionalInterface 编译通过说明是
    14. //
    15. // 改变排序规则:降序
    16. /*TreeSet<Integer> treeSet = new TreeSet<>(new Comparator<Integer>() {
    17. @Override
    18. public int compare(Integer o1, Integer o2) {
    19. return o2.compareTo(o1);
    20. }
    21. });*/
    22. TreeSet<Integer> treeSet = new TreeSet<>((Integer o1, Integer o2)->{return o2.compareTo(o1);});
    23. treeSet.add(30);
    24. treeSet.add(10);
    25. treeSet.add(20);
    26. System.out.println(treeSet);
    27. }
    28. }

    查看源码发现,接口中只有一个抽象方法,接口上多了一个@FunctionalInterface注解这种格式的接口被称为函数式接口,

    函数式接口定义如下:

    函数式接口,即适用于函数式编程场景的接口。而Java中的函数式编程体现就是Lambda,所以函数式接口就是可以适用于Lambda使用的接口。只有确保接口中有且仅有一个抽象方法,但是可以有多个非抽象方法。Java中的Lambda才能顺利地进行推导。

    Lambda表达式的写法

    Lambda表达式格式-([参数类型 ]参数名称) ‐> { 代码语句 }

    需求

    格式

    说明

    有一个形参

    参数名称->{代码语句}

    一个形参可以省略小括号

    没有形参

    ()->{代码语句}

    没有形参括号不能省略

    方法体中只有一行代码

    (参数名称)->代码语句

    方法体中只有一行代码,可以省略大括号,分号和return关键字

    1. package lambda;
    2. @FunctionalInterface
    3. public interface MyInterfaceLambda {
    4. // public void method1();
    5. // public void method2(int a);
    6. // public void method2(int a,String str);
    7. public int method2(int a,String str);
    8. }
    9. class DemoMyInterfaceLambda{
    10. public static void main(String[] args) {
    11. // 1)没有返回值 没有参数
    12. /*MyInterfaceLambda myInterfaceLambda = ()->{
    13. System.out.println("hello");
    14. System.out.println("java");
    15. };
    16. myInterfaceLambda.method1();
    17. System.out.println("===================");
    18. // {}是否可以省略问题 :{}中只有一行代码 {}可以省略
    19. MyInterfaceLambda myInterfaceLambda2 = ()->
    20. System.out.println("hello");
    21. ;
    22. myInterfaceLambda2.method1();*/
    23. // 2)没有返回值 有参数--1个参数
    24. // A:lambda--形参名字--自定义
    25. // B:形参 类型可以省略
    26. // C:()可以省略
    27. /*MyInterfaceLambda myInterfaceLambda3 = (int a)->{
    28. if(a>2){
    29. System.out.println("b>2");
    30. }else{
    31. System.out.println("a<2");
    32. }
    33. };*/
    34. /*MyInterfaceLambda myInterfaceLambda3 = (a)->{
    35. if(a>2){
    36. System.out.println("a>2");
    37. }else{
    38. System.out.println("a<2");
    39. }
    40. };*/
    41. /*MyInterfaceLambda myInterfaceLambda3 = a->{
    42. if(a>2){
    43. System.out.println("a>2");
    44. }else{
    45. System.out.println("a<2");
    46. }
    47. };
    48. myInterfaceLambda3.method2(1);*/
    49. // 3)没有返回值 有参数--多个参数 ()不可以省略
    50. /* MyInterfaceLambda myInterfaceLambda4=(int a,String str)->{
    51. System.out.println(a+"=========="+str);
    52. };*/
    53. /* MyInterfaceLambda myInterfaceLambda4=(a,str)->
    54. System.out.println(a+"=========="+str);
    55. ;
    56. myInterfaceLambda4.method2(66,"hello");*/
    57. // 4)有返回值抽象方法 return 关键字
    58. /* MyInterfaceLambda myInterfaceLambda5 = (a,str)->{
    59. String result = a+"==="+str;
    60. System.out.println(result);
    61. if (a>100){
    62. return a;
    63. }
    64. return 0;
    65. };
    66. myInterfaceLambda5.method2(200,"hello");*/
    67. // 有返回值的方法: 如果{}里面只有一行代码 {}省略同时return也要省略
    68. MyInterfaceLambda myInterfaceLambda5 = (a,str)-> a;
    69. int result = myInterfaceLambda5.method2(200, "hello");
    70. System.out.println("result:"+result);
    71. }
    72. }

    功能性接口Lambda表达式的应用

    1. package lambda.demo03;
    2. import org.junit.Test;
    3. /**
    4. * @date : 2022/11/22 11:12
    5. */
    6. public class JunitTest {
    7. public void testMyFunction(MyFunction myFunction){
    8. myFunction.test("tidy");
    9. }
    10. @Test
    11. //加上注释变成测试类
    12. public void testMethod(){
    13. /* MyFunction myFunction = name->{
    14. System.out.println("name:"+name);
    15. };
    16. testMyFunction(myFunction);*/
    17. /* testMyFunction(name->{
    18. System.out.println("name:"+name);
    19. });*/
    20. testMyFunction(name->
    21. System.out.println("name:"+name)
    22. );
    23. }
    24. }
    1. package part2;
    2. @FunctionalInterface
    3. public interface MyFunction {
    4. // 抽象方法 a=10,b=20;计算a+b,并返回计算结果
    5. // 方法:
    6. // 3要素:1)是否有返回值 2)方法名 3)方法參數
    7. public int operation(int num1, int num2);
    8. }
    9. class Demo {
    10. public static void main(String[] args) {
    11. //案例一:a=10,b=20;计算a+b,并返回计算结果
    12. // MyFunction myFunction = (num1,num2)->{return num1+num2;};
    13. MyFunction myFunction = (num1, num2) -> num1 + num2;
    14. int result1 = myFunction.operation(10, 20);
    15. System.out.println("result1:" + result1);
    16. // a=10,b=20;计算a*b,并返回计算结果
    17. MyFunction myFunction2 = (num1, num2) -> num1 * num2;
    18. int result2 = myFunction2.operation(10, 20);
    19. System.out.println("result2:" + result2);
    20. System.out.println("======================");
    21. Demo demo = new Demo();
    22. /*MyFunction myfunction3 = (a,b)->a+b;
    23. int sum = demo.sum(50, 60, myfunction3);*/
    24. int sum = demo.sum(50, 60, (a,b)->a*b);
    25. System.out.println("sum:"+sum);
    26. }
    27. public int sum(int a, int b, MyFunction myfunction) {
    28. return myfunction.operation(a, b);
    29. }
    30. }

     

    函数接口

     四个接口示例

    1. package part2;
    2. import java.util.function.Consumer;
    3. import java.util.function.Function;
    4. import java.util.function.Predicate;
    5. import java.util.function.Supplier;
    6. /**
    7. * @date : 2022/11/22 15:35
    8. */
    9. public class FunctionDemo02 {
    10. public static void main(String[] args) {
    11. // 1)消费型接口---传入参数
    12. Consumer consumer = t->{
    13. if(t.equals("hello")){
    14. System.out.println("OK");
    15. }else{
    16. System.out.println("NG");
    17. }
    18. };
    19. consumer.accept("hello");
    20. // 2)Supplier供给型接口--返回值
    21. System.out.println("==Supplier供给型接口--返回值:=================");
    22. Supplier<Integer> supplier = ()->new Integer(12);
    23. Integer num = supplier.get();
    24. System.out.println(num);
    25. // 3Function<T , R>Function接口
    26. System.out.println("=Function: Function接口:=================");
    27. // 判断用户名是否正确: tidy success 否则 fail
    28. String inputName = "tidy";
    29. Function<String,String> function = str->{
    30. if ("tidy".equals(str)){
    31. return "Success";
    32. }else{
    33. return "fail";
    34. }
    35. };
    36. String result = function.apply(inputName);
    37. System.out.println("result:"+result);
    38. // 4)Predicate<T>:断言型接口
    39. Predicate<String> predicate = t->{
    40. return "123456".equals(t)?true:false;
    41. };
    42. boolean flg = predicate.test("123456");
    43. System.out.println("flg:"+flg);
    44. }
    45. }

    作业

    1. 给一个整数集合,分别求集合中偶数和与奇数和

     

    1. package housework;
    2. import java.util.ArrayList;
    3. import java.util.List;
    4. public interface test221 {
    5. public int[] operation(List<Integer> list);
    6. }
    7. class test11221{
    8. public static void main(String[] args) {
    9. List<Integer> list = new ArrayList<>();
    10. list.add(1);
    11. list.add(2);
    12. list.add(3);
    13. list.add(4);
    14. test221 function = (list2)->{
    15. int jishuSum =0;
    16. int oushuSum = 0;
    17. for (int i = 0; i < list2.size(); i++) {
    18. if (list2.get(i)%2==0){
    19. oushuSum=oushuSum+list2.get(i);
    20. }else{
    21. jishuSum = jishuSum+list2.get(i);
    22. }
    23. }
    24. int[] arr = new int[2];
    25. arr[0]=jishuSum;
    26. arr[1]=oushuSum;
    27. return arr;
    28. } ;
    29. int[] arr2 = function.operation(list);
    30. System.out.println("奇数和:"+arr2[0]);
    31. System.out.println("偶数和:"+arr2[1]);
    32. }
    33. }

    2. 给一个整数集合,将集合分成偶数集合和奇数集合

     

    1. package housework;
    2. import java.util.ArrayList;
    3. import java.util.List;
    4. public interface test222 {
    5. public List operation(List<Integer> list);
    6. }
    7. class test11222{
    8. public static void main(String[] args) {
    9. test222 function = (list2)->{
    10. List<Integer> ji = new ArrayList<>();
    11. List<Integer> ou = new ArrayList<>();
    12. for (int i = 0; i < list2.size(); i++) {
    13. if (list2.get(i)%2==0){
    14. ou.add(list2.get(i));
    15. }else{
    16. ji.add(list2.get(i));
    17. }
    18. }
    19. List<List<Integer>> sum = new ArrayList<>();
    20. sum.add(ou);
    21. sum.add(ji);
    22. return sum;
    23. } ;
    24. List<Integer> list = new ArrayList<>();
    25. list.add(1);
    26. list.add(2);
    27. list.add(3);
    28. list.add(4);
    29. function.operation(list);
    30. List list1 = function.operation(list);
    31. System.out.println("奇数和:"+ list1.get(1));
    32. System.out.println("偶数和:"+list1.get(0));
    33. }
    34. }

    3. 集合转换:[[1, 2, 3, 4, 5], [2, 1, 9, 3, 6, 7], [3, 1, 6]] > ["1", "2", "4", "5", "2", …… "3", "1","6"]

    1. package housework;
    2. import java.util.ArrayList;
    3. import java.util.Collections;
    4. import java.util.List;
    5. public interface test223 {
    6. public List<String> operation(List<List<Integer>> list);
    7. }
    8. class test11223{
    9. public static void main(String[] args) {
    10. test223 function = (list2)->{
    11. List<String> ji = new ArrayList<>();
    12. for (int i = 0; i < list2.size(); i++) {
    13. for (int j = 0; j < (list2.get(i)).size(); j++)
    14. ji.add("“"+list2.get(i).get(j).toString()+"”");
    15. }
    16. return ji;
    17. } ;
    18. List<List<Integer>> list = new ArrayList<>();
    19. List<Integer> list1 = new ArrayList<>();
    20. List<Integer> list2 = new ArrayList<>();
    21. List<Integer> list3 = new ArrayList<>();
    22. Collections.addAll(list1,1,2,3,4,5);
    23. Collections.addAll(list2,3,1,6);
    24. Collections.addAll(list3,2,1,9,3,6,7);
    25. list.add(list1);
    26. list.add(list2);
    27. list.add(list3);
    28. // System.out.println(list);
    29. // function.operation(list);
    30. List<String> list4 = function.operation(list);
    31. System.out.println("后:"+ list4);
    32. }
    33. }

  • 相关阅读:
    前端周刊第二十期
    Java开发-WebSocket
    MySQL是如何保证主从一致的
    GET 和 POST 有什么区别?
    【python高级】设计模式、类工厂、对象工厂
    【Spring Security 系列】(四)高层级组件
    安卓系列机型 框架LSP 安装步骤 支持多机型 LSP框架通用安装步骤【二】
    Redis数据库的事物机制(详细讲解)
    【从零开始学微服务】04.微服务架构的特点
    VLAN实现二层流量隔离(mux-vlan)应用基础配置
  • 原文地址:https://blog.csdn.net/qq_63202674/article/details/127982186