Java Arrays.setAll方法代码示例

import java.util.Arrays; //导入方法依赖的package包/类
/** {@inheritDoc} */
@Override public Vector map(IgniteDoubleFunction<Double> fun) {
    if (sto.isArrayBased()) {
        double[] data = sto.data();

        Arrays.setAll(data, (idx) -> fun.apply(data[idx]));
    }
    else {
        int len = size();

        for (int i = 0; i < len; i++)
            storageSet(i, fun.apply(storageGet(i)));
    }

    return this;
}
 

import java.util.Arrays; //导入方法依赖的package包/类
private RealTimeTradeProducer(int index, String broker, String topic, int tradesPerSecond, int keysFrom, int keysTo) throws IOException,
        URISyntaxException {
    if (tradesPerSecond <= 0) {
        throw new RuntimeException("tradesPerSecond=" + tradesPerSecond);
    }
    this.index = index;
    this.topic = topic;
    this.tradesPerSecond = tradesPerSecond;
    tickers = new String[keysTo - keysFrom];
    Arrays.setAll(tickers, i -> "T-" + Integer.toString(i + keysFrom));
    Properties props = new Properties();
    props.setProperty("bootstrap.servers", broker);
    props.setProperty("key.serializer", LongSerializer.class.getName());
    props.setProperty("value.serializer", TradeSerializer.class.getName());
    this.producer = new KafkaProducer<>(props);
}
 

import java.util.Arrays; //导入方法依赖的package包/类
/**
 * Parses a GFA file to a {@link Graph}.
 *
 * @param gfaFile         an instance of {@link GfaFile}
 * @param progressUpdater a {@link ProgressUpdater} to notify interested parties on progress updates
 * @return a {@link Graph}
 * @throws GfaParseException if the given {@link String} is not GFA-compliant
 */
@EnsuresNonNull("nodeArrays")
public Graph parse(final GfaFile gfaFile, final ProgressUpdater progressUpdater) throws GfaParseException {
    try {
        LOGGER.info("Start allocating nodes");
        final BufferedReader nodeAllocationReader = gfaFile.readFile();
        allocateNodes(nodeAllocationReader, progressUpdater);
        LOGGER.info("Finished allocating nodes");

        nodeArrays = new int[nodeIds.size()][];
        Arrays.setAll(nodeArrays, i -> Graph.createEmptyNodeArray());

        genomeMapping = new HashMap<>();

        LOGGER.info("Start parsing lines");
        parseLines(gfaFile.getInputStream(), progressUpdater);
        LOGGER.info("Finished parsing lines");
    } catch (final IOException e) {
        throw new GfaParseException("An error while reading the GFA file.", e);
    }

    final Graph graph = new Graph(nodeArrays, gfaFile);
    gfaFile.setGenomeMapping(genomeMapping);

    addEdgesToSentinelNodes(graph);

    return graph;
}
 

import java.util.Arrays; //导入方法依赖的package包/类
@Test
public void run2() {
    int[] arr=new int[10000000];
    Random r=new Random();
    /**串行给数组中每一个元素都附上一个随机值*/
    Arrays.setAll(arr, (i)->r.nextInt());

    /**并行给数组中每一个元素都附上一个随机值*/
    Arrays. parallelSetAll (arr, (i)->r.nextInt());
}
 

import java.util.Arrays; //导入方法依赖的package包/类
@Test(dataProvider = "string")
public void testSetAllString(String name, int size, IntFunction<String> generator, String[] expected) {
    String[] result = new String[size];
    Arrays.setAll(result, generator);
    assertEquals(result, expected, "setAll(String[], IntFunction<String>) case " + name + " failed.");

    // ensure fresh array
    result = new String[size];
    Arrays.parallelSetAll(result, generator);
    assertEquals(result, expected, "parallelSetAll(String[], IntFunction<String>) case " + name + " failed.");
}
 

import java.util.Arrays; //导入方法依赖的package包/类
@Test(dataProvider = "int")
public void testSetAllInt(String name, int size, IntUnaryOperator generator, int[] expected) {
    int[] result = new int[size];
    Arrays.setAll(result, generator);
    assertEquals(result, expected, "setAll(int[], IntUnaryOperator) case " + name + " failed.");

    // ensure fresh array
    result = new int[size];
    Arrays.parallelSetAll(result, generator);
    assertEquals(result, expected, "parallelSetAll(int[], IntUnaryOperator) case " + name + " failed.");
}
 

import java.util.Arrays; //导入方法依赖的package包/类
@Test(dataProvider = "long")
public void testSetAllLong(String name, int size, IntToLongFunction generator, long[] expected) {
    long[] result = new long[size];
    Arrays.setAll(result, generator);
    assertEquals(result, expected, "setAll(long[], IntToLongFunction) case " + name + " failed.");

    // ensure fresh array
    result = new long[size];
    Arrays.parallelSetAll(result, generator);
    assertEquals(result, expected, "parallelSetAll(long[], IntToLongFunction) case " + name + " failed.");
}
 

import java.util.Arrays; //导入方法依赖的package包/类
@Test(dataProvider = "double")
public void testSetAllDouble(String name, int size, IntToDoubleFunction generator, double[] expected) {
    double[] result = new double[size];
    Arrays.setAll(result, generator);
    assertDoubleArrayEquals(result, expected, 0.05, "setAll(double[], IntToDoubleFunction) case " + name + " failed.");

    // ensure fresh array
    result = new double[size];
    Arrays.parallelSetAll(result, generator);
    assertDoubleArrayEquals(result, expected, 0.05, "setAll(double[], IntToDoubleFunction) case " + name + " failed.");
}
 

import java.util.Arrays; //导入方法依赖的package包/类
private static NumberProto.Number protoNum(int i) {
    Integer[] ints = new Integer[32 * 1024];
    Arrays.setAll(ints, operand -> i);

    return NumberProto.Number.newBuilder().addAllNumber(Arrays.asList(ints)).build();
}
 

import java.util.Arrays; //导入方法依赖的package包/类
private List<String> getFixedColumnTypes(final RelationalInput input) {
  final String[] types = new String[input.numberOfColumns()];
  Arrays.setAll(types, index -> STRING_COLUMN_TYE);
  return asList(types);
}
 

import java.util.Arrays; //导入方法依赖的package包/类
public EVMEnvironmentBuilder setCallData(byte[] callData) {
    Byte[] bytes = new Byte[callData.length];
    Arrays.setAll(bytes, n -> callData[n]);
    this.callData = Arrays.asList(bytes);
    return this;
}
 

import java.util.Arrays; //导入方法依赖的package包/类
private static MethodHandle widen(MethodHandle mh, MethodType type) {
  MethodHandle[] filters = new MethodHandle[type.parameterCount()];
  Arrays.setAll(filters, i -> widener(type.parameterType(i)));
  return filterArguments(mh, 0, filters).asType(type);
}