java随堂笔记

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       用那个模块√哪个

}