JAVA
1只要是字符串，必然就是对象。
2API文档的基本使用
3如何创建字符串：
a直接赋值双引号，也是一个字符串对象。
b可以通过new关键字来调用String的构造方法
public String(char[] array)根据字符数组来创建字符串
public String(char[] array,int offset,intcount):根据字符数组当中一部分来创建字符串
4字符串池：为了节省内存，重复利用相同的字符串。
FileWriter
/*
* 如果需要将数据写到纯文本文件中，那么可以使用FileWriter类
*
* 1导包
* import java.io.FileWriter;
*
* 2创建，构造方法
* public FileWriter(String fileName);参数字符串就是文件的路径名称
* FileWriter fw = new FileWriter("file01.txt");
* 文件扩展名只能决定默认用什么软件打开文件，不能决定其内容
*
* 3使用成员方法
* 写数据 public void write(String str) 参数就是需要写到文件中的字符串
* 关闭流 public void close(); 关闭释放资源
*
* 总结一下： FileWriter基本使用步骤 创 写 关
*
*
* 注意：1注意第三步 2创建的时候提示有异常，那么就悬停，然后点击Add throws...即可
*/
案例
//需要将字符串转换成一个Hero对象
//首先将一个完整的字符串切分成若干个小段
String[] array = line.split(",");
String name = array[0];//姓名
//如何将字符串类型"100"转化成int 100
int attack = Integer.parseInt(array[1]);//攻击力
String type = array[2];//类型
//根据三条信息创建一个英雄对象
Hero hero = new Hero(name,attack,type);
list.add(hero);//添加到集合当中
写 BufferedWriter br = new BufferedWriter(new FileWriter("friends.txt"));
读 BufferedReader br = new BufferedReader(new FileReader("friends.txt"));
Lambda表达式
一
method((a,b) ->a + b);
//调用方法的时候，参数类型是函数式接口，所以Lambda可以判断出是哪个接口
Lambda表达式 (a,b) ->a + b
method方法需要一个Calculator接口类型参数
Lambda表达式就是充当了Calculator接口类型的参数
1 Lambda表达式前面的小括号，其实就是接口抽象方法的小括号。
2 箭头代表拿着小括号的数据做什么事情，是一个指向动作
3 箭头后面代表拿到了参数之后做什么事情
Lambda表达式的语义本身代表了怎么做这件事，没有对象的概念在里面（更加简单直观）
* java当中使用Lambda表达式的前提是：必须有"函数接口"
* 概念：有且仅有一个抽象方法的接口，叫做函数式接口"
* 如何才能万无一失的检测一下当前的接口是不是函数式接口：
* 用一个固定的格式写在public interface之前一行即可：
* @FunctionalInterface
* public interface 函数接口名{
* }
public static void method(Calculator calculator) {
int result = calculator.sum(20,10);
System.out.println("结果是：" + result);
}
public static void main(String[] args) {
method((a,b) ->a + b);
}
二
* Lambda表达式要想使用，一定有函数接口的推断环境
* 1 要么通过方法的参数类型来确定是哪个函数接口
* 2 要么通过赋值操作来确定是哪个函数式接口
*
* Lambda的格式就是为了将抽象方法，翻译成以下三点
* 1 一些参数（方法参数）
* 2 一些箭头
* 3 一些代码（方法体）
*
* 例如抽象方法
* public abstract int(int a,int b);
* 翻译成Lambda
* (a,b) -> {return a + b;}
//在Lambda表达式中凡是可以推到的都是可以省略的
//全的 method( (int x) -> {return x++;} );
//1 Lambda表达式中参数类型可以不写 method( (x) -> {return x++;} )
//2 如果参数只有一个那么小括号可以省略 method( x -> {return x++}; )
//3 如果语句只有一个，那么大括号和return也可以省略 method( x -> x++);
//方法引用
hirSitter( food -> System.out.println("将" + food + "做成可口的食物") );
hirSitter( Cook::makeFood );
三
* System.out其实就是一个JDk当中已经创建好的对象而println及时system.out 对象当中的成员方法
*
* 使用方法引用更简单
* 对象名::成员方法名 System.out::println
public static void main(String[] args) {
//首次使用Lambda 间接调用println方法
useMonitor((String str) -> {System.out.println(str);});
//使用方法引用直接交给了println
useMonitor(System.out::println);
/*
* 小结：
* 1 一定要有函数式接口，才能使用Lambda
* 2 对于重复的Lambda场景，可以使用方法引用来进行简化
*/
}
public static void useMonitor(Monitor monitor) {
monitor.show("Hello");
}
Stream流 流式思想
一
* 题目：
* 有一个集合里面存放的字符串， 样如："赵丽颖，98","鹿晗，90"，"宋小宝,87"。。。。。
* 要求打印输出所有成绩当中大于90分的数字
*
* 1 分析定义一个集合ArrayList，存入指定格式的若干个字符串。
*2 我们只想要逗号后面的，那么就要分割字符串：split，然后取结果当中的1号元素
*3 根据字符串切割出来的"98" 仍然是一个String 需要需要转换成int才能比较大小Inter.ParseInt静态方法
*4 判断转换后的int是否大于90 筛选
*5 筛选之后的最终进行打印输出
//Stream API更优写法 题目简便答案
recorList.stream().map(s ->s.split(",")[1]).map(Integer::parseInt)
.filter(n -> n>90).forEach(System.out::println);
二获取流
* Java8中的"流"，其实就是Steam接口的对象
* JDK提供了一个接口：java.util.stream.Stream<T> 底层比集合还要高等
*
* 如何获取流
* 1 根据集合获取流 集合名称.stream();
* 2 根据数组获取流 Stream.of(数组名称);//根据接口获取流
ArrayList<String> list = new ArrayList<>();
list.add("迪丽热巴");
list.add("古力娜扎");
list.add("马尔扎哈");
Stream<String> streamA = list.stream();
//根据数组获取流 数组当中的元素必须是 引用类型才行
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数字
* map方法它的参数是函数是接口的Lambda表达式
*/
ArrayList<String> list = new ArrayList<>();
list.add("100");
list.add("120");
list.add("135");
list.add("143");
Stream<Integer> streamA = list.stream().map((String str)->{
int num = Integer.parseInt(str);return num;});
Stream<Integer> streamB = list.stream().map((str)->{
int num = Integer.parseInt(str);return num;});
Stream<Integer> streamC = list.stream().map((String str)->{
return Integer.parseInt(str);});
Stream<Integer> streamD = list.stream().map(Integer::parseInt);
ArrayList<String> list2 = new ArrayList<>();
list2.add("赵丽颖,98");
list2.add("李八,99");
list2.add("宋小宝,80");
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过滤
/*
* 如果希望对流当中的元素进行过滤，可以使用过滤的方法
* filter(能产生boolean结果的Lambda表达式) 如果Lambda表达式产生了true，则取元素；如果产生了false，则不要元素。
*/
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
);
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(s -> {
boolean b = s.equals("赵丽颖");
return b;
});
Stream<String> streamC = list2.stream().filter(s -> {
return s.equals("赵丽颖");
});
Stream<String> streamD = list2.stream().filter(s -> s.equals("赵丽颖"));
五forEach
/*
* 遍历：如果需要再流当中进行元素的遍历，可以使用forEach方法：
* forEach(Lambda表达式) 意思是，对流当中每一个元素到要进行操作
* 参数的Lambda表达式必须是能够消费一个参数，而且不产生数据结果的Lambda。
* 例如打印输出
* 例如 Lambda： s -> System.out.println(s);
* 方法引用: System::println;
*/
ArrayList<String> list = new ArrayList<>();
list.add("迪丽热巴");
list.add("古力娜扎");
list.add("马尔扎哈");
Stream<String> streamA = list.stream();
streamA.forEach((String str) -> {System.out.println(str);});
list.stream().forEach((String str) -> {System.out.println(str);});
list.stream().forEach(s -> {System.out.println(s);});
list.stream().forEach(System.out::println);
六并发流
/*
* 若果流当中元素特别多， 那么只有一个人在逐一、挨个处理，肯定比较慢，费劲
* 如果对流当中的元素，使用多个人同时处理，这就是"并发"
* 如何获取“并发流”(支持并发操作的流)
* .parallelStream()
* 注意事项
* 1 使用并发流操作的时候，到底有几个人同时进行操作呢？不用管，JDK自己处理。（Frok/Join框架）
* 2 正确使用，就不会出现多个人抢到同一个元素的情况。
* 3 如果已经获取一个普通流，那么只要在调用一下parlle方法也会变成并发流。
*/
ArrayList<String> list = new ArrayList<>();
for(int i = 0;i<=100;i++) {
System.out.println("Hello-" + i);
}
//这是只有一个人在做打印操作
//list.stream().forEach(System.out::println);
//获取一个并发流
//list.parallelStream().forEach(System.out::println);
//如果已经获取一个普通流，那么只要在调用一下parallel方法也会变成并发流。
list.stream().parallel().forEach(System.out::println);
模块化
module demo{
//如果有其他模块依赖我，那么其他模块下面的三个包可以访问（导出包）
exports com.xin.Test;
exports com.xin.Pojo;.
exports com.xin.Qita;
//我需要依赖其他模块，
requires book;
//有机项目名称 Build path à Configure Build Path 在Project 第一项 Modulepath Add 用那个模块√哪个
}