short 在JAVA_在Java中，使用byte或short代替int和float代替double效率更高吗？

这取决于JVM以及底层硬件的实现。大多数现代硬件不会从内存(甚至从一级缓存)中获取单个字节，即使用较小的原始类型通常不会减少内存带宽消耗。同样，现代CPU的字长为64位。他们可以对较少的位执行操作，但是可以通过丢弃多余的位来工作，但这也不快。

唯一的好处是，较小的原始类型可以导致更紧凑的内存布局，尤其是在使用数组时。这样可以节省内存，从而可以改善引用的局部性(从而减少缓存未命中的次数)并减少垃圾回收的开销。

但是，一般而言，使用较小的原始类型并不快。

为了证明这一点，请遵循以下基准：

package tools.bench;

import java.math.BigDecimal;

public abstract class Benchmark {

final String name;

public Benchmark(String name) {

this.name = name;

}

abstract int run(int iterations) throws Throwable;

private BigDecimal time() {

try {

int nextI = 1;

int i;

long duration;

do {

i = nextI;

long start = System.nanoTime();

run(i);

duration = System.nanoTime() - start;

nextI = (i << 1) | 1;

} while (duration < 100000000 && nextI > 0);

return new BigDecimal((duration) * 1000 / i).movePointLeft(3);

} catch (Throwable e) {

throw new RuntimeException(e);

}

}

@Override

public String toString() {

return name + "\t" + time() + " ns";

}

public static void main(String[] args) throws Exception {

Benchmark[] benchmarks = {

new Benchmark("int multiplication") {

@Override int run(int iterations) throws Throwable {

int x = 1;

for (int i = 0; i < iterations; i++) {

x *= 3;

}

return x;

}

},

new Benchmark("short multiplication") {

@Override int run(int iterations) throws Throwable {

short x = 0;

for (int i = 0; i < iterations; i++) {

x *= 3;

}

return x;

}

},

new Benchmark("byte multiplication") {

@Override int run(int iterations) throws Throwable {

byte x = 0;

for (int i = 0; i < iterations; i++) {

x *= 3;

}

return x;

}

},

new Benchmark("int[] traversal") {

@Override int run(int iterations) throws Throwable {

int[] x = new int[iterations];

for (int i = 0; i < iterations; i++) {

x[i] = i;

}

return x[x[0]];

}

},

new Benchmark("short[] traversal") {

@Override int run(int iterations) throws Throwable {

short[] x = new short[iterations];

for (int i = 0; i < iterations; i++) {

x[i] = (short) i;

}

return x[x[0]];

}

},

new Benchmark("byte[] traversal") {

@Override int run(int iterations) throws Throwable {

byte[] x = new byte[iterations];

for (int i = 0; i < iterations; i++) {

x[i] = (byte) i;

}

return x[x[0]];

}

},

};

for (Benchmark bm : benchmarks) {

System.out.println(bm);

}

}

}

在我有些旧的笔记本上打印：

int multiplication  1.530 ns

short multiplication    2.105 ns

byte multiplication 2.483 ns

int[] traversal 5.347 ns

short[] traversal   4.760 ns

byte[] traversal    2.064 ns

如您所见，性能差异很小。优化算法远比选择原始类型重要。