1.Map的改造、方法區的新實作以及介面的新規定
map的新實作
這個其實大家面試經常會遇到，但是其實也比較簡單，記住就ok了
（1）Map的底層由陣列加鏈表的方式改為了陣列加鏈表加紅黑樹的實作方式
（2）對key進行hash，然后再根據陣列長度取余之后的鏈表的頭插法改為了尾插法
（3）ConcurrentHashMap由原來的分段加Hashtable的實作方式，變為了跟Map一樣的方式，只是資料的執行緒安全采用了cas鎖的機制
鏈表改紅黑樹的條件是鏈表的長度超過8，原因是，鏈表長度過長時，查詢效率會變低，而紅黑樹的本質則是一棵有序的二叉樹，而二叉樹的遍歷分為三種方式，左中右，中左右，右中左，具體采用的哪種遍歷方式沒關注，但是不管具體采用哪種方式，遍歷不需要經過所有節點，每經過一個節點，就減少了差不多一半的元素的被命中的可能性，查詢的性能會變得很高，而相應的插入的性能就變低了，
方法區的新實作
另外就是方法區的實作由堆的一塊固定的記憶體稱為永久代，轉變為了元空間，且采用的是物理機器的記憶體，這個轉變的可能原因是因為，永久代本身發生垃圾回收的概率極為苛刻，另外永久代其實主要存盤的是我們的代碼編譯之后加載進記憶體的匯編指令和常量池，這一塊兒可能發生變動比較少以及垃圾回收能節省的空間幾乎可以忽略，所以就移出來了吧，
介面的新規定
介面可以有具有實作體的方法了，但必須制定為默認方法，關鍵字為：default
注意事項：
- (1) 當子類繼承的類和實作的介面的默認方法，有同名方法時，優先呼叫繼承父類的具體實作
- (2)當子類實作多介面時，多介面存在同名默認方法時，子類必須實作默認方法，指定呼叫的具體默認方法
2.Lambda函式式編程以及新符號(::)的方法呼叫
lambda運算式其實解決的是個匿名函式的問題，另外還給我們總結了四種型別的介面，不用我們的代碼中去定義那么多其實并沒有實際實作的java介面檔案，直接采用默認的這四種型別的介面以及他們的子類即可
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;
/**
* Lambda語法總結
* 通用寫法： 一句處理代碼的情況下 () -> code;
* 多句話的情況下 () -> {} ;
* 函式shi介面有四種：
* 1.消費型介面：Consumer（T t） 無回傳值
* 2.供給型介面：Supplier(T) 無引數，有回傳值
* 3.函式型介面：Function(T,R) 有引數且需要回傳值的介面
* 4.判斷型介面：Predicat(T) 回傳True/False
*/
public class LambdaTest {
public static void main(String[] args){
/* // 原寫法
Comparator<Integer> com = new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
return Integer.compare(o1,o2);
}
};
TreeSet<Integer> treeSet = new TreeSet<>(com);
// lambda寫法
Comparator<Integer> comparator = (x ,y) -> Integer.compare(x,y);
TreeSet<Integer> treeSetComparator = new TreeSet<>(comparator);*/
Consumer<Integer> consumer = x -> System.out.println("consumer:"+x);
consumer.accept(1);
Supplier<Integer> supplier = () -> 1;
Integer i = supplier.get();
System.out.println("supplier:"+i);
Function<Integer,Integer> function = x -> x+1;
Integer fi = function.apply(1);
System.out.println("function:"+fi);
Predicate<Integer> predicate = x -> x > 0;
boolean pFlag = predicate.test(1);
System.out.println("predicate:"+pFlag);
}
}
方法的呼叫：采用新的運算子
::
,這其實是對函式式編程的一種支持，進一步降低lambda的代碼量
import java.io.PrintStream;
import java.util.Collections;
import java.util.List;
import java.util.function.BiPredicate;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Supplier;
/**
* 方法的呼叫：采用新的運算子(::),這其實是對函式式編程的一種支持，進一步降低lambda的代碼量
* ::用法又分為以下幾種：
* 1. 實體物件 :: 實體方法名
* 2. 類名 :; 靜態方法名
* 3. 類名 :: 實體方法名
* 建構式其實也是：類名 :: new
* 陣列的構造：類名[] :: new
* 注意點：
* 1.方法的引數以及回傳值的確定是由你定義接收的函式式介面來進行推斷得到的
* 2.呼叫多載的方法時，由你定義的函式式介面的引數型別來推斷的，也就是你要呼叫的
* 方法的引數串列必須跟函式式介面定義的引數串列一直
* 3.類名 :: 實體方法這種呼叫方式其實是對于引數中有一個是實體方法的呼叫者時使用的，比如equlas方法
*/
public class MethodCalledTest {
public static void main(String[] args){
// 1.實體物件 :: 實體方法名
Consumer<String> consumer = (x) -> System.out.println(x);
PrintStream out = System.out;
Consumer<String> consumer1 = out::println;// 實際使用經常為System.out::println
// 2. 類名 :: 靜態方法名
List<Integer> list = Collections.emptyList();
Supplier<List<Integer>> supplier = Collections::emptyList;
list = supplier.get();
// 2. 類名 :: 實體方法名
BiPredicate<String,String> biPredicate = (x,y) -> x.equals(y);
biPredicate = String::equals;
// 構造方法的使用 ClassName :: new
Supplier<String> supplier1 = String::new;
Function<String,String> function = String::new;// 呼叫String的有參建構式
// 陣列 類名[] :: new
Function<Integer,String[]> function1 = String[]::new;
String[] array = function1.apply(10);// Integer 為陣列長度
}
}
3.Stream 流式操作
Stream Api 通過一個管道對集合和陣列進行一系列的操作
-
stream() ： 串行流,資料處理是一個個進行的，執行緒安全 -
parallelStream() ：并行流，資料處理是多執行緒處理的，執行緒不安全，但是大資料量情況下，性能好，實作方式，其實就是Fork/Join框架的方式，充分利用多核的cpu - Stream Api 包含三個步驟：
- 1.創建流
- 2.流式操作
- 3.終止操作
- 流有三個特點：
-
1.Stream本身不存盤元素 -
2.Stream不會改變源物件，它的操作都會回傳一個持有結果的新的Stream物件 -
3.Stream操作是延遲執行的，它只有等到終止操作時才會去真正的進行計算，稱為“惰性求值”
創建流的方式：
/**
* 創建流有四種方式
* 1.通過集合本身提供的stream（）或者parallelStream()方法創建
* 2.通過Arrays的靜態方法Arrays.stream(T t)創建
* 3.通過Stream類本身的靜態方法 Stream.of("aa","bb","cc")創建
* 4.無限流有兩種創建方式
* 1）迭代創建流Stream.iterate(0,x -> x+2),需要一個引數和一個有引數有回傳值的lambda運算式
* 2）生成創建流 Stream.generate(() -> Math.random()),需要一個供給型的lambda的運算式
*/
public void createStream(){
// 1.通過Collection集合的stream()或者parallelStream() 創建流
List<String> list = new ArrayList<>();
Stream<String> stream1 = list.stream();
Stream<String> parallelStream = list.parallelStream();
// 2.通過Arrays的靜態方法stream()，創建流
String[] strArray = new String[]{};
Stream<String> stream2 = Arrays.stream(strArray);
// 3.通過Stream類本身的靜態方法of創建
Stream<String> stream3 = Stream.of("a","b","c");
// 4.無限流
Stream<Integer> stream4 = Stream.iterate(0,x -> x +2 );
Stream<Double> stream5 = Stream.generate(() -> Math.random());
}
流水線的操作：
篩選與切片
/**
* 1.篩選與切片
* (1)filter - 接収一個斷言型別的lambda，過濾掉不滿足的條件的元素
* (2)limit(n) - 截斷流，收集不超過給定數量的元素，收集滿了就不繼續進行了
* （3）skip(n) - 跳過元素，回傳一個丟掉了前n個元素的流，若元素不足n個回傳空流，與limit互補
* （4）distinct - 篩選去掉重復元素，篩選通過的是元素的hashCode()和equals()方法
*/
public void opreateStream1(){
List<Integer> list = Arrays.asList(1,0,3,2,6,5,4);
// filter - 接収一個斷言型別的lambda，過濾掉不滿足的條件的元素
Stream stream = list.stream()
.filter(x -> {
// 可以注釋掉stream.forEach,可以看到這個列印不執行
// 這個就是我們說的惰性求值，只有收集結果才執行中間操作
System.out.println(x);
return x > 0;
});
stream.forEach(System.out :: println);
// limit(n) - 截斷流，收集不超過給定數量的元素，收集滿了就不繼續進行了
list.stream()
.filter(x -> {
// 這里除了上面的還可以看到斷路器的作用，找到了滿足條件的結果，后面的就不執行了
System.out.println(x);
return x > 0;
}).limit(1).forEach(System.out :: println);// 終止操作才能看到結果
// skip(n) - 跳過元素，回傳一個丟掉了前n個元素的流，若元素不足n個回傳空流，與limit互補
list.stream()
.filter(x -> x > 0)
.skip(2)
.forEach(System.out :: println);
// distinct - 篩選去掉重復元素，篩選通過的是元素的hashCode()和equals()方法
list.stream()
.filter(x -> x > 0)
.distinct()
.forEach(System.out :: println);
}
映射
/**
* 2.映射
* (1)map - 接収一個函式型介面的lambda，應用于每個元素，并回傳一個新的元素，最侄訓傳一個流
* (2)flatMap - 接收一個函式作為引數，將該函式應用于每個元素上并回傳一個流，每個元素產生的流再組合在一起產生一個新流回傳
*/
public void opreateStream2(){
List<String> list = Arrays.asList("1","0","3","2");
// map - 接収一個函式型介面的lambda，應用于每個元素，并回傳一個新的元素
List<Integer> list1 = list.stream()
.map(str -> Integer.valueOf(str)) // 將String轉換成為了Integer
.collect(Collectors.toList());
// flatMap - 接收一個函式作為引數，將該函式應用于每個元素上并回傳一個流，每個元素產生的流再組合在一起產生一個新流回傳
List<String> listList = Arrays.asList("abc","bcd");
List<Stream<Character>> characterListList = listList.stream()
.map(StreamTest :: getElementChar) // 結果為{{a,b,c},{b,c,d}}
.collect(Collectors.toList()); // 收集結果為一個流的集合
List<Character> characterList = listList.stream()
.flatMap(StreamTest :: getElementChar) // 結果為{a,b,c,b,c,d}
.collect(Collectors.toList()); // 收集結果為一個char的集合
}
public static Stream<Character> getElementChar(String str){
List<Character> characters = new ArrayList<>();
for (Character c: str.toCharArray()) {
characters.add(c);
}
return characters.stream();
}
排序
/**
* 3.排序
* (1)sorted - 自然排序，按照每個元素物件內部實作的CompareTo方法排序
* (2)sorted(Comparator m) - 定制排序，接收一個比較器的匿名函式，按照匿名函式的比較方法排序
*/
public void opreateStream3(){
List<Integer> list = Arrays.asList(1,0,3,2);
// sorted - 自然排序，按照每個元素物件內部實作的CompareTo方法排序
list.stream()
.sorted()
.forEach(System.out::println);
// sorted(Comparator m) - 定制排序，接收一個比較器的匿名函式，按照匿名函式的比較方法排序
list.stream()
.sorted((x ,y) -> {
if(x < y){
return y;
}else {
return x;
}
})
.forEach(System.out::println);
}
終止操作：
查找與匹配
/**
* 查找與匹配
* (1)allMatch - 接收一個斷言lambda運算式，判斷是否所有元素都滿足這個斷言
* (2)anyMatch - 接收一個斷言lambda運算式，判斷是否至少有一個元素滿足這個斷言
* (3)noneMatch - 接收一個斷言lambda運算式，判斷是否所有元素都不滿足這個斷言
* (4)findFirst - 查找第一個元素，回傳一個Optional，防止空指標
* (5)findAny - 查找任意一個元素，回傳一個Optional，防止空指標
* (6)count - 回傳流中元素的個數
* (7)max - 回傳流中元素的比較的最大的結果
* (8)min - 回傳流中元素的比較的最小的結果
*/
public void finishStream(){
List<Integer> list = Arrays.asList(1,0,3,2);
// allMatch - 接收一個斷言lambda運算式，判斷是否所有元素都滿足這個斷言
boolean flag = list.stream()
.allMatch(x -> x > 2);
System.out.println(flag);
// anyMatch - 接收一個斷言lambda運算式，判斷是否至少有一個元素滿足這個斷言
boolean flag1 = list.stream()
.anyMatch(x -> x > 2);
System.out.println(flag1);
// noneMatch - 接收一個斷言lambda運算式，判斷是否所有元素都不滿足這個斷言
boolean flag2 = list.stream()
.noneMatch(x -> x > 2);
System.out.println(flag2);
// findFirst - 查找第一個元素，回傳一個Optional，防止空指標
Optional<Integer> optional =list.stream()
.filter(x -> x >2)
.findFirst();
System.out.println(optional.get());
// findAny - 查找任意一個元素，回傳一個Optional，防止空指標
Optional<Integer> optional1 =list.stream()
.filter(x -> x >2)
.findAny();
System.out.println(optional1.get());
// count - 回傳流中元素的個數
long count =list.stream()
.filter(x -> x >2)
.count();
System.out.println(count);
// max - 回傳流中元素的比較的最大的結果
Optional<Integer> optional2 = list.stream()
.max((x ,y) -> {
if(x < y){
return y;
}else {
return x;
}
});
System.out.println(optional2.get());
}
規約
map和reduce通常進行連接使用，稱為map-reduce模式，大資料的處理，經常使用這種模式
/**
* 規約
* (1)reduce - reduce(T identity, BinaryOperator<T> accumulator) 第一個引數為起始指定值，且identity做為二元運算
* 的T引數進行一個運算式的運算的結果作為二元運算的T進行下一次計算，直到流中元素全部處理完
* (2)reduce - Optional<T> reduce(BinaryOperator<T> accumulator)無起始值，直接計算結果
*/
public void finishStream1(){
List<Integer> list = Arrays.asList(1,0,3,2);
/**
* reduce - reduce(T identity, BinaryOperator<T> accumulator) 第一個引數為起始指定值，且identity做為二元運算
* 的T引數進行一個運算式的運算的結果作為二元運算的T進行下一次計算，直到流中元素全部處理完
*
*/
Integer sum = list.stream()
.reduce(0,(x,y) -> x+y);
System.out.println(sum);
/**
* reduce - Optional<T> reduce(BinaryOperator<T> accumulator)
* 無起始值，直接計算結果
*/
Optional<Integer> optional = list.stream()
.reduce((x,y) -> x+y);
System.out.println(optional.get());
}
收集
/**
* 收集
* (1)Collector - 接收Collector介面的匿名函式，進行流的元素的收集
*/
public void finishStream2(){
List<Integer> list = Arrays.asList(1,0,3,2,1,2);
// Collector - Collectors.toList()
List<Integer> list1 = list.stream()
.filter(x -> x > 1)
.collect(Collectors.toList());
// Collector - Collectors.toSet()
Set<Integer> set = list.stream()
.filter(x -> x > 1)
.collect(Collectors.toSet());
// Collector - Collectors.toCollection()
HashSet<Integer> set1 = list.stream()
.filter(x -> x > 1)
.collect(Collectors.toCollection(HashSet::new));
// Collector - Collectors.counting() 元素總個數
long count = list.stream()
.filter(x -> x > 1)
.collect(Collectors.counting());
// Collector - Collectors.averagingDouble() 元素的平均值
Double aDouble = list.stream()
.filter(x -> x > 1)
.collect(Collectors.averagingDouble(x -> Double.valueOf(x)));
// Collector - Collectors.maxBy() 最大值
Optional<Integer> integer = list.stream()
.filter(x -> x > 1)
.collect(Collectors.maxBy(Integer::compare));
// Collector - Collectors.minBy() 最小值
Optional<Integer> integer1 = list.stream()
.filter(x -> x > 1)
.collect(Collectors.minBy(Integer::compare));
// Collector - Collectors.groupingBy() 分組
// Collector - Collectors.partitioningBy() 磁區
// Collector - Collectors.summarizingDouble() 總結 可以獲取平均值，最大最小值等
// Collector - Collectors.joining() 連接
}
4.Optipnal防止空指標的新的api類
- Optional容器類：為了解決空指標例外而存在的
- Optional容器類并不能避免空指標的問題，但是能快速定位到空指標的位置，并且將常見的一些空判斷放入到容器中,如果判斷層次夠深，則將if，換成.后面是Optional的各種方法這樣代碼比較整齊
- 常用方法：
-
(1) Optional.of(T value) value不能為空，為空直接拋空指標例外 -
(2) Optional.empty() 創建一個空的容器，呼叫optional.get()拋空指標例外 -
(3)Optional.ofNullable(T value) 當value為空的時候，呼叫optional.get()拋空指標例外 -
(4)Optional.isPresent() 判斷容器中是否有值 -
(5)optional.orElse(T value) 當容器中沒有值的時候，創建一個value的默認值，回傳的也是這個默認值,有則回傳容器中的值 -
(6)optional.orElseGet(Suplier s) 容器中有值回傳值，沒值進行函式式介面處理 -
(7)optional.map(Function t) 當容器中有值進行函式的處理，回傳處理后的值，沒有值，回傳一個空的容器Optional.empty() -
(8)optional.flatMap(Function map) 與map類似，但是回傳值一定是Optional
5.新的日期時間Api
新的時間Api
- 區別：
-
原時間Api，執行緒不安全，并且有背于我們常用的時間，故新的時間api全部放在了Java.time包下且采用了統一的國際標準 - 常用的類：
-
（1）LocalDateTime/LocalDate/LocalTime 三者的方法與實體化一致 -
（2）Instant:時間戳（以Unix元年<1970-01-01 00:00:00>開始到指定時間的毫秒值） -
（3）duration 計算時間差值的類 -
（4）Period 計算日期差值的類 -
（5）TemporalAdjuster時間校正器 計算一個特殊的時間,TemporalAdjusters 提供很多常用的操作，比如下一個作業日 -
（6）DateTimeFormatter 時間/日期格式化器,DateTimeFormatter.ofPattern("yyyyMMdd")指定特殊格式 -
（7）ZoneDate/ZoneTime/ZoneDateTime 帶時區的一些時間api
轉載請註明出處，本文鏈接：https://www.uj5u.com/qita/183443.html
標籤：其他