java8的新特性怎么使用

這篇文章主要介紹“java8的新特性怎么使用”，在日常操作中，相信很多人在java8的新特性怎么使用問題上存在疑惑，小編查閱了各式資料，整理出簡單好用的操作方法，希望對大家解答”java8的新特性怎么使用”的疑惑有所幫助！接下來，請跟著小編一起來學(xué)習(xí)吧！

1）Lambda表達式

	概念：java8中增加了一個新的語法--Lambda表達式，并且引入了一個新的操作符(Lambda操作符)： -> 
	
	Lambda操作符 -> ：
		  -> 將Lambda表達式分為兩個部分：
			左側(cè)：指定了Lambda表達式需要的參數(shù)，參數(shù)的數(shù)據(jù)類型可以由編譯器的“類型推斷”機制推斷得出，故可以省略。
			右側(cè)：指定了Lambda表達式的方法體，即Lambda表達式要執(zhí)行的功能。
	
	語法格式：
		
		格式一：無參數(shù)，無返回值
				() -> System.out.println("Hello Lambda!");

		格式二：有一個參數(shù)，并且無返回值
				(x) -> System.out.println(x)

		格式三：若只有一個參數(shù)，小括號可以省略不寫
				x -> System.out.println(x)

		格式四：有兩個以上的參數(shù)，有返回值，并且 Lambda 體中有多條語句
				(x, y) -> {
					System.out.println("函數(shù)式接口");
					return Integer.compare(x, y);
				};

		格式五：若 Lambda 體中只有一條語句， return 和 大括號都可以省略不寫
				(x, y) -> Integer.compare(x, y);

		格式六：Lambda 表達式的參數(shù)列表的數(shù)據(jù)類型可以省略不寫，因為JVM編譯器通過上下文推斷出，數(shù)據(jù)類型，即“類型推斷”
				(Integer x, Integer y) -> Integer.compare(x, y);			
				
				

2）函數(shù)式接口

	概念：只有一個抽象方法(默認方法與靜態(tài)方法除外)的接口，稱為函數(shù)式接口！
	
	補充：java8中，接口里可以有default方法(默認方法)和static方法(靜態(tài)方法)，實現(xiàn)類默認會繼承defaul方法和static方法。
	
	聲明一個函數(shù)式接口：
	
		@FunctionalInterface
		public interface FirstInterface {
			void run();
		}
	
	說明：
		1)可以通過Lambda表達式來創(chuàng)建函數(shù)式接口的對象。
		2)可以在函數(shù)式接口上使用@FunctionalInterface注解，這樣我們就可以根據(jù)該注解來判斷這個接口是否是一個函數(shù)式接口。
		3)Java8內(nèi)置的四個核心函數(shù)式接口
				函數(shù)式接口				參數(shù)類型	返回類型	抽象方法			用途
			消費型接口：Consumer<T>			T		void		void accept(T t)	對類型為T的對象執(zhí)行某一操作。
			供給型接口：Supplier<T>			無		T			T get()				返回類型為T的對象。
			函數(shù)型接口：Function<T, R>		T		R			R apply(T t)		對類型為T的對象執(zhí)行某一操作，并返回R類型的結(jié)果。
			斷言型接口：Predicate<T>		T		boolean		boolean test(T t)	確定類型為T的對象是否滿足某約束，并返回boolean值。
			
			eg：
				// 對String類型的對象執(zhí)行Lambda表達式(x -> System.out.println(x))的方法體。
				Consumer<String> strConsumer = x -> System.out.println(x);		// 創(chuàng)建一個Consumer(消費型接口)的對象
				strConsumer.accept("Consumer的accept方法！");					// 執(zhí)行
			
				FirstInterface firstObj = () -> System.out.println("Hello Lambda!");
				firstObj.run();
			
	
3）方法引用

	方法引用：
		說明：
			1)若Lambda方法體中的功能，已經(jīng)有方法提供了實現(xiàn)，則可以使用方法引用。
			2)使用操作符 :: 將方法名和對象或類的名字分隔開來。
			
		格式：
		?  對象名 :: 實例方法名
		?  類名   :: 靜態(tài)方法名
		?  類名   :: 實例方法名
		eg：
			Comparator<Integer> com1 = (x, y) -> Integer.compare(x, y);
			Comparator<Integer> com2 = Integer::compare;
	
	構(gòu)造器引用
		格式： 類名 :: new
		eg：
			Supplier<Student> sup1 = () -> new Student();
			Supplier<Student> sup2 = Student::new;
		
	數(shù)組引用
		格式： type[] :: new
		eg：
			Function<Integer, String[]> fun1 = (args) -> new String[args];
			Function<Integer, String[]> fun2 = String[]::new;

			
4）Stream API

概念：Stream用于操作集合、數(shù)組等元素序列。

Stream API 的操作步驟

	1)創(chuàng)建Stream
	
		創(chuàng)建Stream的方式：
			1>通過Collection中的 stream() 或 parallelStream() 來創(chuàng)建一個Stream
				eg：
					List<String> list = new ArrayList<>();
					Stream<String> stream = list.stream(); 					//獲取一個順序流
					Stream<String> parallelStream = list.parallelStream(); 	//獲取一個并行流
				
			2>通過Arrays中的stream(T[] array)創(chuàng)建一個Stream
			3>通過Stream中的
				of(T... values)									創(chuàng)建一個Stream
				generate(Supplier<T> s)							創(chuàng)建一個無限Stream
				iterate(final T seed, final UnaryOperator<T> f)	創(chuàng)建一個無限Stream
				

	2)Stream的中間操作
	
		Stream<T> filter(Predicate<? super T> predicate)	從流中排除某些元素
		Stream<T> limit(long n);							將流截斷，只保留流中的前n個元素
		Stream<T> skip(long n);								將流中的前n個元素剔除掉
		Stream<T> distinct();								將流中的元素進行去重操作。根據(jù)元素的hashCode()方法和equals()方法來確定唯一性。
		
		Stream<T> sorted();									將流中的元素進行自然排序
		Stream<T> sorted(Comparator<? super T> comparator); 將流中的元素按照指定的規(guī)則排序
		
		<R> Stream<R> map(Function<? super T, ? extends R> mapper);		
		
			1>說明：將流中的元素進行處理后，用新生成的元素代替原來的元素。注：新元素的類型與舊元素的類型可能不一樣。
			2>參數(shù)：一個函數(shù)式接口，用傳入的函數(shù)來生成新的元素。
			3>舉例：Stream<String> stream = strList.stream().map(String::toUpperCase);
		
		<R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper);
		
			說明：將流中的每個值都換成另一個流，然后把所有流連接成一個流。
		
		
		<R, A> R collect(Collector<? super T, A, R> collector);	
		
			1>說明：將流轉(zhuǎn)換為其它形式，將流中的元素進行分組、拼接等。
			2>舉例：List<String> list = strList.stream().map(String::toUpperCase).collect(Collectors.toList());
	

	3)Stream的終端操作
	
		void forEach(Consumer<? super T> action);	遍歷流中的所有元素
		
		boolean allMatch(Predicate<? super T> predicate);	檢查所有的元素是否都匹配
				anyMatch									檢查是否有元素匹配
				noneMatch									檢查是否有元素不匹配
		
		Optional<T> findFirst();							返回第一個元素
		Optional<T> findAny();								返回流中任意一個元素
		
		long count();										返回流中元素的總數(shù)
		Optional<T> max(Comparator<? super T> comparator);	返回流中最大的元素
		Optional<T> min(Comparator<? super T> comparator);	返回流中最小的元素
	
	
	說明：
		1>只有調(diào)用終端操作后，所有的中間操作才會去執(zhí)行，若沒有調(diào)用終端操作，那么所有的中間操作都將不會執(zhí)行，這種模式叫做"惰性求值"。
		2>流只能使用一次，即只能調(diào)用一次終端操作。

到此，關(guān)于“java8的新特性怎么使用”的學(xué)習(xí)就結(jié)束了，希望能夠解決大家的疑惑。理論與實踐的搭配能更好的幫助大家學(xué)習(xí)，快去試試吧！若想繼續(xù)學(xué)習(xí)更多相關(guān)知識，請繼續(xù)關(guān)注億速云網(wǎng)站，小編會繼續(xù)努力為大家?guī)砀鄬嵱玫奈恼拢?/p>