javastreamtolist

1. java8,stream().map().collect(Collectors.toList()).forEach()和stream().map().forEach()有啥區別

在stream().map().collect(Collectors.toList()).forEach()中，你的forEach()針對的List；而
stream().map().forEach()針對的是Stream流。從結果操作來看是一樣的，中間過程回產生一些臨時變數。

2. 用idea編寫java代碼時突然出現的問題求大佬指點

Java8在2014年三月發布了。我們打算將Pons的所有生產伺服器升級到這一新版本。從那時起，我們將大部分代碼庫遷移到lambda表達式、數據流和新的日期API上。我們也會使用Nashorn來把我們的應用中運行時發生改變的部分變成動態腳本。

除了lambda，最實用的特性是新的數據流API。集合操作在任何我見過的代碼庫中都隨處可見。而且對於那些集合操作，數據流是提升代碼可讀性的好方法。

但是一件關於數據流的事情十分令我困擾：數據流只提供了幾個終端操作，例如rece和findFirst屬於直接操作，其它的只能通過collect來訪問。工具類Collctors提供了一些便利的收集器，例如toList、toSet、joining和groupingBy。

例如，下面的代碼對一個字元串集合進行過濾，並創建新的列表：

stringCollection
.stream()
.filter(e -> e.startsWith( "a"))
.collect(Collectors.toList());

在遷移了300k行代碼到數據流之後，我可以說，toList、toSet、和groupingBy是你的項目中最常用的終止操作。所以我不能理解為什麼不把這些方法直接集成到Stream介面上面，這樣你就可以直接編寫：

stringCollection
.stream()
.filter(e -> e.startsWith( "a"))
.toList();

這在開始看起來是個小缺陷，但是如果你需要一遍又一遍地編寫這些代碼，它會非常煩人。

有toArray()方法但是沒有toList()，所以我真心希望一些便利的收集器可以在Java9中這樣添加到Stream介面中。是吧，Brian？ಠ_ಠ

註：Stream.js是瀏覽器上的Java 8 數據流API的JavaScript介面，並解決了上述問題。所有重要的終止操作都可以直接在流上訪問，十分方便。詳情請見API文檔。

無論如何，IntelliJ IDEA聲稱它是最智能的Java IDE。所以讓我們看看如何使用IDEA來解決這一問題。

使用 IntelliJ IDEA 來幫忙

IntelliJ IDEA自帶了一個便利的特性，叫做實時模板（Live Template）。如果你還不知道它是什麼：實時模板是一些常用代碼段的快捷方式。例如，你鍵入sout並按下TAB鍵，IDEA就會插入代碼段System.out.println()。更多信息請見這里。

如何用實時模板來解決上述問題？實際上我們只需要為所有普遍使用的默認數據流收集器創建我們自己的實時模板。例如，我們可以創建.toList縮寫的實時模板，來自動插入適當的收集器.collect(Collectors.toList())。

下面是它在實際工作中的樣子：

讓我們看看如何自己構建它。首先訪問設置（Settings）並在左側的菜單中選擇實時模板。你也可以使用對話框左上角的便利的輸入過濾。

下面我們可以通過右側的+圖標創建一個新的組，叫做Stream。接下來我們向組中添加所有數據流相關的實時模板。我經常使用默認的收集器toList、toSet、groupingBy 和 join，所以我為每個這些方法都創建了新的實時模板。

這一步非常重要。在添加新的實時模板之後，你需要在對話框底部指定合適的上下文。你需要選擇Java → Other，然後定義縮寫、描述和實際的模板代碼。

// Abbreviation: .toList
.collect(Collectors.toList())

// Abbreviation: .toSet
.collect(Collectors.toSet())

// Abbreviation: .join
.collect(Collectors.joining( "$END$"))

// Abbreviation: .groupBy
.collect(Collectors.groupingBy(e -> $END$))

特殊的變數$END$指定在使用模板之後的游標位置，所以你可以直接在這個位置上打字，例如，定義連接分隔符。

提示：你應該開啟"Add unambiguous imports on the fly"（自動添加明確的導入）選項，便於讓IDEA自動添加 java.util.stream.Collectors的導入語句。選項在 Editor → General → Auto Import中。

讓我們在實際工作中看看這兩個模板：

連接

Intellij IDEA中的實時模板非常靈活且強大。你可以用它來極大提升代碼的生產力。你知道實時模板可以拯救生活的其它例子嗎？請讓我知道！

作者：布客飛龍 segmentfault.com/a/1190000006033999

3. Java stream中map和forEach有什麼區別

我給你貼段代碼你一看就知道了：
關於stream中map的用法：
Map
data=new
HashMap<>();
data.put(1,
10);
data.put(2,
20);
data.put(3,
30);
List
list
=
data.entrySet().stream().map(Entry::getValue).collect(Collectors.toList());
System.out.println(list);
結果：[10,
20,
30]
這其中map就是把entry的value值映射出來，最後再用Collectors轉成list
關於stream.forEach的用法
map.forEach((k,v)->{
System.out.println(v);
});
純粹就是用流來實現遍歷的語法糖

4. Java8 Stream中小弟我怎麼對多個欄位分組

在介紹Java 8的流（Stream）時，我們學會了一些集合操作的實用技巧。現在我們要看看怎樣把這些循環轉換為更簡潔，可讀性更高的代碼。

開始編碼！

好吧，講的夠多了，是時候展示一些例子了！

這次我們要以文章為例子。一篇文章擁有一個標題，一個作者和幾個標簽。

private class Article {

private final String title;
private final String author;
private final List<String> tags;

private Article(String title, String author, List<String> tags) {
this.title = title;
this.author = author;
this.tags = tags;
}

public String getTitle() {
return title;
}

public String getAuthor() {
return author;
}

public List<String> getTags() {
return tags;
}
}

每個例子都會包含一個使用傳統循環的方案和一個使用Java 8新特性的方案。

在第一個例子里，我們要在集合中查找包含「Java」標簽的第一篇文章。

看一下使用for循環的解決方案。

public Article getFirstJavaArticle() {

for (Article article : articles) {
if (article.getTags().contains("Java")) {
return article;
}
}

return null;
}

現在我們使用Stream API的相關操作來解決這個問題。

public Optional<Article> getFirstJavaArticle() {
return articles.stream()
.filter(article -> article.getTags().contains("Java"))
.findFirst();
}

是不是很酷？我們首先使用 filter 操作去找到所有包含Java標簽的文章，然後使用 findFirst()
操作去獲取第一次出現的文章。因為Stream是「延遲計算」（lazy）的並且filter返回一個流對象，所以這個方法僅在找到第一個匹配元素時才會
處理元素。

現在，讓我們獲取所有匹配的元素而不是僅獲取第一個。

首先使用for循環方案。

public List<Article> getAllJavaArticles() {

List<Article> result = new ArrayList<>();

for (Article article : articles) {
if (article.getTags().contains("Java")) {
result.add(article);
}
}

return result;
}

使用Stream操作的方案。

public List<Article> getAllJavaArticles() {
return articles.stream()
.filter(article -> article.getTags().contains("Java"))
.collect(Collectors.toList());
}

在這個例子里我們使用 collection 操作在返迴流上執行少量代碼而不是手動聲明一個集合並顯式地添加匹配的文章到集合里。

到目前為止還不錯。是時候舉一些突出Stream API強大的例子了。

根據作者來把所有的文章分組。

照舊，我們使用循環方案。

public Map<String, List<Article>> groupByAuthor() {

Map<String, List<Article>> result = new HashMap<>();

for (Article article : articles) {
if (result.containsKey(article.getAuthor())) {
result.get(article.getAuthor()).add(article);
} else {
ArrayList<Article> articles = new ArrayList<>();
articles.add(article);
result.put(article.getAuthor(), articles);
}
}

return result;
}

我們能否找到一個使用流操作的簡潔方案來解決這個問題？

public Map<String, List<Article>> groupByAuthor() {
return articles.stream()
.collect(Collectors.groupingBy(Article::getAuthor));
}

很好！使用 groupingBy 操作和 getAuthor 方法，我們得到了更簡潔、可讀性更高的代碼。

現在，我們查找集合中所有不同的標簽。

我們從使用循環的例子開始。

public Set<String> getDistinctTags() {

Set<String> result = new HashSet<>();

for (Article article : articles) {
result.addAll(article.getTags());
}

return result;
}

好，我們來看看如何使用Stream操作來解決這個問題。

public Set<String> getDistinctTags() {
return articles.stream()
.flatMap(article -> article.getTags().stream())
.collect(Collectors.toSet());
}

棒極了！flatmap 幫我把標簽列表轉為一個返迴流，然後我們使用 collect 去創建一個集合作為返回值。

一切皆有可能

以上的就是如何使用可讀性更高的代碼代替循環的例子。務必仔細看看Stream API，因為這篇文章僅僅提到它的一些皮毛而已。

5. java中 兩個list怎麼合並啊有list,list1,list2。想要list等於list1和list2相加得到的隊列怎麼寫

Java將兩個list合並，只需要把list1和list2內容都添加都集合list中即可，如下：

packagecom.test;

importjava.util.ArrayList;
importjava.util.List;

publicclassTestA{

	/**
	*@paramargs
	*/
	publicstaticvoidmain(String[]args){
		//定義集合1
		List<String>list1=newArrayList<String>();
		list1.add("a1");
		list1.add("a2");
		list1.add("a3");
		System.out.println("集合1內容："+list1);
		//定義集合2
		List<String>list2=newArrayList<String>();
		list2.add("b1");
		list2.add("b2");
		list2.add("b3");
		System.out.println("集合2內容："+list2);
		
		List<String>list=newArrayList<String>();
		//將集合1的內容全添加到集合中
		list.addAll(list1);
		//將集合2的內容全添加到集合中
		list.addAll(list2);
		System.out.println("現在集合內容："+list);
	}

}

運行結果：
集合1內容：[a1,a2,a3]
集合2內容：[b1,b2,b3]
現在集合內容：[a1,a2,a3,b1,b2,b3]

6. Java中如何去除List中的重復的值

屬性是????

先給你一個看看是不是你需要的好了，

//利用Set的特性，將所有項目放入Set
		//中即可移除重復的項目
		Set<String>stringSet=newHashSet<String>();
		for(Stringelement:plicateArray){
			stringSet.add(element);
		}
		//Set.size()為不重復項目的個數
		StringnonDuplicateArray[]=newString[stringSet.size()];
		//將Set中的項目取出放到nonDuplicateArray中
		Object[]tempArray=stringSet.toArray();
		for(inti=0;i<tempArray.length;i++){
			nonDuplicateArray[i]=(String)tempArray[i];
		}

7. java把一個list里的數據轉移到另外一個list

java將一個list里的數據轉移到另外一個list，可以使用for語句，一次使用add方法，示例如下：

ArrayListlist1=newArrayList();
list1.add("1");
list1.add("2");
list1.add("3");
ArrayListlist2=newArrayList();
list2.add("4");
for(inti=0;i<list1.size();i++)
{
list2.add(list1.get(i));//開始復制一個list的內容到另外一個list
}
//這樣就可以用list2添加list1的所有元素了！。想把他顯示出來可以如下
for(inti=0;i<list2.size();i++)
{
System.out.println(list2.get(i));
}

運行結果如下：

8. java stream 及早求值

流使用的通用格式:
獲得流對象Stream
對流對象Stream進行惰性求值，返回值仍然是一個Stream對象。
對流對象Stream進行及早求值，返回值不在是一個Stream對象。

9. JAVA1.8Stream如何使用

這個叫stream流運算，是目前市場上比較流行的用法，效率會比較高，舉幾個例子吧：

常用的流

1、collect(Collectors.toList())

將流轉換為list。還有toSet()，toMap()等。

這幾個是我覺得在公司比較實用的，可以多練習，然後在看比較深的steamAPI。純手打望採納。

10. Java中能取出List里的相同數據;比如{ { 1,2,3,4,5,6},{11,22,33,44,55,6},{12,13,14,15,16,6} };

尋找相同的數據, 可以使用多種方式,下面簡單介紹2種

• 第一種: 循環遍歷,然後在把每一個元素,在其他集合里查找, 如果都存在該元素,就把這個元素保存起來

• 第二種: java8流處理, 原理差不多, 但是語法比較簡潔

稍微注意的是list1 = {'A','A','B'}和list2 = {'A','C'} 如果粗糙的求交集,會得到一個交集結果{'A','A'}, 但是如果要嚴格取交集那麼結果是一個'A'

解決起來很簡單, 創造一個boolean[] b2=new boolean[list2.size]; 該boolean數組用於標記,list2的元素,哪些被使用了,哪些沒有被使用.被使用的立刻標記為true .下次不再使用.

簡單的參考代碼: 可以按照自己的需求進行擴展和完善

importjava.util.ArrayList;
importjava.util.Arrays;
importjava.util.stream.Collectors;


publicclassDemo1{
	//為了方便,全部定義成靜態屬性,方便靜態方法內使用
	staticArrayList<Integer>list1=newArrayList<Integer>(Arrays.asList(1,2,3,4,5,6));
	staticArrayList<Integer>list2=newArrayList<Integer>(Arrays.asList(11,22,33,44,55,6));
	staticArrayList<Integer>list3=newArrayList<Integer>(Arrays.asList(12,13,14,15,16,6));

	publicstaticvoidmain(String[]args){
		test1();//java8流處理
		test2();//傳統遍歷循環進行處理
	}

	//流處理求交集
	privatestaticvoidtest1(){
		System.out.println("list1,list2,list3的交集是:");
		list1.stream().filter(num->list2.contains(num)&&list3.contains(num)).collect(Collectors.toList()).stream()
				.forEach(System.out::println);
	}

	//循環遍歷求交集
	privatestaticvoidtest2(){
		ArrayList<Integer>result=newArrayList<Integer>();
		for(Integernum:list1){
			if(list2.contains(num)&&list3.contains(num)){
				result.add(num);
			}
		}
		System.out.println("list1,list2,list3的交集是:");
		for(Integeri:result){
			System.out.println(i);
		}
	}	
}