安装数组的所有值的最快方法？

尝试

Arrays.fill/c, f/

:
http://docs.oracle.com/javase/ ... %255D,%20char%29

作为另一个选择和后代，我最近研究过这一点，并找到了一个解决方案，使您能够显着减少循环，通过部分工作类
http://docs.oracle.com/javase/ ... .html
, 哪一个 /如果一个 JVM, 您使用足够的智能/ 可以转换为运行
https://coderoad.ru/7367677/
:-

/*

 * initialize a smaller piece of the array and use the System.arraycopy 

 * call to fill in the rest of the array in an expanding binary fashion

 */

public static void bytefill/byte[] array, byte value/ {

 int len = array.length;



 if /len > 0/{

 array[0] = value;

 }



 //Value of i will be [1, 2, 4, 8, 16, 32, ..., len]

 for /int i = 1; i < len; i += i/ {

 System.arraycopy/array, 0, array, i, //len - i/ < i/ ? /len - i/ : i/;

 }

}

这项决定是由 IBM 研究
https://ieeexplore.ieee.org/document/5387064
.

简化解释

从评论中如下，它设置了索引 0 您的值中的目标数组，然后使用
http://docs.oracle.com/javase/ ... .html
复制一个对象的类，即索引的对象 0 在索引中 1, 然后是这两个对象 /指数 0 和 1/ 在 2 和 3, 然后这四个物体 /0,1,2 和 3/ 在 4,5,6 和 7 等等...

效率 /当时

文章/

在快速里程，抓住

System.nanoTime//

之前和之后并计算出我发明的持续时间： -

这种方法 :

332,617 - 390,262

/'highest - lowest' 的 10 测试/

Float[] n = new Float[array.length]; //Fill with null

: 666,650

通过循环设置。 :

3,743,488

-

9,767,744

/'highest - lowest' 的 10 测试/

Arrays.fill

: 12,539,336


汇编 JVM 和 JIT

应该指出的是，随着发展 JVM 和 JIT 这种方法可能很过时，因为图书馆的优化和执行时间可以实现甚至超过这些数字，只需使用

fill//

.
在撰写文章时，它是我找到的最快选择。 已经提到了现在它可能不是这样的，但我没有检查过。 在这个美丽和诅咒 Java.

使用

Arrays.fill

char f = '+';

 char [] c = new char [50];

 Arrays.fill/c, f/

http://www.ensta-paristech.fr/ ... .html
优惠：

public static void bytefill/byte[] array, byte value/ {

 int len = array.length;

 if /len > 0/

 array[0] = value;

 for /int i = 1; i < len; i += i/

 System.arraycopy/ array, 0, array, i,

 //len - i/ < i/ ? /len - i/ : i/;

}

它基本上是这样做的 log2 /array.length/ 挑战 System.arraycopy, 我们希望哪种方式使用优化的实施 memcpy.

但是，是否仍然需要现代技术 Java JITs, 如 Oracle/Android JIT?

System.arraycopy - 这是我的答案。 如果有任何最佳方式，请告诉我。 TNH.

private static long[] r1 = new long[64];

private static long[][] r2 = new long[64][64];



/**Proved:

 * {@link Arrays#fill/long[], long[]/} makes r2 has 64 references to r1 - not the answer;

 * {@link Arrays#fill/long[], long/} sometimes slower than deep 2 looping.<br/>

 */

private static void testFillPerformance// {

 SimpleDateFormat sdf = new SimpleDateFormat/"HH:mm:ss"/;

 System.out.println/sdf.format/new Date////;

 Arrays.fill/r1, 0l/;



 long stamp0 = System.nanoTime//;

 // Arrays.fill/r2, 0l/; -- exception

 long stamp1 = System.nanoTime//;

 // System.out.println/String.format/"Arrays.fill takes %s nano-seconds.", stamp1 - stamp0//;



 stamp0 = System.nanoTime//;

 for /int i = 0; i < 64; i++/ {

 for /int j = 0; j < 64; j++/

 r2[i][j] = 0l;

 }

 stamp1 = System.nanoTime//;

 System.out.println/String.format/"Arrays' 2-looping takes %s nano-seconds.", stamp1 - stamp0//;



 stamp0 = System.nanoTime//;

 for /int i = 0; i < 64; i++/ {

 System.arraycopy/r1, 0, r2[i], 0, 64/;

 }

 stamp1 = System.nanoTime//;

 System.out.println/String.format/"System.arraycopy looping takes %s nano-seconds.", stamp1 - stamp0//;



 stamp0 = System.nanoTime//;

 Arrays.fill/r2, r1/;

 stamp1 = System.nanoTime//;

 System.out.println/String.format/"One round Arrays.fill takes %s nano-seconds.", stamp1 - stamp0//;



 stamp0 = System.nanoTime//;

 for /int i = 0; i < 64; i++/

 Arrays.fill/r2[i], 0l/;

 stamp1 = System.nanoTime//;

 System.out.println/String.format/"Two rounds Arrays.fill takes %s nano-seconds.", stamp1 - stamp0//;

}

12:33:18

2循环阵列占据 133536 纳米秒。

System.arraycopy 循环占用 22070 纳米秒。

一轮 Arrays.fill 占据 9777 纳米秒。

两轮 Arrays.fill 占据 93028 纳米秒。





12:33:38

2循环阵列占据 133816 纳米秒。

System.arraycopy 循环占用 22070 纳米秒。

一轮 Arrays.fill 占据 17042 纳米秒。

两轮 Arrays.fill 占据 95263 纳米秒。





12:33:51

2循环阵列占据 199187 纳米秒。

System.arraycopy 循环占用 44140 纳米秒。

一轮 Arrays.fill 占据 19555 纳米秒。

两轮 Arrays.fill 占据 449219 纳米秒。





12:34:16

2循环阵列占据 199467 纳米秒。

System.arraycopy 循环占用 42464 纳米秒。

一轮 Arrays.fill 占据 17600 纳米秒。

两轮 Arrays.fill 占据 170971 纳米秒。





12:34:26

2循环阵列占据 198907 纳米秒。

System.arraycopy 循环占用 24584 纳米秒。

一轮 Arrays.fill 占据 10616 纳米秒。

两轮 Arrays.fill 占据 94426 纳米秒。

如果你有另一个数组 char,

char[] b

, 而且你想更换

c

在

b

, 您可以使用

c=b.clone//;

.

作为 Java-8 有四个
https://docs.oracle.com/javase ... .html
方法 setAll, 由提供以计算每个元素的生成函数设置指定数组的所有元素。

这四个过载

三

其中，他们采取了一系列原语，如下所示：

https://docs.oracle.com/javase ... tion-
IntToDoubleFunction/


https://docs.oracle.com/javase ... ator-
IntUnaryOperator/


https://docs.oracle.com/javase ... tion-
IntToLongFunction/

如何使用上述方法的示例：

// given an index, set the element at the specified index with the provided value

double [] doubles = new double[50];

Arrays.setAll/doubles, index -> 30D/;



// given an index, set the element at the specified index with the provided value

int [] ints = new int[50];

Arrays.setAll/ints, index -> 60/;



 // given an index, set the element at the specified index with the provided value

long [] longs = new long[50];

Arrays.setAll/longs, index -> 90L/;

该方法提供的功能

setAll

, 获取元素索引并返回此索引的值。

您是否有兴趣涉及字符数组？

这是第四重新加载方法进入游戏

setAll

. 由于没有过载，消耗了一系列符号基元，因此我们拥有的唯一选择， - 这将更改我们符号数组的广告

Character[]

.

如果阵列类型的变化

Character

不合适，然后你可以返回方法 Arrays.fill.

使用方法的示例

setAll

从

Character[]

:

// given an index, set the element at the specified index with the provided value

Character[] character = new Character[50];

Arrays.setAll/characters, index -> '+'/;

虽然是

设置定义

值更容易使用该方法

Arrays.fill

, 不是方法

setAll

.

方法

setAll

您可以使用相同值的数组的所有元素，或生成偶数数组，奇数或任何其他公式的所有优点

例如。

int[] evenNumbers = new int[10]; 

Arrays.setAll/evenNumbers, i -> i * 2/;

还有几种方法过载。 parallelSetAll, 并行执行，尽管重要的是要注意该方法传输的功能 parallelSetAll,

必须摆脱副作用

.

输出

如果你的目标是

设置定义

数组的每个元素的值，然后使用过载

Arrays.fill

这将是最合适的选择。 但是，如果您希望按需更灵活或生成元素，最好使用

Arrays.setAll

或者

Arrays.parallelSetAll

/当它是合适的/.

厘米
http://docs.oracle.com/javase/ ... .html
方法 Arrays.fill:

char f = '+';

char [] c = new char [50];

Arrays.fill/c, f/;

Arrays.fill

可以满足您的需求

Arrays.fill/myArray, 'c'/;

http://docs.oracle.com/javase/ ... %255D,%20char%29
虽然它可能在背景中产生一个循环，但因此没有比你所拥有的更有效 /除了保存日志线/. 如果您真正照顾效率，请尝试以下与上述内容相比：

int size = 50;

char[] array = new char[size];

for /int i=0; i<size; ;="" <="" array.size="" array[i]="c" code]="" div="" i++="" {="" }[="" 对于每次迭代。="" 请注意，以上并没有导致="">

<div class="answer_text">



[code]/**

 * Assigns the specified char value to each element of the specified array

 * of chars.

 *

 * @param a the array to be filled

 * @param val the value to be stored in all elements of the array

 */

 public static void fill/char[] a, char val/ {

 for /int i = 0, len = a.length; i &lt; len; i++/

 a[i] = val;

 }

这是怎么做的 Arrays.fill.

/我想你可以调查 JNI 和使用

memset

./
</div>
<div class="answer_text">
回答罗斯画作略有改善。

为了

小的

Massif简单周期比方法更快 System.arraycopy, 由于与设置相关的开销成本 System.arraycopy. 因此，最好使用简单的循环填充阵列的前几个字节并转到 System.arraycopy 只有在完成的阵列具有一定尺寸时才。

初始循环的最佳大小将是 JVM 具体而且，当然，专门用于系统。

private static final int SMALL = 16;



public static void arrayFill/byte[] array, byte value/ {

 int len = array.length;

 int lenB = len < SMALL ? len : SMALL;



 for /int i = 0; i < lenB; i++/ {

 array[i] = value;

 }



 for /int i = SMALL; i < len; i += i/ {

 System.arraycopy/array, 0, array, i, len < i + i ? len - i : i/;

 }

}

</div>
<div class="answer_text">
您可以使用

arraycopy

, 但这取决于您是否可以提前定义原始数组， - 您是否需要每次填充不同的字符，或者您是否使用相同的符号填写阵列？

显然，填充长度很重要 - 或者您需要一个超过所有可能的目的地的来源，或者您需要多个循环 arraycopy 数据片段直到目的地已满。

char f = '+';

 char[] c = new char[50];

 for /int i = 0; i < c.length; i++/

 {

 c[i] = f;

 }



 char[] d = new char[50];

 System.arraycopy/c, 0, d, 0, d.length/;

</div>
<div class="answer_text">
arrays.fill是通用目的的最佳选择。
如果您需要填充大型数组，虽然是最后一个版本 idk 1.8 u102, 使用更快的方式 System.arraycopy.
您可以查看此替代实施。 Arrays.fill:

根据
https://github.com/zolyfarkas/ ... .java
JMH, 你几乎可以 2x 表现 boost 对于大型盾牌 /1000 +/

在任何情况下，都应仅在必要的地方使用这些实现。 JDKs Arrays.fill 必须是一个首选。
</div>
</size;>

/**

 * Assigns the specified char value to each element of the specified array

 * of chars.

 *

 * @param a the array to be filled

 * @param val the value to be stored in all elements of the array

 */

 public static void fill/char[] a, char val/ {

 for /int i = 0, len = a.length; i < len; i++/

 a[i] = val;

 }

这是怎么做的 Arrays.fill.

/我想你可以调查 JNI 和使用

memset

./

回答罗斯画作略有改善。

为了

小的

Massif简单周期比方法更快 System.arraycopy, 由于与设置相关的开销成本 System.arraycopy. 因此，最好使用简单的循环填充阵列的前几个字节并转到 System.arraycopy 只有在完成的阵列具有一定尺寸时才。

初始循环的最佳大小将是 JVM 具体而且，当然，专门用于系统。

private static final int SMALL = 16;



public static void arrayFill/byte[] array, byte value/ {

 int len = array.length;

 int lenB = len < SMALL ? len : SMALL;



 for /int i = 0; i < lenB; i++/ {

 array[i] = value;

 }



 for /int i = SMALL; i < len; i += i/ {

 System.arraycopy/array, 0, array, i, len < i + i ? len - i : i/;

 }

}

您可以使用

arraycopy

, 但这取决于您是否可以提前定义原始数组， - 您是否需要每次填充不同的字符，或者您是否使用相同的符号填写阵列？

显然，填充长度很重要 - 或者您需要一个超过所有可能的目的地的来源，或者您需要多个循环 arraycopy 数据片段直到目的地已满。

char f = '+';

 char[] c = new char[50];

 for /int i = 0; i < c.length; i++/

 {

 c[i] = f;

 }



 char[] d = new char[50];

 System.arraycopy/c, 0, d, 0, d.length/;

arrays.fill是通用目的的最佳选择。
如果您需要填充大型数组，虽然是最后一个版本 idk 1.8 u102, 使用更快的方式 System.arraycopy.
您可以查看此替代实施。 Arrays.fill:

根据
https://github.com/zolyfarkas/ ... .java
JMH, 你几乎可以 2x 表现 boost 对于大型盾牌 /1000 +/

在任何情况下，都应仅在必要的地方使用这些实现。 JDKs Arrays.fill 必须是一个首选。