java8listtolist
1. JDK8中增加的一个Stream接口,该接口可以将集合、数据中的元素转换为Stream流对吗
java 8引入了全新的Stream API。这里的Stream和I/O流不同，它更像具有Iterable的集合类，但行为和集合类又有所不同。
Stream API引入的目的在于弥补Java函数式编程的缺陷。对于很多支持函数式编程的语言，map()、rece()基本上都内置到语言的标准库中了，不过，Java 8的Stream API总体来讲仍然是非常完善和强大，足以用很少的代码完成许多复杂的功能。
创建一个Stream有很多方法，最简单的方法是把一个Collection变成Stream。我们来看最基本的几个操作：
public static void main(String[] args) {
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
Stream<Integer> stream = numbers.stream();
stream.filter((x) -> {
return x % 2 == 0;
}).map((x) -> {
return x * x;
}).forEach(System.out::println);
}
集合类新增的stream()方法用于把一个集合变成Stream，然后，通过filter()、map()等实现Stream的变换。Stream还有一个forEach()来完成每个元素的迭代。
为什么不在集合类实现这些操作，而是定义了全新的Stream API？Oracle官方给出了几个重要原因：
一是集合类持有的所有元素都是存储在内存中的，非常巨大的集合类会占用大量的内存，而Stream的元素却是在访问的时候才被计算出来，这种“延迟计算”的特性有点类似Clojure的lazy-seq，占用内存很少。
二是集合类的迭代逻辑是调用者负责，通常是for循环，而Stream的迭代是隐含在对Stream的各种操作中，例如map()。
要理解“延迟计算”，不妨创建一个无穷大小的Stream。
如果要表示自然数集合，显然用集合类是不可能实现的，因为自然数有无穷多个。但是Stream可以做到。
自然数集合的规则非常简单，每个元素都是前一个元素的值+1，因此，自然数发生器用代码实现如下：
class NaturalSupplier implements Supplier<Long> {
long value = 0;
public Long get() {
this.value = this.value + 1;
return this.value;
}
}
反复调用get()，将得到一个无穷数列，利用这个Supplier，可以创建一个无穷的Stream：
public static void main(String[] args) {
Stream<Long> natural = Stream.generate(new NaturalSupplier());
natural.map((x) -> {
return x * x;
}).limit(10).forEach(System.out::println);
}
对这个Stream做任何map()、filter()等操作都是完全可以的，这说明Stream API对Stream进行转换并生成一个新的Stream并非实时计算，而是做了延迟计算。
当然，对这个无穷的Stream不能直接调用forEach()，这样会无限打印下去。但是我们可以利用limit()变换，把这个无穷Stream变换为有限的Stream。
利用Stream API，可以设计更加简单的数据接口。例如，生成斐波那契数列，完全可以用一个无穷流表示（受限Java的long型大小，可以改为BigInteger）：
class FibonacciSupplier implements Supplier<Long> {
long a = 0;
long b = 1;
@Override
public Long get() {
long x = a + b;
a = b;
b = x;
return a;
}
}
public class FibonacciStream {
public static void main(String[] args) {
Stream<Long> fibonacci = Stream.generate(new FibonacciSupplier());
fibonacci.limit(10).forEach(System.out::println);
}
}
如果想取得数列的前10项，用limit(10)，如果想取得数列的第20~30项，用：
List<Long> list = fibonacci.skip(20).limit(10).collect(Collectors.toList());
最后通过collect()方法把Stream变为List。该List存储的所有元素就已经是计算出的确定的元素了。
用Stream表示Fibonacci数列，其接口比任何其他接口定义都要来得简单灵活并且高效。
2. 怎么用java8 lamada 提取集合中每个对象的属性
要提取属性的话，用Stream中的map，然后使用方法引用，就可以了。
3. JAVA怎样生成1-100的有顺序的数字集合如（1,2,3,4......100）
可以用Java8的Stream来帮助生成集合，举例如下：
publicstaticvoidmain(String[]args){
//起始数字
intstart=1;
//生成数字的个数
intend=100;
//生成1,2,3,4,5...100
List<Integer>list=Stream.iterate(start,item->item+1).limit(end).collect(Collectors.toList());
//生成1,3,5...199
List<Integer>list1=Stream.iterate(start,item->item+2).limit(end).collect(Collectors.toList());
}生成是比较灵活的，可以定制生成规则，即修改那个item->item+1这个lambda表达式就可以了
4. 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];
}
5. 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));
}
运行结果如下：
6. 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]
7. Java8,stream().map().collect(Collectors.toList()).forEach()和stream().map().forEach()有啥区别
在stream().map().collect(Collectors.toList()).forEach()中，你的forEach()针对的List；而
stream().map().forEach()针对的是Stream流。从结果操作来看是一样的，中间过程回产生一些临时变量。
8. 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，因为这篇文章仅仅提到它的一些皮毛而已。
9. Java8新特性有哪些
【注意】本文节选自是 DZone 指南 Java 生态系统的专题文章，作者Trisha Gee是Java资深工程师和布道者。在本文中，Trisha Gee阐述了Java 8的重要特性以及使用的原因，由OneAPM工程师翻译。
一、要点速递
1、在很多情况下，Java8 都能提升应用性能，而无需任何改变或性能调优。
2、Lambda 表达式、 Streams API 以及现有类的新方法都是提高生产力的重要工具。
3、Java8 新推出的 Optional 类型在处理 null 值时，能减少 NullPointerExceptions 的可能性，给开发者极大的灵活度。
二、其他特性：
速度更快
可以取悦老板、满足业务或运营人员的一大卖点是：Java8 运行应用时速度更快。通常，升级至 Java8 的应用都能得到速度上的提升，即便没有做任何改变或调优。对于为了迎合特定 JVM 而做出调整的应用，这或许并不适用。但 Java8 性能更优的理由还有很多：
80%以上的高端企业级应用都使用JAVA平台（电信、银行等）。JAVA是成熟的产品，已经有10年的历史。如果你想在Java行业有所建树，想要系统的进行java的学习，那么你可以来这个群，前面是二三一，中间是三一四，后面是零二八。连起来就可以了。这里有很多互联网大牛教你学习，还有免费的课程。不是想学习的就不要加了。
常见数据结构的性能提升：对广受欢迎的 HashMap 进行的基准测试表明，它们在 Java8 中的性能更好。这种提升非常吸引人——你无需学习新的 Streams API 或 Lambda 语法，甚至不需要改变现有的代码，就能提升应用的性能。
垃圾回收器提升：通常，Java 应用性能取决于垃圾回收的效率。的确，糟糕的垃圾回收会很大程度上影响应用性能。Java8 对垃圾回收做了很多改变，能有效提升性能并简化调优。最为人熟知的改变是 PermGen 的移除与 Metaspace 的引入。
Fork/Join 速度提升：fork/join 框架是在 Java7 中首次引入的，目的是简化使用 JVM 的并发程序。Java8 中投入了很多努力进一步提升该框架。现在，fork/join 在 Streams API 中用于并发操作。
此外，Java8 中还包含诸多改进以支持并发。Oracle 在 JDK 8 中总结了这些性能提升。
代码行更少
Java 经常被人们诟病其样本代码太多。为此，Java8 新的 API 采用了更具功能性的方式，专注于实现什么而不是如何实现。
Lambda 表达式
Java8 中的 Lambda 表达式不仅是 Java 已有的匿名内部类—— Java8 推出之前传递行为的方法之外的语法糖衣。Lambda 表达式采用了 Java 7 的内部改变，因此运用起来相当流畅。想了解如何使用 Lambda 表达式简化代码，请继续阅读。
集合新方法介绍
Lambda 表达式与 Streams 可能是 Java8 最大的两个卖点，较少为人知的是 Java 现在允许开发者给现有类添加新的方法，而无需为了向后兼容性折中。这样，新的方法，结合 Lambda 表达式，能在很大程序上简化代码。比如，我们常常需要判断 Map 中的某个成员是否已经存在，如果不存在则创建之。在 Java8 之前，你可能会这么做：
privatefinalMap<CustomerId,Customer>customers=newHashMap<>();
(CustomerIdcustomerId){
Customercustomer=customers.get(customerId);
if(customer==null){
customer=newCustomer(customerId);
customers.put(customerId,customer);
}
customer.incrementOrders();
}
操作“检查某个成员在 map 中是否存在，若不存在则添加之”是如此常用，Java 现在为 Map 添加了一个新方法 computeIfAbsent 来支持这个操作。该方法的第二个参数是一个 Lambda 表达式，该表达式定义了如何创建缺少的成员。
(CustomerIdcustomerId){
Customercustomer=customers.computeIfAbsent(customerId,
id->newCustomer(id));
customer.incrementOrders();
}其实，Java8 还有一个新的特性，称为方法引用(method references)，它能使我们用更简洁的代码实现该功能：
(CustomerIdcustomerId){
Customercustomer=customers.computeIfAbsent(customerId,Customer::new);
customer.incrementOrders();
}Java8 为 Map 与 List 都添加了新方法。你可以了解一下这些新方法，看它们能节省多少行代码。
Streams API
Streams API 为查询、操纵数据提供了更多灵活度。这是一个很强大的功能。阅读这些文章能对 Streams API 有更全面的了解。在大数据时代建立流畅的数据查询会非常有趣，而且也是常用的操作。比如，你有一列书，你希望按照字母表顺序排列这些书的作者名，且不含重复。
publicList<Author>getAllAuthorsAlphabetically(List<Book>books){
List<Author>authors=newArrayList<>();
for(Bookbook:books){
Authorauthor=book.getAuthor();
if(!authors.contains(author)){
authors.add(author);
}
}
Collections.sort(authors,newComparator<Author>(){
publicintcompare(Authoro1,Authoro2){
returno1.getSurname().compareTo(o2.getSurname());
}
});
returnauthors;
}在上面的代码中，我们首先遍历这列书，如果书的作者从未在作者列表出现，则添加之。之后，我们根据作者的姓氏按字母表顺序对这些作者排序。这种排序操作正是 Streams 擅长解决的领域：
publicList<Author>getAllAuthorsAlphabetically(List<Book>books){
returnbooks.Streams()
.map(book->book.getAuthor())
.distinct()
.sorted((o1,o2)->o1.getSurname().compareTo(o2.getSurname()))
.collect(Collectors.toList());
}上面的做法不仅代码行更少，而且描述性更强——后来的开发者读到这段代码能够轻易理解：1、代码从书中获取作者姓名。2、只在意从未出现过的作者。3、返回的列表按照作者姓氏排序。将 Streams API 与其他新特性——方法引用(method references)、比较器(Comparator)的新方法结合使用，可以得到更加简洁的版本：
publicList<Author>getAllAuthorsAlphabetically(List<Book>books){
returnbooks.Streams()
.map(Book::getAuthor)
.distinct()
.sorted(Comparator.comparing(Author::getSurname))
.collect(Collectors.toList());
}这里，排序方法按照作者姓氏排序，更加显而易见了。
便于并行
此前我们浅聊过更利于开箱即用的性能，除了前面提到过的特性，Java8 能更好地利用 CPU 内核。将前例中的 Streams 方法替换为 parallelStreams，JVM 会将此运算分解为不同的任务，使用 fork/join 将这些任务运行在多个核上。然而，并行化并不是加速所有运算的魔法。并行化运算总是会带来更多工作——分解运算，整合结果，因此无法总是减少时间。但是，对适合并行化的例子，这么做还是颇有效率的。
最大化减少 Null 指针
Java8 的另一个新特性是全新的 Optional 类型。该类型的含义是“我可能有值，也可能是 null。“这样一来，API 就可以区分可能为 null 的返回值与绝对不会是 null 的返回值，从而最小化 NullPointerException 异常的发生几率。
Optional 最赞的用处是处理 null。例如，假设我们要从一个列表中找一本特定的书，新创建的 findFirst() 方法会返回 Optional 类型的值，表明它无法确保是否找到特定的值。有了这个可选择的值，我们接下来可以决定，如果是 null 值要如何处理。如果想要抛出一个自定义的异常，我们可以使用 orElseThrow：
publicBookfindBookByTitle(List<Book>books,Stringtitle){
Optional<Book>foundBook=books.Streams()
.filter(book->book.getTitle().equals(title))
.findFirst();
returnfoundBook.orElseThrow(()->newBookNotFoundException("Didnotfindbookwithtitle"+title));
}或者，你可以返回其他书：
returnfoundBook.orElseGet(()->getRecommendedAlternativeBook(title));
或者，返回 Optional 类型，这样，该方法的调用者可以自己决定书没找到时要怎么做。
总结：Java8 作为 Java 语言的一次重大发布，包含语法上的更改、新的方法与数据类型，以及一些能默默提升应用性能的隐性改善。Oracle 已经不再支持 Java 7，因此许多公司都被迫向 Java8 转移。好消息是，Java8 对业务、现有的应用以及期望提高生产力的开发者都好好多。