Lambda，递归

1.Lamdba表达式

1.Lambda表达式的标准格式

三部分组成:

• 一些参数
• 一个箭头
• 一段代码

格式:

(参数列表) -> {一些重写方法的代码}

解释说明格式:

• ():接口中抽象方法的参数列表,没有参数,就空着;有参数就写出参数,多个参数使用逗号分隔
• ->:传递的意思,把参数传递给方法体{}
• {}:重写接口的抽象方法的方法体

public class DemoLambda{
    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
        //优化省略Lambda
        new Thread(()->System.out.println(Thread.currentThread().getName()+" 新线程创建了")).start();
    }
}

1.案例

1. 需求: 给定一个厨子Cook接口，内含唯一的抽象方法makeFood，且无参数、无返回值。 使用Lambda的标准格式调用invokeCook方法，打印输出“吃饭啦！”字样

   //定义Cook接口
   public interface Cook{
       public abstract void makeFood();
   }
   

   //使用Lambda
   public class Demo{
       public static void main(String[] args){
           //调用invokeCook方法,参数是Cook接口,传递Cook对象
           invokeCook(new Cook(){
               @Override
               public void makeFood(){
                   System.out.println("吃饭了");
               }
           });
           //使用Lambda函数
           invokeCook(()->{
               System.out.println("吃饭了");
           });
           // 优化
           invokeCook(()-> System.out.println("吃饭了"));
       }
       //定义一个方法,参数传递Cook接口,方法内部调用makeFood()方法
       public static void invokeCook(Cook cook){
           cook.makeFood();
       }
   }
   

2. 需求:

   给定一个计算器Calculator接口，内含抽象方法calc可以将两个int数字相加得到和值 使用Lambda的标准格式调用invokeCalc方法，完成120和130的相加计算

   // 接口
   public interface Calculator{
       public abstract calc(int a, int b);
   }
   

   public class Demo{
       public static void main(String[] args){
           // 调用invokeCalc方法,方法的参数是一个接口,使用匿名内部类
           invokeCalc(10,20, new Calculator(){
               @Override
               public int calc(int a, int b){
                   return a+b;
               }
           });
           //使用Lambda表达式简化匿名内部类的书写
           invokeCalc(120, 130,(int a, int b)->{
               return a+b;
           });
           //优化
           invokeCalc(120,130,(a,b)-> a+b);
       }
       /*
           定义一个方法
           参数传递两个int类型的整数
           参数传递Calculator接口
           方法内部调用Calculator中的方法calc计算两个整数的和
        */
       public static void invokeCalc(int a,int b,Calculator c){
           int sum = c.calc(a,b);
           System.out.println(sum);
       }
   }
   

2.Lambda省略规则

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

1. 小括号内参数的类型可以省略；
2. 如果小括号内有且仅有一个参，则小括号可以省略；
3. 如果大括号内有且仅有一个语句，则无论是否有返回值，都可以省略大括号、return关键字及语句分号。

Lambda表达式:是可推导,可以省略 凡是根据上下文推导出来的内容,都可以省略书写 可以省略的内容:

1. (参数列表):括号中参数列表的数据类型,可以省略不写

2. (参数列表):括号中的参数如果只有一个,那么类型和()都可以省略

3. {一些代码}:如果{}中的代码只有一行,无论是否有返回值,都可以省略({},return,分号)注意:要省略{},return,分号必须一起省略

   import java.util.ArrayList;
   public class Demo01ArrayList {
       public static void main(String[] args) {
           //JDK1.7版本之前,创建集合对象必须把前后的泛型都写上
           ArrayList<String> list01 = new ArrayList<String>();
   
           //JDK1.7版本之后,=号后边的泛型可以省略,后边的泛型可以根据前边的泛型推导出来
           ArrayList<String> list02 = new ArrayList<>();
       }
   }
   

3.使用前提

Lambda的语法非常简洁，特别注意：

1. 使用Lambda必须具有接口，且要求接口中有且仅有一个抽象方法。 无论是JDK内置的 Runnable 、 Comparator 接口还是自定义的接口，只有当接口中的抽象方法存在且唯一 时，才可以使用Lambda。

2. 使用Lambda必须具有上下文推断。 也就是方法的参数或局部变量类型必须为Lambda对应的接口类型，才能使用Lambda作为该接口的实例。

   备注：有且仅有一个抽象方法的接口，称为“函数式接口”。

2.File类

1.概述

java.io.File是文件和目录的类,用于文件和目录的创建,查找和删除操作

2.构造方法

• public File(String pathName):通过指定的路径名称字符串转换为抽象路径名来创建新的File实例

• public File(String parent, String child):从父路径名字符串和子路径字符串创建File实例

• public File(File parent, String child):从父抽象路径名和子路径名字符串创建新的File实例

• 构造实例

  //文件路径名
  String pathName = "D:\\aaa.txt";
  File file = new File(pathName);
  
  //文件路径名
  String pathName = "D:\\a";
  String child = "b.txt";
  File file = new File(pathName, child);
  
  //第三种
  File parentDir = new File("d:\\aaaa");
  String child = "b.txt";
  File file = new File(parentDir, child);
  /*
  1. 一个File对象代表硬盘中实际存在的一个文件或者目录。
  2. 无论该路径下是否存在文件或者目录，都不影响File对象的创建。*/
  

3.常用方法

获取功能的方法

• public String getAbsolutePath(): 返回此File的绝对路径字符串名字

• public String getPath():将此File转换为路径名字符串

• public String getName():返回此File表示的文件或目录的名称

• public long length(): 返回此File文件的长度

• 代码如下

  public class FileDemo{
      public static void main(String[] args){
          File f = new File("d:/aaa/bbb.java");
          System.out.println("文件绝对路径:"+f.getAbsolutePath());
          System.out.println("文件构造路径:"+f.getPath());
          System.out.println("文件名称:"+f.getName());
          System.out.println("文件长度:"+f.length()+"字节");
          File f2 = new File("d:/aaa");
          System.out.println("目录绝对路径:"+f2.getAbsolutePath());
          System.out.println("目录构造路径:"+f2.getPath());
          System.out.println("目录名称:"+f2.getName());
          System.out.println("目录长度:"+f2.length());
      }
  }
  // ：length()，表示文件的长度。但是File对象表示目录，则返回值未指定。
  

绝对路径和相对路径

• 绝对路径: 从根目录开始
• 相对路径: 当前目录

public class FilePath {
	public static void main(String[] args) {
		// D盘下的bbb.java文件
        File f = new File("D:\\bbb.java");
        System.out.println(f.getAbsolutePath());
        // 项目下的bbb.java文件
        File f2 = new File("bbb.java");
        System.out.println(f2.getAbsolutePath());
	}
}

判断功能的方法

• public boolean exists():此File表示的文件或目录是否实际存在

• public boolean isDirectory(): 是否是目录

• public boolean isFile():是否为文件

• 代码

  public class FileIs {
  	public static void main(String[] args) {
          File f = new File("d:\\aaa\\bbb.java");
          File f2 = new File("d:\\aaa");
          // 判断是否存在
          System.out.println("d:\\aaa\\bbb.java 是否存在:"+f.exists());
          System.out.println("d:\\aaa 是否存在:"+f2.exists());
          // 判断是文件还是目录
          System.out.println("d:\\aaa 文件?:"+f2.isFile());
          System.out.println("d:\\aaa 目录?:"+f2.isDirectory());
  	}
  }
  

创建删除功能的方法

• public boolean createNewFile():当且仅当具有该名称文件不存在的时候,创建一个新的空文件

• public boolean delete():删除由此File表示的文件或目录

• public boolean mkdir():创建此文件的目录

• public boolean mkdirs():创建此File表示的目录,包括任何必须但不存在的父目录

• 代码

  public class FileCreateDelete {
  	public static void main(String[] args) throws IOException {
          // 文件的创建
          File f = new File("aaa.txt");
          System.out.println("是否存在:"+f.exists()); // false
          System.out.println("是否创建:"+f.createNewFile()); // true
          System.out.println("是否存在:"+f.exists()); // true
          // 目录的创建
          File f2= new File("newDir");
          System.out.println("是否存在:"+f2.exists());// false
          System.out.println("是否创建:"+f2.mkdir()); // true
          System.out.println("是否存在:"+f2.exists());// true
          // 创建多级目录
          File f3= new File("newDira\\newDirb");
          System.out.println(f3.mkdir());// false
          File f4= new File("newDira\\newDirb");
          System.out.println(f4.mkdirs());// true
          // 文件的删除
          System.out.println(f.delete());// true
          // 目录的删除
          System.out.println(f2.delete());// true
          System.out.println(f4.delete());// false
  	}
  }
  // delete方法，如果此File表示目录，则目录必须为空才能删除
  

4.目录的遍历

• public String[] list(): 返回一个String数组, 表示该File目录的所有子文件或目录

• public File[] listFiles():返回一个File数组,表示该File目录中的所有子文件或者目录

  public class FileFor {
  	public static void main(String[] args) {
          File dir = new File("d:\\java_code");
          //获取当前目录下的文件以及文件夹的名称。
          String[] names = dir.list();
          for(String name : names){
          System.out.println(name);
          }
          //获取当前目录下的文件以及文件夹对象，只要拿到了文件对象，那么就可以获取更多信息
          File[] files = dir.listFiles();
          for (File file : files) {
          System.out.println(file);
          }
      }
  }
  //调用listFiles方法的File对象，表示的必须是实际存在的目录，否则返回null，无法进行遍历
  

3.递归

1.什么是递归

• 递归: 当前方法调用自己的这种现象
• 递归的分类:
  • 递归分为两种，直接递归和间接递归。
  • 直接递归称为方法自身调用自己。
  • 间接递归可以A方法调用B方法，B方法调用C方法，C方法调用A方法
• 注意事项:
  • 递归一定要有条件限定，保证递归能够停止下来，否则会发生栈内存溢出。
  • 在递归中虽然有限定条件，但是递归次数不能太多。否则也会发生栈内存溢出。
  • 构造方法,禁止递归

public class DemoDiGgui{
    public static void main(String[] args){
        b(1);
    }
    //3.构造方法,静止递归
    // 编译报错: 构造方法是创建对象的,不能让对象一直创建下去
    public DemoDiGui(){

    }
    // 2.递归的限定条件,发生栈内存溢出
    private static void b(int i){
        System.out.println(i);
        //递归结束的条件
        if(i==500){
            return;//结束方法
        }
        b(++i);
    }
//1.递归一定要有条件限定，保证递归能够停止下来，否则会发生栈内存溢出。 Exception in thread "main"
 //java.lang.StackOverflowError

    private static void a() {
        System.out.println("a方法");
        a();
    }
}

2.累加求和

public class DiguiSum{
    public static void main(String[] args){
        // 计算1-num的和
        //调用求和的方法
        int sum = getSum(num);
        //输出结果
        System.out.println(sum);
    }
    public static int getSum(int num){
        if(num==1){
            return 1;
        }
        return num+getSum(num-1);
    }
}