java.util.stream.IntStream#concat ( )源码实例Demo

@Override
public MetaData getGeneratedMetaData() throws OperatorException {
	ExampleSetMetaData emd = new ExampleSetMetaData();
	emd.addAttribute(new AttributeMetaData("label", Ontology.NOMINAL, Attributes.LABEL_NAME));
	emd.setNumberOfExamples(getParameterAsInt(PARAMETER_NUMBER_EXAMPLES));
	int desiredNumberOfAttributes = getParameterAsInt(PARAMETER_NUMBER_ATTRIBUTES);
	double mean = getParameterAsDouble(PARAMETER_SPARSE_FRACTION);
	IntStream attributeIndices;
	if (desiredNumberOfAttributes <= MAX_METADATA_ATTRIBUTES) {
		// all attributes
		attributeIndices = IntStream.range(1, desiredNumberOfAttributes);
	} else {
		// first ten and last ten
		attributeIndices = IntStream.concat(IntStream.rangeClosed(1, MAX_METADATA_ATTRIBUTES/2),
				IntStream.rangeClosed(desiredNumberOfAttributes - MAX_METADATA_ATTRIBUTES/2 + 1, desiredNumberOfAttributes));
	}
	attributeIndices.mapToObj(i -> new AttributeMetaData("att" + i, null, Ontology.REAL, new Range(0, 1)))
			.peek(amd -> amd.setMean(new MDReal(mean))).forEach(emd::addAttribute);
	return emd;
}
 

private void assertIntConcat(Stream<Integer> s1, Stream<Integer> s2, boolean parallel, boolean ordered) {
    IntStream result = IntStream.concat(s1.mapToInt(Integer::intValue),
                                        s2.mapToInt(Integer::intValue));
    assertEquals(result.isParallel(), parallel);
    assertConcatContent(result.spliterator(), ordered,
                        expected.stream().mapToInt(Integer::intValue).spliterator());
}
 

private void assertIntConcat(Stream<Integer> s1, Stream<Integer> s2, boolean parallel, boolean ordered) {
    IntStream result = IntStream.concat(s1.mapToInt(Integer::intValue),
                                        s2.mapToInt(Integer::intValue));
    assertEquals(result.isParallel(), parallel);
    assertConcatContent(result.spliterator(), ordered,
                        expected.stream().mapToInt(Integer::intValue).spliterator());
}
 

private void assertIntConcat(Stream<Integer> s1, Stream<Integer> s2, boolean parallel, boolean ordered) {
    IntStream result = IntStream.concat(s1.mapToInt(Integer::intValue),
                                        s2.mapToInt(Integer::intValue));
    assertEquals(result.isParallel(), parallel);
    assertConcatContent(result.spliterator(), ordered,
                        expected.stream().mapToInt(Integer::intValue).spliterator());
}
 

private static List<ByteBuf> shiftedSlices(int shift, Bytes... chunks) {
  AtomicInteger sum = new AtomicInteger(0);
  IntStream pos =
      IntStream.concat(
          IntStream.of(0), Arrays.stream(chunks).mapToInt(Bytes::size).map(sum::addAndGet));
  if (shift > 0) {
    pos = pos.limit(chunks.length);
  } else {
    pos = pos.skip(1);
  }
  pos = pos.map(p -> p + shift).map(p -> Math.max(p, 0));
  return slice(toByteBuf(chunks), pos.toArray());
}
 

private void assertIntConcat(Stream<Integer> s1, Stream<Integer> s2, boolean parallel, boolean ordered) {
    IntStream result = IntStream.concat(s1.mapToInt(Integer::intValue),
                                        s2.mapToInt(Integer::intValue));
    assertEquals(result.isParallel(), parallel);
    assertConcatContent(result.spliterator(), ordered,
                        expected.stream().mapToInt(Integer::intValue).spliterator());
}
 

private void assertIntConcat(Stream<Integer> s1, Stream<Integer> s2, boolean parallel, boolean ordered) {
    IntStream result = IntStream.concat(s1.mapToInt(Integer::intValue),
                                        s2.mapToInt(Integer::intValue));
    assertEquals(result.isParallel(), parallel);
    assertConcatContent(result.spliterator(), ordered,
                        expected.stream().mapToInt(Integer::intValue).spliterator());
}
 

private void assertIntConcat(Stream<Integer> s1, Stream<Integer> s2, boolean parallel, boolean ordered) {
    IntStream result = IntStream.concat(s1.mapToInt(Integer::intValue),
                                        s2.mapToInt(Integer::intValue));
    assertEquals(result.isParallel(), parallel);
    assertConcatContent(result.spliterator(), ordered,
                        expected.stream().mapToInt(Integer::intValue).spliterator());
}
 

private void assertIntConcat(Stream<Integer> s1, Stream<Integer> s2, boolean parallel, boolean ordered) {
    IntStream result = IntStream.concat(s1.mapToInt(Integer::intValue),
                                        s2.mapToInt(Integer::intValue));
    assertEquals(result.isParallel(), parallel);
    assertConcatContent(result.spliterator(), ordered,
                        expected.stream().mapToInt(Integer::intValue).spliterator());
}
 

private void assertIntConcat(Stream<Integer> s1, Stream<Integer> s2, boolean parallel, boolean ordered) {
    IntStream result = IntStream.concat(s1.mapToInt(Integer::intValue),
                                        s2.mapToInt(Integer::intValue));
    assertEquals(result.isParallel(), parallel);
    assertConcatContent(result.spliterator(), ordered,
                        expected.stream().mapToInt(Integer::intValue).spliterator());
}
 

private void assertIntConcat(Stream<Integer> s1, Stream<Integer> s2, boolean parallel, boolean ordered) {
    IntStream result = IntStream.concat(s1.mapToInt(Integer::intValue),
                                        s2.mapToInt(Integer::intValue));
    assertEquals(result.isParallel(), parallel);
    assertConcatContent(result.spliterator(), ordered,
                        expected.stream().mapToInt(Integer::intValue).spliterator());
}
 

private void assertIntConcat(Stream<Integer> s1, Stream<Integer> s2, boolean parallel, boolean ordered) {
    IntStream result = IntStream.concat(s1.mapToInt(Integer::intValue),
                                        s2.mapToInt(Integer::intValue));
    assertEquals(result.isParallel(), parallel);
    assertConcatContent(result.spliterator(), ordered,
                        expected.stream().mapToInt(Integer::intValue).spliterator());
}
 

private void assertIntConcat(Stream<Integer> s1, Stream<Integer> s2, boolean parallel, boolean ordered) {
    IntStream result = IntStream.concat(s1.mapToInt(Integer::intValue),
                                        s2.mapToInt(Integer::intValue));
    assertEquals(result.isParallel(), parallel);
    assertConcatContent(result.spliterator(), ordered,
                        expected.stream().mapToInt(Integer::intValue).spliterator());
}
 

private void assertIntConcat(Stream<Integer> s1, Stream<Integer> s2, boolean parallel, boolean ordered) {
    IntStream result = IntStream.concat(s1.mapToInt(Integer::intValue),
                                        s2.mapToInt(Integer::intValue));
    assertEquals(result.isParallel(), parallel);
    assertConcatContent(result.spliterator(), ordered,
                        expected.stream().mapToInt(Integer::intValue).spliterator());
}
 

private void assertIntConcat(Stream<Integer> s1, Stream<Integer> s2, boolean parallel, boolean ordered) {
    IntStream result = IntStream.concat(s1.mapToInt(Integer::intValue),
                                        s2.mapToInt(Integer::intValue));
    assertEquals(result.isParallel(), parallel);
    assertConcatContent(result.spliterator(), ordered,
                        expected.stream().mapToInt(Integer::intValue).spliterator());
}
 

public String get() {
    if (entriesToRemove.isEmpty()) {
        return tweet.getText();
    }

    IntStream filteredIndexes = IntStream.empty();
    for (TweetEntry tweetEntry : entriesToRemove) {
        final IntStream nextFilter;

        if (tweetEntry.getStart() == tweetEntry.getEnd()) {
            nextFilter = IntStream.of(tweetEntry.getStart());
        } else {
            nextFilter = IntStream.range(tweetEntry.getStart(), tweetEntry.getEnd());
        }

        filteredIndexes = IntStream.concat(filteredIndexes, nextFilter);
    }

    final Set<Integer> indexesToFilterOut = filteredIndexes.boxed().collect(toCollection(TreeSet::new));
    final int[] chars = tweet.getText().chars().toArray();
    final int[] filteredChars = IntStream.range(0, chars.length)
            .filter(i -> !indexesToFilterOut.contains(i))
            .map(i -> chars[i])
            .toArray();

    return new String(filteredChars, 0, filteredChars.length)
            .replaceAll("  *", " ")
            .trim();
}
 

@Test
public void intstream_concat() {

	IntStream first = IntStream.builder().add(10).build();
	IntStream second = IntStream.builder().add(10).build();

	IntStream third = IntStream.concat(first, second);

	assertEquals(20, third.sum());
}
 

/**
 * Returns a new {@code IntStreamEx} which is a concatenation of this stream
 * and the stream containing supplied values
 * 
 * <p>
 * This is a <a href="package-summary.html#StreamOps">quasi-intermediate
 * operation</a>.
 * 
 * @param values the values to append to the stream
 * @return the new stream
 */
public IntStreamEx append(int... values) {
    if (values.length == 0)
        return this;
    return new IntStreamEx(IntStream.concat(stream(), IntStream.of(values)), context);
}
 

/**
 * Creates a lazily concatenated stream whose elements are all the elements
 * of this stream followed by all the elements of the other stream. The
 * resulting stream is ordered if both of the input streams are ordered, and
 * parallel if either of the input streams is parallel. When the resulting
 * stream is closed, the close handlers for both input streams are invoked.
 *
 * @param other the other stream
 * @return this stream appended by the other stream
 * @see IntStream#concat(IntStream, IntStream)
 */
public IntStreamEx append(IntStream other) {
    return new IntStreamEx(IntStream.concat(stream(), other), context.combine(other));
}
 

/**
 * Returns a new {@code IntStreamEx} which is a concatenation of the stream
 * containing supplied values and this stream
 * 
 * <p>
 * This is a <a href="package-summary.html#StreamOps">quasi-intermediate
 * operation</a>.
 * 
 * @param values the values to prepend to the stream
 * @return the new stream
 */
public IntStreamEx prepend(int... values) {
    if (values.length == 0)
        return this;
    return new IntStreamEx(IntStream.concat(IntStream.of(values), stream()), context);
}