Java基础(十)
复习
静态方法与成员方法
//另一个类里的静态和成员方法 public class MyClass { //静态方法 public static void method2() { System.out.println("静态方法2执行!"); } //没有static,这是一个成员方法(实例方法,Instance Method) public void method3() { System.out.println("成员方法3执行!"); } } /* * 定义方法的时候,有static和没有static有什么区别? * * 有static的方法,叫做静态方法. * 没有static的方法,叫做成员方法(实例方法). * * 定义静态方法的格式: * public static 返回值类型 方法名称(参数类型 参数名称){ * //方法体 * } * * 定义成员方法的格式: * public 返回值类型 方法名称(参数类型 参数名称){ * //方法体 * } * * 调用静态方法的格式: * 方法名(参数值); //直接调用本类当中的静态方法 * 类名称.方法名(参数值); //调用另外一个类当中的静态方法 * 调用成员方法的格式: * 类名称 对象名 = new 类名称(); //首先创建对象 * 对象名.成员方法名(参数值); //通过对象名调用成员方法 * * 1.如果不创建对象,那么通过类名称只能调用静态方法. * 2.如果创建了对象,那么通过对象名可以调用成员方法. * 3.通过对象名称也可以调用静态方法,然而不推荐这么做. */ public class Demo01StaticVsInstance { public static void main(String[] args) { method1(); //调用本类当中的静态方法 //注意:本类当中的静态方法,也可以通过类名称进行调用. Demo01StaticVsInstance.method1(); //调用本类当中的静态方法 MyClass.method2(); //调用另外一个类当中的静态方法 //需要调用成员方法,就必须借助对象 MyClass obj = new MyClass(); //一定要首先创建一个对象 obj.method3(); //然后才能通过对象去调用成员方法 obj.method2(); //这种写法也可以,但是不推荐! } public static void method1() { System.out.println("静态方法1执行!"); } }
静态方法的简单使用
//Cook类 public class Cook { //这是一个静态方法,可以通过类名称进行调用 public static void makeFood(String food) { System.out.println("将" + food + "做成可口的食物."); } } public class Demo02StaticInvoke { public static void main(String[] args) { //希望调用Cook这个类当中的静态方法makeFood //类名称.静态方法名(参数值) Cook.makeFood("白菜"); } }
方法引用
Lambda的冗余场景
//Cook类 public class Cook { //这是一个静态方法,可以通过类名称进行调用 public static void makeFood(String food) { System.out.println("将" + food + "做成可口的食物."); } } //保姆接口 public interface Sitter { //保姆的工作,就是生米煮成熟饭 public abstract void work(String food); } /* * 在某些场景之下,Lambda表达式要做的事情,其实在另外一个地方已经写过了. * 那么此时如果通过Lambda表达式重复编写相同的代码,就是浪费. * 那么如何才能复用已经存在的方法逻辑呢? */ public class Demo03Lambda { public static void main(String[] args) { hireSitter( sitter -> System.out.println("将" + sitter + "做成可口的食物.") ); } //雇佣一个保姆,并且让他去做饭 public static void hireSitter(Sitter sitter) { sitter.work("白菜"); } }
体验方法引用
//Cook类 public class Cook { //这是一个静态方法,可以通过类名称进行调用 public static void makeFood(String food) { System.out.println("将" + food + "做成可口的食物."); } } //保姆接口 public interface Sitter { //保姆的工作,就是生米煮成熟饭 public abstract void work(String food); } /* * 在某些场景之下,Lambda表达式要做的事情,其实在另外一个地方已经写过了. * 那么此时如果通过Lambda表达式重复编写相同的代码,就是浪费. * 那么如何才能复用已经存在的方法逻辑呢? */ public class Demo03Lambda { public static void main(String[] args) { hireSitter( sitter -> System.out.println("将" + sitter + "做成可口的食物.") ); hireSitter( Cook -> makeFood ); } //雇佣一个保姆,并且让他去做饭 public static void hireSitter(Sitter sitter) { sitter.work("白菜"); } }
类名称引用静态方法的格式
//Cook类 public class Cook { //这是一个静态方法,可以通过类名称进行调用 public static void makeFood(String food) { System.out.println("将" + food + "做成可口的食物."); } } //保姆接口 public interface Sitter { //保姆的工作,就是生米煮成熟饭 public abstract void work(String food); } /* * 在某些场景之下,Lambda表达式要做的事情,其实在另外一个地方已经写过了. * 那么此时如果通过Lambda表达式重复编写相同的代码,就是浪费. * 那么如何才能复用已经存在的方法逻辑呢? * * 如果Lambda表达式需要做的事情,在另外一个类当中已经做过了,那么就可以直接拿过来替换Lambda. * 方法引用的写法: * * 通过类名称引用静态方法,格式: * 类名称::静态方法名 */ public class Demo03Lambda { public static void main(String[] args) { hireSitter( sitter -> System.out.println("将" + sitter + "做成可口的食物.") ); hireSitter( Cook -> makeFood ); } //雇佣一个保姆,并且让他去做饭 public static void hireSitter(Sitter sitter) { sitter.work("白菜"); } }
类名称引用静态方法的练习
//计算器函数式接口 @FunctionalInterface public interface Calculator { //抽象方法的作用:求绝对值(如果是正数或者是0,那么仍然是本身;如果是负数,就要负负为正) public abstract int getAbs(int num); } /* * JDK当中已经给我们提供好了一个java.lang.Math类.其中有一个静态方法abs就可以实现求绝对值的功能. * 既然Math.abs方法已经存在了现成的做法,那么我就没有必要在用Lambda自己写一遍了. * 就可以通过方法引用,直接拿过来用. * * 格式: * 类名称::静态方法名 */ public class Demo01Abs { public static void main(String[] args) { method( num -> { int result; if(num >= 0) { //如果是正数或者是0.那么原封不动 result = num; }else { //否则就是负数,应该负负为正 result = -num; } return result; } ); System.out.println("==============================="); //方法引用的意义:Math类当中有一个abs静态方法,已经有了现成的功能,直接拿过来用. method(Math::abs); } public static void method(Calculator calculator) { int result = calculator.getAbs(-25); System.out.println("结果是:" + result); } }
对象名引用成员方法的格式
//Cook类 public class Cook { //这是一个成员方法,必须要有对象才能调用 public void makeFood(String food) { System.out.println("将" + food + "做成可口的饭菜!" ); } } //函数式接口 public interface Sitter { public abstract void work(String food); } /* * 方法引用的又一种格式: * * 通过对象引用成员方法,格式: * 对象名::成员方法名 */ public class Demo02MethodRef { public static void main(String[] args) { Cook cook = new Cook(); //创建了一个厨师对象 //引用了cook对象当中的成员方法makeFood method( cook::makeFood ); } public static void method(Sitter sitter) { sitter.work("土豆"); } }
对象名引用成员方法的练习
//函数式接口 @FunctionalInterface public interface Monitor { //将参数打印显示出来 public abstract void show(String str); } /* * 问题:既然Lambda就是拿到参数,原封不动的交给println去使用. * 那么为什么不能直接交给println,而中间不用Lambda? * Lambda在这种场景当中,要做的事情,就是打印.而打印的功能在println当中已经有了. * * 这时候,可以使用方法引用. * 扩展一点:System.out其实就是一个JDK当中已经创建好的对象,而println就是System.out对象当中的成员方法 * * 对象名::成员方法名 * System.out.println * * 小结: * 1.一定要有函数式接口,才能使用Lambda. * 2.对于重复的Lambda场景,可以使用方法引用来进行简化. */ public class Demo03Monitor { public static void main(String[] args) { //首先使用Lambda,间接调用println方法 useMonitor( (String str) -> {System.out.println(str);} ); //使用方法引用,直接交给了println方法引用去处理 useMonitor(System.out::println); } public static void useMonitor(Monitor monitor) { monitor.show("Hello,World!"); } }
Stream流
集合for遍历的冗余场景
import java.util.ArrayList; /* * 题目: * 有一个集合里面存放的字符串,样子如:"赵丽颖,98","鹿晗,95","宋小宝,87" * 要求打印输出所有成绩当中大于90分的数字. * * 分析: * 1.首先定义一个集合ArrayList.存入指定格式的若干个字符串. * 2.我们只想要逗号后面的,那么就要分割字符串:split,然后取用结果数组当中的1号元素 * 3.根据字符串切割出来的"98"仍然是一个String,需要转换成为int:Interger.parseInt静态方法 * 4.要判断一下转换之后的int是不是大于90,筛选 * 5.对筛选之后的最终结果进行打印输出. */ public class Demo01ArrayList { public static void main(String[] args) { //首先创建一个集合,然后放入指定格式的字符串 ArrayList<String> recordList = new ArrayList<>(); recordList.add("赵丽颖,98"); recordList.add("鹿晗,95"); recordList.add("宋小宝,87"); //应该拆分一下每个字符串,只要逗号后面的 ArrayList<String> scoreList = new ArrayList<>(); //保存的多个字符串是:"98","95","87" for (int i = 0; i < recordList.size(); i++) { String record = recordList.get(i); //当前字符串:"赵丽颖,98" String[] array = record.split(","); String score = array[1]; //"98" scoreList.add(score); } //将字符串"98"转换成为int数字98 ArrayList<Integer> numList = new ArrayList<>();//保存的多个数字是:98,95,87 for(int i = 0;i < scoreList.size();i++) { String score = scoreList.get(i); //"98" int num = Integer.parseInt(score); numList.add(num); } //过滤一下,筛选,只要大于90的,小于等于90的不要 ArrayList<Integer> resultList = new ArrayList<>(); //最终结果集合 for(int i = 0;i < numList.size();i++) { int num = numList.get(i); //98 if(num > 90) { resultList.add(num); } } //最后遍历最终结果集合,打印输出 for(int i = 0; i < resultList.size();i++) { int result = resultList.get(i); System.out.println(result); } } }
体验Stream的更优写法
import java.util.ArrayList; /* * 题目: * 有一个集合里面存放的字符串,样子如:"赵丽颖,98","鹿晗,95","宋小宝,87" * 要求打印输出所有成绩当中大于90分的数字. * * 分析: * 1.首先定义一个集合ArrayList.存入指定格式的若干个字符串. * 2.我们只想要逗号后面的,那么就要分割字符串:split,然后取用结果数组当中的1号元素 * 3.根据字符串切割出来的"98"仍然是一个String,需要转换成为int:Interger.parseInt静态方法 * 4.要判断一下转换之后的int是不是大于90,筛选 * 5.对筛选之后的最终结果进行打印输出. */ public class Demo01ArrayList { public static void main(String[] args) { //首先创建一个集合,然后放入指定格式的字符串 ArrayList<String> recordList = new ArrayList<>(); recordList.add("赵丽颖,98"); recordList.add("鹿晗,95"); recordList.add("宋小宝,87"); //Stream API更优写法! recordList.stream().map(s -> s.split(",")[1]).map(Integer::parseInt) .filter(n -> n > 90).forEach(System.out::println); } }
思想概述
获取Stream流的常用方式
import java.util.ArrayList; import java.util.stream.Stream; /* * Java 8当中的"流"其实就是Stream接口的对象. * JDK提供了一个流接口:java.util.stream.Stream<T> * * 如何获取流? * 1.根据集合获取流:集合名称.stream() * 2.根据数组获取流:Stream.of(数组名称) */ public class Demo03GetStream { public static void main(String[] args) { //1.根据集合获取流 ArrayList<String> list = new ArrayList<>(); list.add("迪丽热巴"); list.add("古力娜扎"); list.add("玛尔扎哈"); Stream<String> streamA = list.stream(); //2.根据数组获取流,数组当中的元素必须是引用类型才行 String[] arrayStr = {"Hello","World","Java"}; Stream<String> streamB = Stream.of(arrayStr); Integer[] arrayInteger = {10,20,30}; Stream<Integer> streamC = Stream.of(arrayInteger); } }
map映射方法
/* * 获取流之后,可以使用映射方法:map(用于转换的Lambda表达式) * * 映射:就是将一个对象转换成为另一个对象,把老对象映射到新对象上. * * "赵丽颖,98" 转换成为 "98" 将一个长字符串转换成为一个短字符串 * "98" 转换成为 98 将一个字符串转换成为一个int数字 */ public class Demo04StreamMap { public static void main(String[] args) { //这个集合当中存放的是字符串类型 ArrayList<String> list = new ArrayList<>(); list.add("100"); list.add("200"); list.add("300"); Stream<Integer> steramA = list.stream().map((String str) -> { int num = Integer.parseInt(str); return num; }); Stream<Integer> steramB = list.stream().map(str -> { int num = Integer.parseInt(str); return num; }); Stream<Integer> steramC = list.stream().map((String str) -> { return Integer.parseInt(str); }); Stream<Integer> steramD = list.stream().map(Integer::parseInt); System.out.println("=========================="); ArrayList<String> list2 = new ArrayList<>(); list2.add("赵丽颖,98"); list2.add("鹿晗,95"); list2.add("宋小宝,87"); Stream<String> stream1 = list2.stream().map((String str) -> { String[] array = str.split(","); String result = array[1]; return result; }); Stream<String> stream2 = list2.stream().map(s -> { String[] array = s.split(","); String result = array[1]; return result; }); Stream<String> stream3 = list2.stream().map(s -> { String[] array = s.split(","); return array[1]; }); Stream<String> stream4 = list2.stream().map(s -> { return s.split(",")[1]; }); Stream<String> stream5 = list2.stream().map(s -> s.split(",")[1]); } }
filter过滤方法
import java.util.ArrayList; import java.util.stream.Stream; /* * 如果希望对流当中的元素进行过滤,可以使用过滤方法: * * filter(能产生boolean结果的Lambda):如果参数Lambda生产了true,则要元素;如果产生了false,则不要元素. */ public class Demo05SteramFilter { public static void main(String[] args) { ArrayList<Integer> list1 = new ArrayList<>(); list1.add(90); list1.add(85); list1.add(60); Stream<Integer> stream1 = list1.stream().filter((Integer num) -> { boolean b = num > 80; return b; }); Stream<Integer> stream2 = list1.stream().filter(num -> { boolean b = num > 80; return b; }); Stream<Integer> stream3 = list1.stream().filter(num -> { return num > 80; }); Stream<Integer> stream4 = list1.stream().filter(num -> num > 80); System.out.println("=========================="); ArrayList<String> list2 = new ArrayList<>(); list2.add("赵丽颖"); list2.add("赵丽颖"); list2.add("宋小宝"); Stream<String> streamA = list2.stream().filter((String str) -> { // boolean b = "赵丽颖".equals(str); boolean b = str.equals("赵丽颖"); return b; }); Stream<String> streamB = list2.stream().filter(str -> { boolean b = str.equals("赵丽颖"); return b; }); Stream<String> streamC = list2.stream().filter(str -> { return str.equals("赵丽颖"); }); Stream<String> streamD = list2.stream().filter(s -> s.equals("赵丽颖")); } }
forEach遍历方法
import java.util.ArrayList; import java.util.stream.Stream; /* * 如果希望在流当中进行元素的遍历操作,可以使用forEach方法: * * forEach(Lambda表达式):意思是,对流当中的每一个元素都要进行操作. * 参数Lambda表达式必须是一个能够消费一个参数,而且不产生数据结果的Lambda. * * 例如: * Lambda: s -> System.out.println(s); * 方法引用: System::println */ public class Demo06SteramForEach { public static void main(String[] args) { ArrayList<String> list = new ArrayList<>(); list.add("迪丽热巴"); list.add("古力娜扎"); list.add("玛尔扎哈"); Stream<String> streamA = list.stream(); streamA.forEach((String str) -> { System.out.println(str); }); System.out.println("================"); list.stream().forEach((String str) -> { System.out.println(str); }); System.out.println("================"); list.stream().forEach(str -> { System.out.println(str); }); System.out.println("================"); list.stream().forEach(System.out::println); } }
并发的Stream流
import java.util.ArrayList; /* * 流当中的元素如果特别多,那么只有一个人在逐一,挨个儿处理,肯定比较慢,费劲. * 如果对流当中的元素,使用多个人同时处理,这就是"并发". * * 如何才能获取"并发流"(支持并发操作的流): * .parallelStream() * * 注意事项: * 1.使用并发流操作的时候,到底有几个人进行同时操作呢?不用管,JDK自己处理. * 2.只要正确使用,就不会出现多个人抢到同一个元素的情况. * 3.如果已经获取了一个普通的流,那么只要再调用一下parallel()方法也会变成并发流. * * 总结: * 1.直接获取并发流: .parallelStream() * 2.已经获取了普通流,然后升级成为并发流: .stream().parallel() */ public class Demo07StreamParallel { public static void main(String[] args) { ArrayList<String> list = new ArrayList<>(); for (int i = 1; i <= 100; i++) { list.add("Hello-" + i); } //这是只有一个人在做打印输出的操作 // list.stream().forEach(System.out::println); //获取一个并发流 // list.parallelStream().forEach(System.out::println); //如果已经获取了一个普通的流,那么只要再调用一下parallel()方法也会变成并发流 list.stream().parallel().forEach(System.out::println); } }
模块化
思想概述
可以解决的问题
认识module-info.java文件
在Java的一个模块中，需要使用module-info.java文件描述模块信息。
将Eclipse项目改造为模块
可以通过下面的操作将Eclipse的Java Project改造成一个Java9的模块：
1. 点击项目名称，右键选择Configure，点击 Create module-info java 选项。
2. 在生成的module-info.java文件中编写导出exports和依赖requires等信息。
3. 点击项目名称，右键选择Build Path，点选最后一项Configure Build Path。在Projects
标签中选中Modulepath，然后右侧Add所需要依赖的模块。
1. 创建
2. 名字输入
3. 如果有其它模块依赖我,那么其他模块下面的3个包都可以访问
4. 可以访问谁不可以访问谁
设置模块间的依赖关系
知识总结
1. 对比一下静态方法与成员方法的区别：
a） 静态方法与对象无关，可以直接通过类名称调用：
类名称.静态方法名（参数值）；
b） 成员方法一定要有对象才能使用：
对象名.成员方法名（参数值）；
2. 方法引用：如果Lambda表达式想做的事情，在某一个地方某一个方法已经做过了，那么就可以使用方法引用来替代Lambda。
3. 方法引用的方式：
a）通过类名称引用静态方法：类名称::静态方法名
b）通过对象名引用成员方法：对象名::成员方法名
4. Stream 流式思想：简化了普通的集合操作，类似于流水线。Stream流在Java当中就是一个java.util.stream.Stream<T>接口的对象。.
a）如何获取流：
i. 通过集合获取：集合名称stream()
ii. 通过数组获取：Stream.of(数组名称）注意，数组当中必须是引用类型元素
b）映射的方法：map，参数是一个负责转换的Lambda表达式
c）过滤的方法：filter，参数是一个可以产生boolean结果的Lambda表达式
d）遍历的方法：forEach，参数也是一个Lambda，Lambda对应的抽象方法应该只有一个参数并且不产生返回值。
e）如何获取并发流
i. 直接一次性获取并发流：.parallelStream(）
ii. 首先获取普通流，然后继续变成并发流：.stream().parallel()
5. 模块化思想可以为我们带来两点好处:
a） 整体一整个，文件体积太大。如果只是用到了其中的一部分内容，就会浪费。
b） 精确控制package包级别的访问控制。只有导出的包，模块之外才可以访问，否则只能模块内部自己访问。
c） 模块的描述信息module-info.java文件的基本内容：
module本模块的名称{
exports导出的包名称；
requires需要依赖的其他模块名称;
}
