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

Question 1

我注意到我总是使用int并加倍，无论数字的大小是多少。因此，在Java中，使用byte或short代替int和float代替会更有效double吗？

因此，假设我有一个包含很多整数和双精度数的程序。如果我知道这个数字合适，将我的整数更改为字节或短裤是否值得？

我知道Java没有无符号类型，但是如果我知道数字只会是正数，我还能做些额外的事情吗？

高效，我主要是指处理。我认为，如果所有变量的大小都减半，那么垃圾收集器的速度将大大提高，并且计算速度也可能会更快。（我想因为我在android上工作，所以我也需要担心ram）

（我假设垃圾收集器仅处理对象，而不处理原始对象，但仍然删除废弃对象中的所有原始对象，对吗？）

我用一个小型的Android应用程序进行了尝试，但实际上并没有发现任何区别。（尽管我没有“科学地”测量任何东西。）

我以为它应该更快，更有效吗？我不希望在大型程序中进行更改，以发现自己浪费了时间。

当我开始一个新项目时，从一开始就值得做吗？（我的意思是，我认为一点点都会有所帮助，但是如果有的话，那又是一次，为什么似乎没有人这样做呢？）

Question 2

我以为它应该更快，更有效吗？我不希望在大型程序中进行更改，以发现自己浪费了时间。

简短答案

是的，你错了。在大多数情况下，所使用的空间几乎没有区别。

这是不值得尝试优化这个......除非你有明确的证据表明需要优化。而且，如果确实需要优化对象字段的内存使用，则可能需要采取其他（更有效的）措施。

更长的答案

Java虚拟机使用偏移量（实际上是32位原始单元格大小的倍数）对堆栈和对象字段进行建模。因此，当您将局部变量或对象字段声明为（例如）a时byte，变量/字段将存储在32位单元格中，就像一样int。

有两个例外：

long和double值需要2个原始32位单元
基本类型的数组以打包形式表示，因此（例如）字节数组每个32位字包含4个字节。

因此，它可能是值得的优化利用long和double......和基本类型的大型阵列。但总的来说没有。

^{从理论上讲，JIT 可能可以对此进行优化，但是在实践中，我从未听说过这样做。一个障碍是，JIT通常无法运行，直到创建了要编译的类的实例之后。如果JIT优化了内存布局，则您可能会有两个（或更多）相同类的对象的“味道”……这将带来巨大的困难。}

重访

查看@meriton答案中的基准测试结果，看来使用short和byte而不是int乘法会导致性能下降。的确，如果孤立地考虑这些操作，那么代价将是巨大的。（您不应该孤立地考虑它们……但这是另一个主题。）

我认为这是因为JIT可能在每种情况下都使用32位乘法指令进行乘法运算。但是在byte和的short情况下，它会执行额外的指令以在每次循环迭代中将中间的32位值转换为a byte或short。（理论上，该转换可以在循环结束时完成一次，但是我怀疑优化器是否能够解决这一问题。）

无论如何，这确实指出了切换到short并byte作为优化的另一个问题。在算术和计算密集型的算法中，这可能会使性能变差。

Question 3

这取决于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

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

Question 4

如果您大量使用它们，则使用byte代替int可以提高性能。这是一个实验：

import java.lang.management.*;

public class SpeedTest {

/** Get CPU time in nanoseconds. */
public static long getCpuTime() {
    ThreadMXBean bean = ManagementFactory.getThreadMXBean();
    return bean.isCurrentThreadCpuTimeSupported() ? bean
            .getCurrentThreadCpuTime() : 0L;
}

public static void main(String[] args) {
    long durationTotal = 0;
    int numberOfTests=0;

    for (int j = 1; j < 51; j++) {
        long beforeTask = getCpuTime();
        // MEASURES THIS AREA------------------------------------------
        long x = 20000000;// 20 millions
        for (long i = 0; i < x; i++) {
                           TestClass s = new TestClass(); 

        }
        // MEASURES THIS AREA------------------------------------------
        long duration = getCpuTime() - beforeTask;
        System.out.println("TEST " + j + ": duration = " + duration + "ns = "
                + (int) duration / 1000000);
        durationTotal += duration;
        numberOfTests++;
    }
    double average = durationTotal/numberOfTests;
    System.out.println("-----------------------------------");
    System.out.println("Average Duration = " + average + " ns = "
            + (int)average / 1000000 +" ms (Approximately)");


}

}

此类测试创建新的速度TestClass。每次测试都会进行2000万次，并且有50个测试。

这是TestClass：

 public class TestClass {
     int a1= 5;
     int a2= 5; 
     int a3= 5;
     int a4= 5; 
     int a5= 5;
     int a6= 5; 
     int a7= 5;
     int a8= 5; 
     int a9= 5;
     int a10= 5; 
     int a11= 5;
     int a12=5; 
     int a13= 5;
     int a14= 5; 
 }

我已经SpeedTest上课了，最后得到了这个：

 Average Duration = 8.9625E8 ns = 896 ms (Approximately)

现在，我将int更改为TestClass中的字节，然后再次运行它。结果如下：

 Average Duration = 6.94375E8 ns = 694 ms (Approximately)

我相信这个实验表明，如果您要实例化大量变量，则使用字节代替int可以提高效率

Question 5

字节通常被认为是8位。short通常被认为是16位。

在“纯”环境中，这不是java，因为字节和多头，短裤和其他有趣事物的所有实现通常都对您隐藏，字节可以更好地利用空间。

但是，您的计算机可能不是8位，也可能不是16位。这意味着要特别获得16位或8位，将需要求助于浪费时间的“骗子”，以假装它具有在需要时访问这些类型的能力。

此时，这取决于硬件的实现方式。然而，从我一直坚强的观点来看，最好的速度是通过将事物存储在适合CPU使用的块中来实现的。64位处理器喜欢处理64位元素，而少于此的东西通常需要“工程魔术师”来假装它喜欢处理它们。

Question 6

短/字节/字符性能较差的原因之一是缺少对这些数据类型的直接支持。通过直接支持，这意味着JVM规范没有提及这些数据类型的任何指令集。诸如存储，加载，添加等指令具有用于int数据类型的版本。但是它们没有short / byte / char的版本。例如考虑下面的Java代码：

void spin() {
 int i;
 for (i = 0; i < 100; i++) {
 ; // Loop body is empty
 }
}

将相同内容转换为如下所示的机器代码。

0 iconst_0 // Push int constant 0
1 istore_1 // Store into local variable 1 (i=0)
2 goto 8 // First time through don't increment
5 iinc 1 1 // Increment local variable 1 by 1 (i++)
8 iload_1 // Push local variable 1 (i)
9 bipush 100 // Push int constant 100
11 if_icmplt 5 // Compare and loop if less than (i < 100)
14 return // Return void when done

现在，考虑如下将int更改为short。

void sspin() {
 short i;
 for (i = 0; i < 100; i++) {
 ; // Loop body is empty
 }
}

相应的机器代码将更改如下：

0 iconst_0
1 istore_1
2 goto 10
5 iload_1 // The short is treated as though an int
6 iconst_1
7 iadd
8 i2s // Truncate int to short
9 istore_1
10 iload_1
11 bipush 100
13 if_icmplt 5
16 return

如您所见，要操作short数据类型，它仍然使用int数据类型指令版本，并在需要时将int显式转换为short。现在，由于这个原因，性能会降低。

现在，列举不给予直接支持的理由如下：

Java虚拟机为int类型的数据提供了最直接的支持。这部分是因为期望Java虚拟机的操作数堆栈和局部变量数组的有效实现。它也受典型程序中int数据的出现频率的影响。其他整数类型的直接支持较少。例如，没有字节，字符或存储，加载或添加指令的简短版本。

引自此处的 JVM规范（页58）。

Question 7

区别几乎不明显！这更多是设计，适当性，统一性，习惯等问题。有时只是品味问题。当您关心的只是您的程序启动并运行并将a替换float为int不会损害正确性时，除非您可以证明使用任何一种类型都会改变性能，否则我认为这样做并没有好处。根据2或3个字节不同的类型进行性能调整实际上是您最后需要关心的事情；唐纳德·克努斯（Donald Knuth）曾经说过：“过早的优化是万恶之源”（不确定是他的邪恶，如果有答案，请编辑）。