📌  相关文章
📜  在Java中创建流的 10 种方法

📅  最后修改于: 2022-05-13 01:54:52.159000             🧑  作者: Mango

在Java中创建流的 10 种方法

Java 8 中引入的 Stream API，用于处理对象的集合。 Stream 是一系列对象，它支持许多不同的方法，这些方法可以通过管道处理以产生所需的结果。

Java流的特点是——

  • 流不是数据结构，它从集合、数组或 I/O 通道获取输入。
  • Streams 不会更改原始数据结构，它们仅将结果作为流水线方法提供。
  • 每个中间操作都被延迟执行并返回一个流作为结果，因此各种中间操作可以被管道化。终端操作标记流的结束并返回结果。

创建流的不同方式：

  1. 使用集合

    方法：

    1. 获取收藏
    2. 使用 Collection.stream() 方法从集合构造一个顺序流
    3. 打印流

    下面是上述方法的实现：

    程序： 

    // Java program to create Stream from Collections
  
import java.util.*;
import java.util.stream.Stream;
  
class GFG {
  
    // Function convert a List into Stream
    private static  void getStream(List list)
    {
  
        // Create stream object with the List
        Stream stream = list.stream();
  
        // Iterate list first to last element
        Iterator it = stream.iterator();
  
        // Iterate stream object
        while (it.hasNext()) {
            System.out.print(it.next() + " ");
        }
    }
  
    public static void main(String[] args)
    {
  
        // Create ArrayList of String
        List list = new ArrayList<>();
  
        // Add element in list
        list.add("Geeks");
        list.add("for");
        list.add("Geeks");
  
        // Get the Stream from the List
        getStream(list);
    }
}
    输出： 
    Geeks for Geeks
  2. 从指定值创建流

    Stream.of(T…t)方法可用于创建具有指定 t 值的流，其中 t 是元素。此方法返回包含 t 个元素的顺序 Stream。

    下面是上述方法的实现：

    程序： 

    // Java program to create Stream from values
  
import java.util.*;
import java.util.stream.Stream;
  
class GFG {
  
    // Function convert a List into Stream
    private static void getStream()
    {
  
        // Create a stream from specified values
        Stream stream
            = Stream.of(1, 2,
                        3, 4,
                        5, 6,
                        7, 8,
                        9);
  
        // Displaying the sequential ordered stream
        stream.forEach(p -> System.out.print(p + " "));
    }
  
    public static void main(String[] args)
    {
  
        // Get the Stream from the values
        getStream();
    }
}
    输出： 
    1 2 3 4 5 6 7 8 9
  3. 从数组创建流：

    Stream.of() 和 Arrays.stream() 是从指定数组创建顺序流的两种常用方法。当使用非原始类型 T 调用时，这两种方法都返回一个 Stream。
    整数数组

    • 使用 Arrays.stream() 创建流

      程序： 

      // Java program to create Stream from Collections
  
import java.util.*;
import java.util.stream.Stream;
  
class GFG {
  
    // Function convert a List into Stream
    private static  void getStream(T[] arr)
    {
  
        // Create stream from an array
        // using Arrays.stream()
        Stream streamOfArray
            = Arrays.stream(arr);
  
        // Iterate list first to last element
        Iterator it
            = streamOfArray.iterator();
  
        // Iterate stream object
        while (it.hasNext()) {
            System.out.print(it.next() + " ");
        }
    }
  
    public static void main(String[] args)
    {
  
        // Get the array
        String[] arr
            = new String[] { "a", "b", "c" };
  
        // Get the Stream from the Array
        getStream(arr);
    }
}
      输出： 
      a b c
    • 使用 Stream.of() 创建流
      当元素从流中消耗并返回一个新流时，要对元素执行的非干扰操作。

      程序： 

      // Java program to create Stream from Collections
  
import java.util.*;
import java.util.stream.Stream;
  
class GFG {
  
    // Function convert a List into Stream
    private static  void getStream(T[] arr)
    {
  
        // Create stream from an array
        // using Stream.of()
        Stream streamOfArray = Stream.of(arr);
  
        // Iterate list first to last element
        Iterator it = streamOfArray.iterator();
  
        // Iterate stream object
        while (it.hasNext()) {
            System.out.print(it.next() + " ");
        }
    }
  
    public static void main(String[] args)
    {
  
        // Get the array
        String[] arr
            = new String[] { "a", "b", "c" };
  
        // Get the Stream from the Array
        getStream(arr);
    }
}
      输出： 
      a b c
  4. 使用 Stream.empty() 创建一个空流

    empty() 方法在创建时使用，以避免为没有元素的流返回 null。

    程序： 

    // Java program to create empty Stream
  
import java.util.*;
import java.util.stream.Stream;
  
class GFG {
  
    // Function convert a List into Stream
    private static void getStream()
    {
  
        // Create stream from an array using Stream.empty()
        Stream streamOfArray
            = Stream.empty();
  
        // Iterate list first to last element
        Iterator it
            = streamOfArray.iterator();
  
        // Iterate stream object
        while (it.hasNext()) {
            System.out.print(it.next() + " ");
        }
    }
  
    public static void main(String[] args)
    {
  
        // Get the empty Stream
        getStream();
    }
}
    输出：
  5. 使用 Stream.builder() 创建流

    当需要在语句的右侧额外指定所需类型时，使用 builder() 方法，否则 build() 方法将创建 Stream 的实例。

    程序： 

    // Java program to create Stream from Collections
  
import java.util.*;
import java.util.stream.Stream;
  
class GFG {
  
    // Function convert a List into Stream
    private static  void getStream()
    {
  
        // Create stream using Stream builder()
        Stream.Builder builder
            = Stream.builder();
  
        // Adding elements in the stream of Strings
        Stream stream = builder.add("a")
                                    .add("b")
                                    .add("c")
                                    .build();
  
        // Iterate list first to last element
        Iterator it = stream.iterator();
  
        // Iterate stream object
        while (it.hasNext()) {
            System.out.print(it.next() + " ");
        }
    }
  
    public static void main(String[] args)
    {
  
        // Get the Stream using Builder
        getStream();
    }
}
    输出： 
    a b c
  6. 使用 Stream.iterate() 创建无限流

    iterate() 方法返回由函数f 迭代应用到初始元素种子产生的无限顺序有序流。在下面的示例中，结果流的第一个元素是迭代方法的第一个参数。为了创建每个后续元素，该函数将应用于前一个元素。在下面的示例中，第二个元素将是 4。

    程序： 

    // Java program to create infinite Stream
// using Stream.iterate() method
  
import java.util.*;
import java.util.stream.Stream;
  
class GFG {
  
    // Function convert a List into Stream
    private static  void
    getStream(int seedValue, int limitTerms)
    {
  
        // Create infinite stream
        // using Stream.iterate() method
        Stream.iterate(seedValue,
                       (Integer n) -> n * n)
            .limit(limitTerms)
            .forEach(System.out::println);
    }
  
    public static void main(String[] args)
    {
  
        // Get the seed value
        int seedValue = 2;
  
        // Get the limit for number of terms
        int limitTerms = 5;
  
        // Get the Stream from the function
        getStream(seedValue, limitTerms);
    }
}
    输出： 
    2
4
16
256
65536
  7. 使用 Stream.generate() 方法创建无限流

    generate() 方法接受一个供应商来生成元素，结果流是无限的。因此，要限制它，请指定所需的大小，否则 generate() 方法将一直工作，直到达到内存限制。

    程序： 

    // Java program to create infinite Stream
// using Stream.generate() method
  
import java.util.*;
import java.util.stream.*;
  
class GFG {
  
    // Function convert a List into Stream
    private static  void getStream(int limitTerms)
    {
  
        // Create infinite stream
        // using Stream.generate() method
        Stream.generate(Math::random)
            .limit(limitTerms)
            .forEach(System.out::println);
    }
  
    public static void main(String[] args)
    {
  
        // Get the limit for number of terms
        int limitTerms = 5;
  
        // Get the Stream from the function
        getStream(limitTerms);
    }
}
    输出： 
    0.2293502475696314
0.5650334795948209
0.3418138293253522
0.36831074763500116
0.4864408670097241
  8. 使用 Predicate 从 Pattern 创建流

    在Java 8 中，Pattern 的 Predicate asPredicate() 方法创建了一个用于模式匹配的谓词布尔值函数。

    程序： 

    // Java program to create Stream from Collections
  
import java.util.*;
import java.util.stream.*;
import java.util.regex.Pattern;
  
class GFG {
  
    // Function convert a List into Stream
    private static void
    getStream(List list, Pattern p)
    {
  
        list.stream()
            .filter(p.asPredicate())
            .forEach(System.out::println);
    }
  
    public static void main(String[] args)
    {
  
        // Create ArrayList of String
        // that is backed by the specified array
        List list
            = Arrays
                  .asList("Geeks",
                          "For",
                          "Geek",
                          "GeeksForGeeks",
                          "A Computer Portal");
  
        // Get the pattern
        Pattern p = Pattern.compile("^G");
  
        // Get the Stream from the List matching Pattern
        getStream(list, p);
    }
}
    输出： 
    Geeks
Geek
GeeksForGeeks
  9. 从迭代器创建流

    Java中的迭代器在 Collection Framework 中用于一一检索元素。 Spliterator 是创建顺序流的关键。因此，在这种方法中，也使用了 Spliterator。但是在这个方法中，Spliterator 的源被设置为一个从 Iterator 创建的 Iterable。所以首先 Iterable 是从 Iterator 创建的。然后Spliterator作为Iterable.spliterator()直接传递给stream()方法。

    程序： 

    // Java program to create Stream from Collections
  
import java.util.*;
import java.util.stream.*;
  
class GFG {
  
    // Function convert a List into Stream
    private static  void getStream(Iterator itr)
    {
  
        // Convert the iterator into a Spliterator
        Spliterator spitr
            = Spliterators
                  .spliteratorUnknownSize(itr,
                                          Spliterator.NONNULL);
  
        // Convert spliterator into a sequential stream
        Stream stream
            = StreamSupport.stream(spitr, false);
  
        // Iterate list first to last element
        Iterator it = stream.iterator();
  
        // Iterate stream object
        while (it.hasNext()) {
            System.out.print(it.next() + " ");
        }
    }
  
    public static void main(String[] args)
    {
  
        // Get the Iterator
        Iterator iterator = Arrays
                                        .asList("a", "b", "c")
                                        .iterator();
  
        // Get the Stream from the Iterator
        getStream(iterator);
    }
}
    输出： 
    a b c
  10. 从 Iterable 创建流

    可迭代接口的设计牢记在心，它本身不提供任何 stream() 方法。只需将它传递给 StreamSupport.stream() 方法，并从给定的 Iterable 对象中获取 Stream。将 Iterable 转换为 Stream 更容易。 Iterable 有一个默认方法 spliterator()，可用于获取 Spliterator 实例，然后再将其转换为 Stream。

    注意： Iterable 不是 Collection 的实例，该方法在内部调用 StreamSupport.stream() 从 Spliterator 获取顺序流，否则它只是调用 Collection.stream() 方法。

    程序： 

    // Java program to create Stream from Collections
  
import java.util.*;
import java.util.stream.*;
  
class GFG {
  
    // Function convert a List into Stream
    private static  void getStream(Iterable iterable)
    {
  
        // Convert the iterator into a Stream
        Stream stream
            = StreamSupport
                  .stream(iterable.spliterator(),
                          false);
  
        // Iterate list first to last element
        Iterator it = stream.iterator();
  
        // Iterate stream object
        while (it.hasNext()) {
            System.out.print(it.next() + " ");
        }
    }
  
    public static void main(String[] args)
    {
  
        // Get the Iterable
        Iterable iterable
            = Arrays.asList("a", "b", "c");
  
        // Get the Stream from the Iterable
        getStream(iterable);
    }
}
    输出： 
    a b c