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);
//如果已經獲取一個普通流，那麽只要在調用一下parlle方法也會變成並發流。
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 用那個模塊√哪個
}
java隨堂筆記