用Java创建流的10种方法

📌 相关文章

📜 用Java创建流的10种方法

📅 最后修改于: 2020-03-28 14:06:01 🧑 作者: Mango

Java 8中引入的Stream API，用于处理对象的集合。流是对象的序列，它支持许多不同的方法，可以通过管道进行排列以产生所需的结果。
Java流的功能:

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

创建流的不同方法：

使用Collections
方法：

获取Collections
使用Collection.stream()方法从集合构造顺序流
打印流

下面是上述方法的实现：
程序：

// Java从Collections创建流Stream
import java.util.*;
import java.util.stream.Stream;
class GFG {
    // 把List转化成Stream
    private static  void getStream(List list)
    {
        // 使用List创建stream对象
        Stream stream = list.stream();
        // 对list进行遍历迭代
        Iterator it = stream.iterator();
        // 对stream对象进行遍历迭代
        while (it.hasNext()) {
            System.out.print(it.next() + " ");
        }
    }
    public static void main(String[] args)
    {
        // 创建ArrayList，String类型
        List list = new ArrayList<>();
        // Add element in list
        list.add("芒果");
        list.add("for");
        list.add("芒果");
        // 从List获取stream
        getStream(list);
    }
}

输出：

芒果 for 芒果

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

// Java根据值创建流
import java.util.*;
import java.util.stream.Stream;
class GFG {
    // 把List转成Stream
    private static void getStream()
    {
        // 利用给定的值创建流
        Stream stream
            = Stream.of(1, 2,
                        3, 4,
                        5, 6,
                        7, 8,
                        9);
        // 展示按顺序排列的流
        stream.forEach(p -> System.out.print(p + " "));
    }
    public static void main(String[] args)
    {
        // 从Stream获取值
        getStream();
    }
}

输出：

1 2 3 4 5 6 7 8 9

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

使用Arrays.stream()创建流程序：

// Java创建Stream，利用Collections
import java.util.*;
import java.util.stream.Stream;
class GFG {
    // 把List转化成Stream
    private static  void getStream(T[] arr)
    {
        // 利用array创建流
        // 使用Arrays.stream()
        Stream streamOfArray
            = Arrays.stream(arr);
        // 遍历list
        Iterator it
            = streamOfArray.iterator();
        // 遍历stream对象
        while (it.hasNext()) {
            System.out.print(it.next() + " ");
        }
    }
    public static void main(String[] args)
    {
        // 获取array
        String[] arr
            = new String[] { "a", "b", "c" };
        // 从Array获取stream
        getStream(arr);
    }
}

输出：

a b c

使用Stream.of()创建流。
在元素从流中消耗掉并返回新流时，要对它们执行的无干扰操作。程序：

// Java创建Stream，利用Collections
import java.util.*;
import java.util.stream.Stream;
class GFG {
    //  把List转化成Stream
    private static  void getStream(T[] arr)
    {
        // 利用array创建流
        // 使用Stream.of()
        Stream streamOfArray = Stream.of(arr);
        // 遍历list
        Iterator it = streamOfArray.iterator();
        // 遍历Stream对象
        while (it.hasNext()) {
            System.out.print(it.next() + " ");
        }
    }
    public static void main(String[] args)
    {
        // 获取array
        String[] arr
            = new String[] { "a", "b", "c" };
        // 从Array获取stream
        getStream(arr);
    }
}

输出：

abc

使用Stream.empty()创建一个空流，创建时使用empty()方法，以避免没有元素的流返回null。
程序：

// Java程序，创建空Stream
import java.util.*;
import java.util.stream.Stream;
class GFG {
    // 把List转化成Stream
    private static void getStream()
    {
        // 使用Stream.empty()从array创建流
        Stream streamOfArray
            = Stream.empty();
        // 遍历list
        Iterator it
            = streamOfArray.iterator();
        // 遍历Stream对象
        while (it.hasNext()) {
            System.out.print(it.next() + " ");
        }
    }
    public static void main(String[] args)
    {
        // 获取空Stream
        getStream();
    }
}

输出：

使用Stream.builder()创建一个Stream：在语句的右侧另外指定所需的类型时，将使用builder()方法，否则build()方法将创建Stream的实例。
程序：

// Java创建Stream，利用Collections
import java.util.*;
import java.util.stream.Stream;
class GFG {
    // 把List转成Stream
    private static  void getStream()
    {
        // 使用builder()创建流
        Stream.Builder builder
            = Stream.builder();
        // 在类型为Strings的流里面添加元素
        Stream stream = builder.add("a")
                                    .add("b")
                                    .add("c")
                                    .build();
        // 遍历list
        Iterator it = stream.iterator();
        // 遍历Stream对象
        while (it.hasNext()) {
            System.out.print(it.next() + " ");
        }
    }
    public static void main(String[] args)
    {
        // 使用Builder获取Stream
        getStream();
    }
}

输出：

abc

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

// Java使用Stream.iterate()方法创建一个无限流
import java.util.*;
import java.util.stream.Stream;
class GFG {
    // 把List转成Stream
    private static  void
    getStream(int seedValue, int limitTerms)
    {
        //  使用Stream.iterate()方法，创建无限流
        Stream.iterate(seedValue,
                       (Integer n) -> n * n)
            .limit(limitTerms)
            .forEach(System.out::println);
    }
    public static void main(String[] args)
    {
        // 获取seed值
        int seedValue = 2;
        
        int limitTerms = 5;
        // 获取Stream
        getStream(seedValue, limitTerms);
    }
}

输出：

使用Stream.generate()方法创建无限流。generate()方法接受生成元素，并且结果流是无限的。因此，要限制它，请指定所需的大小，否则generate()方法将一直作用直到达到内存限制。
程序：

// Java使用Stream.generate()方法创建一个无限流
import java.util.*;
import java.util.stream.*;
class GFG {
    // 把List转成Stream
    private static  void getStream(int limitTerms)
    {
        // 使用Stream.generate()方法创建无限流
        Stream.generate(Math::random)
            .limit(limitTerms)
            .forEach(System.out::println);
    }
    public static void main(String[] args)
    {
        // 限制=5
        int limitTerms = 5;
        // 获取流
        getStream(limitTerms);
    }
}

输出：

0.2293502475696314
0.5650334795948209
0.3418138293253522
0.36831074763500116
0.4864408670097241

使用谓词从regular expression创建流。在Java 8中，Pattern的Predicate asPredicate()方法创建一个用于模式匹配的谓词布尔值函数。
程序：

// Java创建Stream，利用Collections
import java.util.*;
import java.util.stream.*;
import java.util.regex.Pattern;
class GFG {
    // 把List转成Stream
    private static void
    getStream(List list, Pattern p)
    {
        list.stream()
            .filter(p.asPredicate())
            .forEach(System.out::println);
    }
    public static void main(String[] args)
    {
        // 创建ArrayList，由String类型组成
        List list
            = Arrays
                  .asList("芒果",
                          "For",
                          "芒果",
                          "芒果For芒果",
                          "A Computer Portal");
        // 获取模式
        Pattern p = Pattern.compile("^果");
        // 获取流中匹配模式的元素
        getStream(list, p);
    }
}

输出：

芒果
芒果
芒果For芒果

从迭代器创建流。Java中的迭代器在Collection Framework中用于一一检索元素。分隔符是创建顺序流的关键。因此，在该方法中，也使用了分隔符Spliterator。但是在此方法中，将Spliterator的源设置为从Iterator创建的Iterable。因此，首先从Iterator创建Iterable。然后，将Spliterator作为Iterable.spliterator()直接传递到stream()方法。
程序：

// Java创建Stream，利用Collections
import java.util.*;
import java.util.stream.*;
class GFG {
    // 把List转成Stream
    private static  void getStream(Iterator itr)
    {
        // 把迭代器转成Spliterator
        Spliterator spitr
            = Spliterators
                  .spliteratorUnknownSize(itr,
                                          Spliterator.NONNULL);
        // 把spliterator转成stream
        Stream stream
            = StreamSupport.stream(spitr, false);
        // 遍历list
        Iterator it = stream.iterator();
        // Iterate stream object
        while (it.hasNext()) {
            System.out.print(it.next() + " ");
        }
    }
    public static void main(String[] args)
    {
        // 获取Iterator
        Iterator iterator = Arrays
                                        .asList("a", "b", "c")
                                        .iterator();
        // 从Iterator获取Stream
        getStream(iterator);
    }
}

输出：

abc

从Iterable创建流可迭代接口的设计谨记在心，它自己不提供任何stream()方法。只需将其传递到StreamSupport.stream()方法，并从给定的Iterable对象获取Stream。将Iterable转换为Stream更容易。Iterable具有默认方法spliterator()，该方法可用于获取Spliterator实例，然后可以将其转换为Stream。
注意： Iterable不是Collection的实例，此方法在内部调用StreamSupport.stream()以从Spliterator获取顺序的Stream，否则它仅调用Collection.stream()方法。
程序：

// Java创建Stream，利用Collections
import java.util.*;
import java.util.stream.*;
class GFG {
    // 把List转成Stream
    private static  void getStream(Iterable iterable)
    {
        // 把迭代器转成Stream
        Stream stream
            = StreamSupport
                  .stream(iterable.spliterator(),
                          false);
        // 遍历list
        Iterator it = stream.iterator();
        // 遍历stream对象
        while (it.hasNext()) {
            System.out.print(it.next() + " ");
        }
    }
    public static void main(String[] args)
    {
        // 获取Iterable
        Iterable iterable
            = Arrays.asList("a", "b", "c");
        // 从迭代器获取Stream
        getStream(iterable);
    }
}

输出：

abc