Lambda表达式File类

最新推荐文章于 2023-07-26 23:41:22 发布

学java的狗蛋

最新推荐文章于 2023-07-26 23:41:22 发布

阅读量222

点赞数

文章标签： java

本文链接：https://blog.csdn.net/weixin_51621893/article/details/111079923

版权

今日内容

函数式编程思想
lambda表达式
File类
递归

函数式编程思想

强调的是做什么，而不是以什么样的方式来做，它忽略了面向对象的复杂语法，只要能够获取到结果，谁去做的，怎么做的，都不重要，重要的是结果，不重视过程。

冗余的Runnable代码

传统的写法

public class Demo01Runnable {
    public static void main(String[] args) {
        // 匿名内部类的方式
        new Thread(new Runnable() {
            @Override
            public void run(){
                System.out.println("开启了一个新的线程任务");
            }
        }).start();// 启动新线程  
    }
}

代码分析：

对于Runnable的匿名内部类用法，可以分析出一下内容：

Thread类需要Runnable接口作为参数，其中抽象方法run用来指定线程任务内容的核心。
为了指定run方法的方法体，不得不需要Runnable接口的实现类
为了省去定义一个RunnableImpl实现类的麻烦，不得不使用匿名内部类。
必须重写抽象方法run方法，所以方法的名称、方法的参数、方法的返回值不得不在写一遍，且不能写错。
从这里面可以，只有方法体才是线程任务的关键性内容

编程思想的转换

做什么，而不是怎么做

我们真正希望做的事情是：将run方法体内的代码传递给Thread类知晓能够加载到即可。

传递一段代码---这是我们真正的目的。

我们需要将程序关注的重点从怎么做回归到做什么的本质上，过程与形式并不重要。

2014年3月Oracle官方所发布的Java 8(JDK1.8)中，加入了Lambda表达式

体验Lambda表达式的更优写法

Java 8的新特性，优化刚才的代码

public class Demo01Runnable {
    public static void main(String[] args) {
        // 使用Lambda表达式的方式
        new Thread(() -> {
                System.out.println("开启了一个新的线程任务");
            }
        ).start();// 启动新线程  
    }
}

从上面的代码可以看出：没有创建接口实现类对象的操作，也不再有抽象方法覆盖重写的操作，只写了线程任务的内容。

从上面的代码能狗推导出Lambda的语法：

() -> System.out.println("开启了一个新的线程任务")

前面的一对小括号即run方法，参数为无，里面是空的，此时需要任何的条件
中间的一个箭头代表将前面的参数传递给后面的代码
后面的输出语句即业务逻辑代码(线程任务内容)

Lambda的标准格式

格式由三个部分组成：

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

Lambda表达式的标准格式：

(参数类型1 参数名称1,参数类型2 参数名称2,....) -> {代码语句}

格式说明：

小括号内的语法与传统的方法参数列表一致，无参数就留空，多个参数则用逗号隔开
->是新引入的语法格式，代表指向的动作
大括号内的语法与传统方法体要求基本一致。

练习：定义一个厨子接口，该接口内内置了一个做饭的方法(抽象的方法)，且无参数，无返回值，使用Lambda表达式，最后打印输出“我今天吃的是红烧茄子，吃的好开心”。(无参无返回)

练习2：使用数组存储多个学生对象，对数组中的学生对象使用Arrays的sort方法通过年龄进行升序排序。使用Lambda表达式来实现以上需求。(有参无返回)

练习3：给定一个计算器接口，内置了一个抽象方法计算的方法，可以将两个double类型的数字相加得到和值。使用Lambda表达式来实现以上需求。（有参有返回）

代码示例：

Lambda省略格式

可推导即可省略

Lambda强调的是“做什么”，而不是“怎么做”，所以凡是可以根据上下文推导得知的信息，都可以省略。比如：

invokeSum(3.14, 3.15, (double d1,double d2) -> {
			   return  d1 + d2;
		});
// 省略格式表达
invokeSum(3.14,3.15,(d1,d2) -> d1 + d2);

省略的规则：

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

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

Lambda的使用前提

Lambda的语法非常的简洁，使用非常的简单，但是有以下注意事项：

使用Lambda必须具有接口，且要求接口中有且仅有一个抽象方法

无论JDK内置的Runnable、Comparator接口还是自定义的接口，只有当接口中的抽象方法存在且唯一，才可以使用Lambda
使用Lambda必须具有上下文推断。

也就是方法的参数或者局部变量类型必须为Lambda对应的接口类型，才能使用Lambda作为该接口的实例。

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

学习目标

能够说出File类获取名称的方法名称
能够说出File对象的创建方式
能够说出File类获取绝对路径的方法名称
能够区分文件操作中的相对路径与绝对路径
能过说出File获取文件大小的方法名称
能够判断一个文件是否为文件还是文件夹(目录)
能够遍历文件夹(目录)
能够解释递归的含义
能够使用递归的方式做相关的数学运算
能够解释使用递归引发内存溢出隐患的原因

File类

java.io.File类是文件和目录路径名的抽象表示。主要用于文件和目录的创建、查找、删除等操作。

Java把电脑中的文件和文件夹(目录)封装为了一个File类，我们可以使用File类对文件和文件夹进行操作。

可以使用File类的方法：

创建一个文件、文件夹
删除一个文件、文件夹
获取一个文件、文件夹
判断文件、文件夹是否存在
对文件夹进行遍历
获取文件的大小

File类是一个与系统无关的类，任何的操作系统都可以使用这个类中的方法。

构造方法

public File(String pathname)：通过将给定路径名字符串转换为抽象路径名来创建一个新 File 实例。
public File(String parent,String child)：根据 parent 路径名字符串和 child 路径名字符串创建一个新 File 实例。
public File(File parent,String child)：根据 parent 抽象路径名和 child 路径名字符串创建一个新 File 实例。

代码示例：

常用API方法

获取功能的方法
判断功能的方法
路径功能的方法
创建删除功能的方法
目录遍历功能的方法

获取功能的方法

public String getAbsolutePath()：返回此抽象路径名的绝对路径名字符串。
public String getPath()：将此File转换为路径名字符串
public String getName()：返回由此File表示的文件或目录的名称。
public long length()：返回此File表示的文件的长度。

判断功能的方法

public boolean exists()：判断File表示的文件或者文件夹是否实际存在
public boolean isDirectory()：判断此File表示的文件夹是否存在
public boolean isFile()：判断此File表示的文件是否存在

创建和删除文件的方法

public boolean createNewFile()：当且仅当具有该名称的文件不存在时，创建一个新的空的文件，返回值是true
public boolean delete()：删除由此File表示的文件或者目录
public boolean mkdir()：创建由此File表示的文件夹
public boolean mkdirs()：创建由此File表示的文件夹，包括任何必须但是又不存在的父目录。

目录的遍历

public String[] list()：返回一个String数组，表示该File目录中的所有的子目录或者子文件。
public File[] listFile()：返回一个File数组，表示该File目录中的所有的子目录或者子文件。

《编译器代码演示》

/*
 * 学习三个单词：
 *      1. file:文件
 *      2. directory:目录/文件夹
 *      3. path:路径
 */
public class Demo01File {
	
	public static void main(String[] args) {
		/*
		 * static String pathSeparator      与系统有关的路径分隔符，为了方便，它被表示为一个字符串。 
		   static char pathSeparatorChar    与系统有关的路径分隔符。 
		   static String separator          与系统有关的默认名称分隔符，为了方便，它被表示为一个字符串。 
		   static char separatorChar        与系统有关的默认名称分隔符。 
		   
		   D:\Developer\Java\jdk1.8.0_191
		        操作路径不能写死
		    D: + File.separator + Developer + File.separator + Java + File.separator + jdk1.8.0_191
		 */
		
		String pathseparator = File.pathSeparator;
		System.out.println(pathseparator);// ;  路径分隔符     windows:分号     linux:冒号 
		
	  /*  char pathSeparatorChar =   File.pathSeparatorChar;
		System.out.println(pathSeparatorChar);*/
		
		String separator = File.separator;
		System.out.println(separator);// \ 名称分隔符    windows:反斜杠\   linux:正斜杠/
		
	}
	
}

/*
 * 
 * 路径：
 *    绝对路径： 是一个完整的路径 一般以盘符(D:,C:,c:,d:)为开头
 *        如： D:\Developer\Java\jdk1.8.0_191\README.html
 *           D:\123.txt
 *    
 *    相对路径：是一个简化的路径
 *        相对指的是相对于当前项目的根目录(E:\codes\workspace\day26_LambdaAndFile)
 *        如果使用当前项目的根目录，路径可以简化书写：
 *        E:\codes\workspace\day26_LambdaAndFile\.classpath---->简化为：.classpath(可以省略前面项目的根目录)
 * 	   注意：
 *       1.路径是不区分大小写
 *       2.路径中的文件名称分隔符windows使用反斜杠	，反斜杠是转义字符，两个反斜杠才代表一个普通的反斜杠。
 */
public class Demo02File {

	public static void main(String[] args) {
//		show01();
//		show02("D:\\", "Developer\\Java\\jdk1.8.0_191\\README.html");
		File parent = new File("D:\\");	
		String child = "Developer\\Java\\jdk1.8.0_191\\README.html";
		show03(parent, child);
	}
	
	/*
	 *  public File(File parent,String child)：根据 parent 抽象路径名和 child 路径名字符串创建一个新 File实例。
	 *  参数：把路径分成了两部分
	 *      File file 父路径
	 *      String child 子路径
	 *  好处：
	 *     父路径和子路径，可以单独写
	 *     父路径是File类型，可以使用File类中的方法对路径进行一些操作
	 */
	public static void show03(File parent,String child) {
		File file = new File(parent,child);
		System.out.println(file);// D:\Developer\Java\jdk1.8.0_191\README.html
	}
	
	
	/*
	 * public File(String parent,String child)：根据 parent 路径名字符串和 child 路径名字符串创建一个新 File 实例。
	 * 参数：把路径分成了两部分
	 *    String parent 父路径
	 *    String child  子路径
	 * 好处：
	 *    父路径和子路径，可以单独写，   
	 */
	public static void show02(String parent,String child) {
		File file = new File(parent, child);
		System.out.println(file);//D:\Developer\Java\jdk1.8.0_191\README.html
	}
	
	
	/*
	 * 使用第一个构造方法  public File(String pathname) 通过将给定路径名字符串转换为抽象路径名来创建一个新 File 实例。
	 * 参数：
	 *    String pathname：字符串的路径名称
	 *    路径可以是以文件结尾，也可以是以文件夹结尾
	 *    路径可以是相对路径，也可以是绝对路径
	 *    路径可以是存在的，也可以是不存在的
	 *    File对象，只是把字符串路径封装为File类对象，不考虑路径的真实情况。
	 */
	public static void show01() {
		File f1 = new File("D:\\Developer\\Java\\jdk1.8.0_191\\README.html");
		System.out.println(f1);//D:\\Developer\\Java\\jdk1.8.0_191\\README.html
		
		File f2 = new File("D:\\Developer\\Java\\jdk1.8.0_191");
		System.out.println(f2);//D:\Developer\Java\jdk1.8.0_191
		
		File f3 = new File(".project");
		System.out.println(f3);//.project
		
		File f4 = new File("abc.txt");
		System.out.println(f4);//abc.txt
	}
	
}

/*
 * 获取功能的方法
	- public String getAbsolutePath()：返回此File表示的绝对路径名字符串。 
	- public String getPath()：将此File转换为路径名字符串
	- public String getName()：返回由此File表示的文件或目录的名称。
	- public long length()：返回此File表示的文件的长度。
 */
public class Demo03File {

	public static void main(String[] args) {
//		show01();
//		show02();
//		show03();
		show04();
	}
	
	/*
	 * public long length()：返回此File表示的文件的长度。
	 * 获取的是构造方法中指定的文件的大小，以字节为单位
	 * 注意：
	 *    文件夹是没有大小概念的，不能获取文件夹的大小
	 *    如果构造方法中给出的路径不存在，那么length()方法的返回值是0
	 */
	public static void show04() {
		File f1 = new File("E:\\codes\\workspace\\day26_LambdaAndFile\\.classpath");
		long length = f1.length();
		System.out.println(length);// 232 字节
		
		// 11,346 字节
		File f2 = new File("E:\\documents\\Java运算符优先级.png");
		long length2 = f2.length();
		System.out.println(length2);// 11346
		
		File f3 = new File("E:\\codes\\workspace\\day26_LambdaAndFile");
		long length3 = f3.length();
		System.out.println(length3);// 0
		
		File f4 = new File("E:\\codes\\workspace\\day26_Lambda");
		long length4 = f4.length();
		System.out.println(length4);// 0
	}
	
	/*
	 * public String getName()：返回由此File表示的文件或目录的名称。
	 * 获取的是构造方法中传递路径的结尾部分(文件还是文件夹)
	 * 
	 */
	public static void show03() {
		File f1 = new File("E:\\codes\\workspace\\day26_LambdaAndFile\\.classpath");
		String name = f1.getName();
		System.out.println(name);// .classpath
		
		File f2 = new File("E:\\codes\\workspace\\day26_LambdaAndFile");
		String name2 = f2.getName();
		System.out.println(name2);// day26_LambdaAndFile
		
	}
	
	/*
	 * public String getPath()：将此File转换为路径名字符串
	 * 获取构造方法中传递的路径
	 * 
	 * 	源码当中：toString方法
		  public String toString() {
        		return getPath();
    	   }
	 */
	public static void show02() {
		File f1 = new File("E:\\codes\\workspace\\day26_LambdaAndFile\\.classpath");
		String path = f1.getPath();
		System.out.println(path);// E:\codes\workspace\day26_LambdaAndFile\.classpath
		File f2 = new File(".classpath");
		String path2 = f2.getPath();
		System.out.println(path2);// .classpath
	}
	
	
	
	/*
	 * public String getAbsolutePath()：返回此抽象路径名的绝对路径名字符串。
	 * 获取的是构造方法里面传递的路径
	 * 无论路径是绝对路径还是相对路径，getAbsolutePath返回的都是绝对路径
	 * 
	 */
	public static void show01() {
		File f1 = new File("E:\\codes\\workspace\\day26_LambdaAndFile\\.classpath");
		String absolutePath = f1.getAbsolutePath();
		System.out.println(absolutePath);// E:\codes\workspace\day26_LambdaAndFile\.classpath
		
		File f2 = new File(".classpath");
		String absolutePath2 = f2.getAbsolutePath();
		System.out.println(absolutePath2);// E:\codes\workspace\day26_LambdaAndFile\.classpath
		
		File file = new File("day26_LambdaAnd");
		String absolutePath3 = file.getAbsolutePath();
		System.out.println(absolutePath3);// E:\codes\workspace\day26_LambdaAndFile\day26_LambdaAnd
	}
	
	
	
}

/*
 * 判断功能的方法
	- public boolean exists()：判断File表示的文件或者文件夹是否实际存在
	- public boolean isDirectory()：判断此File表示的文件夹是否存在
	- public boolean isFile()：判断此File表示的文件是否存在
 */
public class Demo04File {

	public static void main(String[] args) {
//		show01();
		show02();
	}
	
	
	/*
	 * public boolean isDirectory()：判断此File表示的文件夹是否存在
	 *   用于判断构造方法中给定的路径是否以文件夹结尾
	 *   	是：true
	 *      不是：false
	 * 
	 * public boolean isFile()：判断此File表示的文件是否存在
	 *   用于判断构造方法中给定的路径是否以文件结尾
	 *     是：true
	 *     不是：false
	 * 
	 * 注意：
	 *    电脑的硬盘中只有文件和文件夹，两个方法时互斥的
	 *    这两个方法使用的前提是：路径必须是存在的，否则都返回false
	 * 
	 */
	public static void show02() {
		File f1 = new File("E:\\codes\\workspace\\day26_LambdaAndFile\\.classpath");
		System.out.println(f1.isDirectory());// false
		System.out.println(f1.isFile());// true
		
		File f2 = new File("E:\\codes\\workspace\\day26_Lambda");
		
		if (f2.exists()) {
			System.out.println(f2.isDirectory());// false
			System.out.println(f2.isFile());// false
		}
		
		File f3 = new File("E:\\codes\\workspace\\day26_LambdaAndFile\\.project");
		if (f3.exists()) {
			System.out.println(f3.isDirectory());//false
			System.out.println(f3.isFile());//true
		}
		
	}
	
	
	/*
	 * public boolean exists()：判断File表示的文件或者文件夹是否实际存在
	 * 用于判断构造方法中的路径是否存在
	 *    存在：true
	 *    不存在：false
	 */
	public static void show01() {
		File f1 = new File("E:\\codes\\workspace\\day26_LambdaAndFile\\.classpath");
		System.out.println(f1.exists());// true
		
		File f2 = new File("E:\\codes\\workspace\\day26_LambdaAndFile");
		System.out.println(f2.exists());// true

		File f3 = new File("E:\\codes\\workspace\\day26_Lambda");
		System.out.println(f3.exists());// false
		
		File f4 = new File(".classpath");// 相对路径-->E:\\codes\\workspace\\day26_LambdaAndFile\\.classpath
		System.out.println(f4.exists());// true
		
		File f5 = new File("123.txt");
		System.out.println(f5.exists());//false
		
		File f6 = new File("css样式简单介绍.md");
		System.out.println(f6.exists());// false
		
		
	}
	
	
	
}

/*
 *创建和删除文件的方法
	- public boolean createNewFile()：当且仅当具有该名称的文件不存在时，创建一个新的空的文件，返回值是true
	- public boolean delete()：删除由此File表示的文件或者目录
	- public boolean mkdir()：创建由此File表示的文件夹
	- public boolean mkdirs()：创建由此File表示的文件夹，包括任何必须但是又不存在的父目录。
 */
public class Demo05File {

	public static void main(String[] args) throws IOException {
		
//		show01();
//		show02();
		show03();
	}
	
	/*
	 * public boolean delete()：删除由此File表示的文件或者目录
	 * 此方法，可以删除构造方法路径中给出的文件或者文件夹
	 * 返回值：布尔值
	 *     true：文件、文件夹删除成功，返回true
	 *     false：如果文件夹中有内容，不会删除返回false；构造方法中不存在的路径返回的是false
	 *     
	 * 注意：
	 *     delete方法时直接从磁盘删除文件/文件夹，不经过回收站。    
	 *     文件夹中有内容不能删除，但是文件中有内容不影响删除
	 *     删除的路径可以是相对路径也可以是绝对路径，
	 *     如果是相对路径，则查看当前项目的根目录是否有该文件或者文件夹，
	 *     如果有且内容为空删除，如果没有返回false，删除失败。
	 */
	public static void show03() {
		File f1 = new File("E:\\codes\\workspace\\day26_LambdaAndFile\\aa");
		boolean b1 = f1.delete();
		System.out.println(b1);
		
		File f2 = new File("E:\\codes\\workspace\\day26_LambdaAndFile\\file");
		boolean b2 = f2.delete();
		System.out.println(b2);
		
		File f3 = new File("E:\\codes\\workspace\\day26_LambdaAndFile\\新建文件夹");
		boolean b3 = f3.delete();
		System.out.println(b3);
		
		File f4 = new File("E:\\codes\\workspace\\day26_LambdaAndFile\\abc.txt");
		boolean b4 = f4.delete();
		System.out.println(b4);
		
		File f5 = new File("day26_Lambda");
		boolean b5 = f5.delete();
		System.out.println(b5);
		
	}
	
	/*
	 * public boolean mkdir()：创建由此File表示的文件夹
	 *                         ---》创建单级空文件夹
	   public boolean mkdirs()：创建由此File表示的文件夹，包括任何必须但是又不存在的父目录。
	                            ---》既可以创建单级空文件夹，也可以创建多级孔文件夹
	 * 
	 * 注意：
	 *     此方法只能创建文件夹，不能创建文件
	 *     路径不对也不会抛出异常，可以使用相对路径也可以使用绝对路径
	 */
	public static void show02() {
		File f1 = new File("E:\\codes\\workspace\\day26_LambdaAndFile");
		boolean b1 = f1.mkdir();
		System.out.println(b1);// false
		
		File f2 = new File("E:\\codes\\workspace\\day26_Lambda");
		boolean b2 = f2.mkdir();
		System.out.println(b2);// true
		
		File f3 = new File("E:\\codes\\workspaces\\day26_Lambda");
		boolean b3 = f3.mkdir();
		System.out.println(b3);//false
		
		File f4 = new File("bin");
		boolean b4 = f4.mkdir();
		System.out.println(b4);//false
		
		File f5 = new File("E:\\codes\\workspace\\day26_LambdaAndFile\\aa\\bb\\cc\\dd");
		boolean b5 = f5.mkdirs();
		System.out.println(b5);//true
		
		File f6 = new File("file\\aa\\bb\\cc\\dd");
		boolean b6 = f6.mkdirs();
		System.out.println(b6);//true
		
		
	}
	
	/*
	 * public boolean createNewFile()：当且仅当具有该名称的文件不存在时，创建一个新的空的文件，返回值是true
	 * 创建文件的路径和名称在构造方法中声明
	 * 返回值：
	 *     布尔值
	 *     true：文件不存在，创建了空文件，返回为true
	 *     false：文件存在，不会创建，返回false
	 * 注意：
	 *     1. 此方法不能创建文件夹，只能创建文件
	 *     2. 创建文件的路径必须存在，否则就抛出异常。
	 * 该方法携带有IOException
	 */
	public static void show01() throws IOException {
		File f1 = new File("E:\\codes\\workspace\\day26_LambdaAndFile\\.classpath");
		boolean b1 = f1.createNewFile();
		System.out.println(b1);// false

		File f2 = new File("E:\\codes\\workspace\\day26_LambdaAndFile\\abc.txt");
		boolean b2 = f2.createNewFile();
		System.out.println(b2);// true

		File f3 = new File("E:\\codes\\workspace\\day26_LambdaAndFile\\新建文件夹");
		boolean b3 = f3.createNewFile();
		System.out.println(b3);// true
		
		File f4 = new File("E:\\codes\\workspace\\day26_Lambda\\123.txt");
		boolean b4 = f4.createNewFile();
		System.out.println(b4);// java.io.IOException: 系统找不到指定的路径。
		
		
		
	}
	
	
	
	
}

/*
 *目录的遍历
	- public String[] list()：返回一个String数组，表示该File目录中的所有的子目录或者子文件。
	- public File[] listFile()：返回一个File数组，表示该File目录中的所有的子目录或者子文件。
	
	注意事项：
	    list方法和listFile方法遍历的是构造方法中指定的目录。
	            如果构造方法中给出的目录的路径不存在，会抛出空指针异常。
	            如果构造方法中给出的目录不是一个目录，也会抛出一个空指针异常。         
	
 */
class Fu {
	
	public Fu() {
		
	}
	
}


public class Demo06File extends Fu{
	
/*	public Demo06File() {
		this("张三");
	}
	
	public Demo06File(String name) {
		Demo06File();
	}*/
	
	public static void main(String[] args) {
//		show01();
//		show02();
		show03(20000);
	}
	
	public static void show04() {
		System.out.println("show04.......");
		//show03();//  java.lang.StackOverflowError
		
	}
	
	public static void show03(int n) {
		System.out.println("show03......." + n);
		if (n == 1) {
			return;
		}
		show03(n-1);//  java.lang.StackOverflowError
	}
	
	/*
	 * public File[] listFile()：返回一个File数组，表示该File目录中的所有的子目录或者子文件
	 * 遍历构造方法中给出的目录，会获取目录中所有的文件夹、文件的名称，把获取到的多个名称存储到一个File类型的数组中
	 * 
	 */
	public static void show02() {
		File file = new File("E:\\codes\\workspace\\day26_LambdaAndFile");
		File[] list = file.listFiles();
		// 遍历
		for (File f : list) {
			System.out.println(f.toString());
		}
		
		/*
		 *  E:\codes\workspace\day26_LambdaAndFile\.classpath
			E:\codes\workspace\day26_LambdaAndFile\.project
			E:\codes\workspace\day26_LambdaAndFile\abc.txt
			E:\codes\workspace\day26_LambdaAndFile\bin
			E:\codes\workspace\day26_LambdaAndFile\file
			E:\codes\workspace\day26_LambdaAndFile\src
		 */
	}
	
	/*
	 * public String[] list()：返回一个String数组，表示该File目录中的所有的子目录或者子文件。
	 * 遍历构造方法中给出的目录，会获取目录中所有的文件夹、文件的名称，把获取到的多个名称存储到一个String类型的数组中
	 * 
	 */
	public static void show01() {
		// java.lang.NullPointerException
		//File file = new File("E:\\codes\\workspace\\day26_LambdaAndFile\\abc.txt");
		// java.lang.NullPointerException
		// File file = new File("E:\\codes\\workspace\\day26_Lambda");
		File file = new File("E:\\codes\\workspace\\day26_LambdaAndFile");
		String[] list = file.list();
		// 遍历
		for (String string : list) {
			System.out.println(string);
		}
		/*
		 *  .classpath
			.project
			abc.txt
			bin
			file
			src
		 */
	}
}

/*
 * 定义一个接口 厨子接口，内含唯一的抽象方法做饭的方法 makeFood()
 */
public interface Cook {
	// 定义一个无参无返回的方法	
	void makeFood();
	
	
}

/*
 * 
 * 定义一个厨子接口，该接口内内置了一个做饭的方法(抽象的方法)，且无参数，无返回值，
 * 使用Lambda表达式，最后打印输出“我今天吃的是红烧茄子，吃的好开心”。(无参无返回)
 * 标准格式：
 *   (参数类型1 参数名称1,参数类型2 参数名称2,....) -> {代码语句}
 */
public class Demo01Cook {

	public static void main(String[] args) {
		//调用invokeFood()方法，参数是Cook接口, 传递Cook接口的匿名内部类对象
		invokeFood(new Cook() {
			@Override
			public void makeFood() {
				System.out.println("我今天吃的是红烧茄子，吃的好开心");
			}
		});
		
//		() ->{};
		// 使用Lambda表达式，简化匿名内部类
		invokeFood(() -> {
			System.out.println("我今天吃的是红烧茄子，吃的好开心");
		});
		
		// 使用Lambda表达式的省略写法
		invokeFood(() -> System.out.println("我今天吃的是红烧茄子，吃的好开心"));
		
	
	}
	
	// 定义一个方法，参数的类型Cook接口，方法内部做一个调用makeFood()
	public static void invokeFood(Cook cook) {
		cook.makeFood();
	}
	
	
	
	
}

//定义一个学生类
public class Student {
	private String name;
	private Integer age;
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Integer getAge() {
		return age;
	}
	public void setAge(Integer age) {
		this.age = age;
	}
	@Override
	public String toString() {
		return "Student [name=" + name + ", age=" + age + "]";
	}
	public Student(String name, Integer age) {
		super();
		this.name = name;
		this.age = age;
	}
	
	public Student() {
		super();
	}
	
	
	
}

/*
 * 使用数组存储多个学生对象，对数组中的学生对象使用Arrays的sort方法通过年龄进行升序排序。
 * 使用Lambda表达式来实现以上需求。(有参无返回)
 * 
 */
public class Demo01Arrays {

	public static void main(String[] args) {
		// 使用数组存储多个学生对象
		Student[] students = {new Student("小孙", 20),new Student("小刘", 18),
				   new Student("小王",25),new Student("小赵", 15)};
		
		// 传统的写法 匿名内部类方式
		/*Arrays.sort(students,new Comparator<Student>(){
			// 升序     前面-后面
			@Override
			public int compare(Student s1,Student s2) {
				return s1.getAge() - s2.getAge();
			}
		});*/
		
		// 使用Lambda表达式 简化匿名内部类
		Arrays.sort(students,(Student s1,Student s2) -> {
			return s1.getAge() - s2.getAge();
		});
		
		// 使用Lambda表达式的省略写法
		Arrays.sort(students,(s1,s2) -> s1.getAge() - s2.getAge());
		
		
		/*输出的结果：
		 *  Student [name=小赵, age=15]
			Student [name=小刘, age=18]
			Student [name=小孙, age=20]
			Student [name=小王, age=25]
		 */
		
		for (Student student : students) {
			System.out.println(student);
		}
		
	}
}

//定义一个计算器的接口Cala，内置了一个抽象的方法 sum(double d1,double d2)，有返回值sum值
public interface Calc {
	// 定义一个求和的 
	double sum(double d1,double d2);
	
}

/*
 * 给定一个计算器接口，内置了一个抽象方法计算的方法，可以将两个double类型的数字相加得到和值。
 * 使用Lambda表达式来实现以上需求。（有参有返回）
 * 
 */
public class Demo01Calc {

	public static void main(String[] args) {
		
		// 传统写法  使用匿名内部类的方式
		/*invokeSum(3.14, 3.15, new Calc() {
			@Override
			public double sum(double d1, double d2) {
				
				return d1 + d2;
			}
		});*/ // d1 + d2 的和为：6.29
		
//		() -> {}
		// 使用Lambda表达式实现      新式写法
		/*invokeSum(3.14, 3.15, (double d1,double d2) -> {
			   // 带着返回值
			   return  d1 + d2;
		});*/// d1 + d2 的和为：6.29
		
		// 使用Lambda表达式的省略写法
		invokeSum(3.14,3.15,(d1,d2) -> d1 + d2);
		
	}
	
	// 定义一个方法
	/*
	 * 参数传递两个double值，
	 * 传递一个Calc接口
	 * 方法内部调用了sum()
	 * 
	 */
	public static void invokeSum(double d1,double d2,Calc calc) {
		double sum = calc.sum(d1, d2);
		System.out.println("d1 + d2 的和为："+sum);
	}
}

/*
 * 可以省略的内容：
 *    1.参数列表：括号中的参数列表的数据类型，可以省略不写。
 *    2.参数列表：括号中的参数只有一个，那么类型和小括号都可以省略
 *    3.{一些代码}：如果{}中的代码只有一行代码，无论是否有返回值，都可以省略（{},return,分号）、
 *      但是：要省略{},return,分号需要一起省略。
 */
public class Demo01Lambda {

	public static void main(String[] args) {
		// 在JDK1.7之前，创建集合对象的泛型需要前后都显式的定义
		ArrayList<String> list = new ArrayList<String>();
		
		// 在JDK1.7版本之后， = 号后面的泛型可以省略，后面的泛型可以根据前边的推导出来
		ArrayList<String> list2 = new ArrayList<>();
		
	}
	
	
}

下周预习内容：

递归、字节流、字符流、缓冲流、转换流、序列化流、打印流等

网络编程软件架构CS/BS TCP、SOCKET SERVERSOCKET

函数式接口、函数式编程、常用函数式接口

Stream流、方法引用

学java的狗蛋

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Lambda表达式File类

今日内容函数式编程思想 lambda表达式 File类递归函数式编程思想强调的是做什么，而不是以什么样的方式来做，它忽略了面向对象的复杂语法，只要能够获取到结果，谁去做的，怎么做的，都不重要，重要的是结果，不重视过程。冗余的Runnable代码传统的写法public class Demo01Runnable { public static void main(String[] args) { // 匿名内部类的方.
复制链接

扫一扫