Lambda表达式File类

今日内容

  • 函数式编程思想

  • 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表达式File类_第1张图片

体验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标准格式的表达式的基础上,使用省略写法的规则是:

  1. 小括号内参数的类型可以省略。

  2. 如果小括号内有且仅有一个参数,则小括号也可以省略

  3. 如果大括号内有且仅有一个语句,则无论是否有返回值,都可以省略大括号、return关键字和语句的分号。

Lambda的使用前提

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

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

    无论JDK内置的Runnable、Comparator接口还是自定义的接口,只有当接口中的抽象方法存在且唯一,才可以使用Lambda

  2. 使用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(){
			// 升序     前面-后面
			@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 list = new ArrayList();
		
		// 在JDK1.7版本之后, = 号后面的泛型可以省略,后面的泛型可以根据前边的推导出来
		ArrayList list2 = new ArrayList<>();
		
	}
	
	
}

下周预习内容:

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

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

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

Stream流、方法引用

你可能感兴趣的:(java)