Lambda省略格式&Lambda使用前提与File类的概述

Lambda省略格式

可推导即可省略

Lambda强调的是“做什么"而不是“怎么做”，所以凡是可以根据上下文推导得知的信息，都可以省略。例如上例还可以使用Lambda的省略写法∶

public static void main(String[ ] args) {
invokeCalc(120，130，(a, b) ->a + b);

 

省略规则
在Lambda标准格式的基础上，使用省略写法的规则为∶

1.小括号内参数的类型可以省略;
2.如果小括号内有且仅有一个参，则小括号可以省略;
3.如果大括号内有且仅有一个语句，则无论是否有返回值，都可以省略大括号、return关键字及语句分号。备注:掌握这些省略规则后，请对应地回顾本章开头的多线程案例。

Lambda表达式省略格式
Lambda表达式：是可推导，可以省略

凡是根据上下文推导出来的内容，都可以省略书写

可以省略的内容
1.(参数列表）：括号中参数列表的数据类型吗，可以省略不写
2.（参数列表）：括号中的参数如果只有一个，那么类型和（）都可以省略
3.{一些代码}:如果{}中的代码只有一行，无论是否有返回值，都可以省略{}，return,分号;）
注意：要省略{},return,分号;必须一起省略

package com.Lambda;

import com.sun.org.apache.bcel.internal.generic.ARRAYLENGTH;

import java.util.ArrayList;

/*
      Lambda表达式：是可推导，可以省略
      凡是根据上下文推导出来的内容，都可以省略书写
      可以省略的内容
           1.(参数列表）：括号中参数列表的数据类型吗，可以省略不写
           2.（参数列表）：括号中的参数如果只有一个，那么类型和（）都可以省略
           3.{一些代码}:如果{}中的代码只有一行，无论是否有返回值，都可以省略{}，return,分号;）
                注意：要省略{},return,分号;必须一起省略
 */
public class Demo06ArrayList {
    public static void main(String[] args) {
        //在JDK1.7之前，创建集合对象必须把前后的泛型都写上
        ArrayList<String> list01 = new ArrayList<String>();

        //在JDK1.7版本之后，=号后边的泛型可以省略，后边的泛型可以根据前边的泛型推导出来
        ArrayList<String> list02 = new ArrayList<>();
    }
}

 

package com.Lambda;
public class Demo02Lambda {
    public static void main(String[] args) {
       //使用匿名内部类的方式实现多线程
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "新线程创建了");
            }
        }).start();
       //使用Lambda表达式，实现多线程
        new Thread(() ->{
                System.out.println(Thread.currentThread().getName() + "新线程创建了");
            }
            ).start();
        //优化省略Lambda
        new Thread(() -> System.out.println(Thread.currentThread().getName() + "新线程创建了")).start();
    }
}

package com.Lambda;

public class Demo03Cook {
    public static void main(String[] args) {
       //调用invokeCoke方法,参数是Cook接口，传递Cook接口的匿名内部类对象
        invokeCoke(new Cook() {
            @Override
            public void makeFood() {
                System.out.println("吃饭啦");
            }
        });

        //使用Lambda表达式，简化匿名内部类的书写
        invokeCoke(()->{
            System.out.println("吃饭啦");
        });

        //优化省略Lambda
        invokeCoke(()-> System.out.println("吃饭啦"));
    }
    //定义一个方法，参数传递Cook接口，方法内部调用Cook接口中的方法makeFood
    public static void invokeCoke(Cook cook){
      cook.makeFood();
    }
}

package com.Lambda;

import java.util.Arrays;
import java.util.Comparator;

public class Demo04Arrays {
    public static void main(String[] args) {
        //使用数组存储多个Person对象
        Person[] arr = {
                new Person("柳岩",39),
                new Person("杨幂",29),
                new Person("迪丽热巴",26)
        };
         //对数组中的Person对象使用Arrays对象使用Arrays的sort方法通过年龄进行升序（前边-后边）排序
//        Arrays.sort(arr, new Comparator<Person>() {
//            @Override
//            public int compare(Person o1, Person o2) {
//                return o1.getAge()-o2.getAge();
//            }
//        });

        //使用Lambda表达式，简化匿名内部类
        Arrays.sort(arr,(Person o1,Person o2) ->{return o1.getAge()-o2.getAge(); } );

        //优化省略Lambda
        Arrays.sort(arr,(o1, o2) ->o1.getAge()-o2.getAge());

        //遍历数组
        for (Person p : arr) {
            System.out.println(p);
        }
    }
}

package com.Lambda;

public class Demo05Calculator {
    public static void main(String[] args) {
    //调用invokeCalc方法，方法的参数是一个接口，可以使用匿名内部类
      invokeCalc(120, 130, new Calculator() {
        @Override
        public int calc(int a, int b) {
          return a+b;
        }
      });

    //使用Lambda表达式简化匿名内部类的书写
    invokeCalc(120,130,(int a,int b)->{return a+b;});

    //优化省略Lambda
        invokeCalc(120,130,(a,b)-> a+b);
    }

    /*
        定义一个方法
        参数传递两个int类型的整数
        参数传递Calculator接口
        方法调用Calculator中的方法calc计算两个整数的和
     */
    public static void invokeCalc(int a,int b,Calculator c){
      int sum = a + b;
      System.out.println(sum);
    }
}

Lambda使用前提
Lambda表达式使用前提

1.使用Lambda必须具有接口，且要求接口中有且仅有一个抽象方法
无论是JDK内置的Runnable、Comparator接口还是自定义的接口，只有当接口中的抽象方法存在且唯一时，才可以使用Lambda
2.使用Lambda必须具有上下文推断
也就是方法的参数或局部变量类型必须为Lambda对应的接口类型，才能使用Lambda作为该接口的实例。
备注：有且仅有一个抽象方法的接口.称为"函数式编程"

File类的概述

它是文件和目录路径名的抽象表示，文件和目录是可以通过File封装成对象的。对于File而言，其封装的并不是一个真正的文件，仅仅是一个路径名，他可以是存在的，也可以是不存在的，将来要通过具体的操作把这个路径的内容转化成具体存在的。

构造方法：

public File(String pathname)
通过将给定的路径名字符串转换为抽象路径名来创建新的File实例。 如果给定的字符串是空字符串，则结果是空的抽象路径名。
public File(String parent,String child)
从父路径名字符串和子路径名字符串创建新的File实例。
public File(File parent,String child)
从父抽象路径名和子路径名字符串创建新的File实例。

package Demo_Proer;
/*
java.io.FiLe类
文件和目录路径名的抽象表示形式。
java把电脑中的文件和文件夹(目录)封装为了一个File类,我们可以使用FiLe类对文件和文件夹进行操作我们可以使用File类的方法
创建一个文件/文件夹删除文件/文件夹
获取文件/文件夹
判断文件/文件夹是否存在对文件夹进行遍历
获取文件的大小
FiLe类是一个与系统无关的类,任何的操作系统都可以使用这个类中的方法
重点:记住这三个单词
fiLe:文件
directory:文件夹/目录path :路径
 */
public class Demo01File {
}

 

 

 

/*
java.io.FiLe类
文件和目录路径名的抽象表示形式。
java把电脑中的文件和文件夹(目录)封装为了一个File类,我们可以使用FiLe类对文件和文件夹进行操作我们可以使用File类的方法
创建一个文件/文件夹删除文件/文件夹
获取文件/文件夹
判断文件/文件夹是否存在对文件夹进行遍历
获取文件的大小
FiLe类是一个与系统无关的类,任何的操作系统都可以使用这个类中的方法
重点:记住这三个单词
fiLe:文件
directory:文件夹/目录path :路径
 */