Java Code Examples for java.util.Arrays#stream()

@NonNull
private static Stream<File> findModules(@NonNull final File modulesFolder) {
    //No project's dist folder do File.list
    File[] modules = modulesFolder.listFiles((File f) -> {
        try {
            if (f.getName().startsWith(".")) {
                return false;
            }
            return f.isFile() ?
                    FileUtil.isArchiveFile(BaseUtilities.toURI(f).toURL()) :
                    new File(f, MODULE_INFO_CLASS).exists();
        } catch (MalformedURLException e) {
            Exceptions.printStackTrace(e);
            return false;
        }
    });
    return modules == null ?
       Stream.empty():
       Arrays.stream(modules);
}
 

@Override
public List<PotentialAssignment> getValueSources(final ParameterSignature sig) {
	final DoubleData doubledata = sig.getAnnotation(DoubleData.class);
	DoubleStream stream = Arrays.stream(doubledata.vals());

	if(doubledata.angle()) {
		stream = DoubleStream.of(0d, Math.PI / 2d, Math.PI, 3d * Math.PI / 2d, 2d * Math.PI, -Math.PI / 2d, -Math.PI,
			-3d * Math.PI / 2d, -2d * Math.PI, 1.234, -1.234, 3d * Math.PI, -3d * Math.PI);
	}

	if(doubledata.bads()) {
		stream = DoubleStream.concat(stream, DoubleStream.of(Double.NaN, Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY));
	}

	return stream.mapToObj(i -> PotentialAssignment.forValue("", i)).collect(Collectors.toList());
}
 

/**
 * Returns a {@link Stream} constructed from the specified path
 *
 * @param path
 * @return
 */
public Stream<String> getFileStream(String path) {
    try {
        return Files.lines(new File(path).toPath());
    }catch(IOException e) {
        LOGGER.error("Failed to load indicated file: " + path);
        try {
            InputStream is = getClass().getResourceAsStream("/foxeat.csv");
            return new BufferedReader(new InputStreamReader(is)).lines();
        }catch(Exception ex) {
            LOGGER.error("Failed secondary attempt from jar.");
        }
        return Arrays.stream(new String[] { });
    }
}
 

@Test
public void whenCollectionHasElements_thenExpectAStreamOfExactlyTheSameElements() {
    Collection<String> collection = Arrays.asList("a", "b", "c");
    Stream<String> expResult = Arrays.stream(new String[] { "a", "b", "c" });
    Stream<String> result = instance.collectionAsStream(collection);
    assertStreamEquals(expResult, result);
}
 

@Override
public List<PotentialAssignment> getValueSources(final ParameterSignature sig) {
	final StringData data = sig.getAnnotation(StringData.class);
	Stream<String> stream = Arrays.stream(data.vals());

	if(data.withNull()) {
		stream = Stream.concat(stream, Stream.of((String) null));
	}

	return stream.map(i -> PotentialAssignment.forValue("", i)).collect(Collectors.toList());
}
 

private Stream<Configuration> getConfigurations0(String filter)
		throws IOException, InvalidSyntaxException {

	Configuration[] configurations = cm.listConfigurations(filter);
	if (configurations == null)
		configurations = EMPTY;

	return Arrays.stream(configurations);
}
 

private static Stream<Method> definedMethods(Class<?> javaClass) {
    if (javaClass == null || javaClass == Object.class) {
        return Stream.empty();
    }
    Stream<Method> selfMethods = Arrays.stream(javaClass.getDeclaredMethods());
    Stream<Method> superMethods = definedMethods(javaClass.getSuperclass());

    return Stream.concat(selfMethods, superMethods);
}
 

@Test
public void whenCollectionHasElements_thenExpectAStreamOfExactlyTheSameElements() {

    Collection<String> collection = Arrays.asList("a", "b", "c");
    Stream<String> expResult = Arrays.stream(new String[] { "a", "b", "c" });
    Stream<String> result = instance.collectionAsStream(collection);
    assertStreamEquals(expResult, result);
}
 

@Override
public DoubleStream getRealizationsStream() {
	if(isDeterministic()) {
		return DoubleStream.generate(new DoubleSupplier() {
			@Override
			public double getAsDouble() {
				return valueIfNonStochastic;
			}
		});
	} else {
		return Arrays.stream(getDoubleArray(realizations));
	}
}
 

@SafeVarargs
@Nonnull
public static <T> Stream<T> stream(T... args) {
  return args == null ? Stream.<T>empty() : Arrays.stream(args);
}
 

/**
 * {@inheritDoc}
 */
@Override
public Stream<DataInstance> stream() {
    return Arrays.stream(this.dataInstances);
}
 

public static TableData table(Object... columnNames) {
    return new TableData(Arrays.stream(columnNames));
}
 

/**
 * Returns a sequential ordered stream whose elements are the specified values.
 *
 * @param values the elements of the new stream
 * @return the new stream
 */
public static DoubleStream of(double... values) {
    return Arrays.stream(values);
}
 

/**
 * Converts a vector of {@link Cell} indexes to {@link Column} indexes.
 * 
 * @param cells             the indexes of the cells to convert
 * @param cellsPerColumn    the defined number of cells per column  
 *                          false if not.   
 * @return  the column indexes of the specified cells.
 */
public static int[] asColumnIndices(int[] cells, int cellsPerColumn) {
    IntStream op = Arrays.stream(cells);
    return op.map(cell -> cell / cellsPerColumn).distinct().toArray();
}
 

/**
 * Returns a sequential ordered stream whose elements are the specified values.
 *
 * @param values the elements of the new stream
 * @return the new stream
 */
public static DoubleStream of(double... values) {
    return Arrays.stream(values);
}
 

/**
 * Returns a sequential ordered stream whose elements are the specified values.
 *
 * @param values the elements of the new stream
 * @return the new stream
 */
public static LongStream of(long... values) {
    return Arrays.stream(values);
}
 

/**
 * Returns a sequential ordered stream whose elements are the specified values.
 *
 * @param values the elements of the new stream
 * @return the new stream
 */
public static IntStream of(int... values) {
    return Arrays.stream(values);
}
 

/**
 * Returns a sequential ordered stream whose elements are the specified values.
 *
 * @param values the elements of the new stream
 * @return the new stream
 */
public static IntStream of(int... values) {
    return Arrays.stream(values);
}
 

/**
 * Returns a sequential ordered stream whose elements are the specified values.
 *
 * @param values the elements of the new stream
 * @return the new stream
 */
public static DoubleStream of(double... values) {
    return Arrays.stream(values);
}
 

/**
 * Returns a sequential {@link Stream} with the specified array as its
 * source.
 *
 * @param <T> The type of the array elements
 * @param self The array, assumed to be unmodified during use
 * @return a {@code Stream} for the array
 *
 * @since 2.5.0
 */
public static <T> Stream<T> stream(final T[] self) {
    return Arrays.stream(self);
}