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);
		}
	}	
}