考虑内存IO的Java中If/Else语句的使用

我知道这可能是个愚蠢的问题，但我想知道什么时候是使用if/else语句的正确时机

假设我们通过在原始java int类型中指定最大堆大小来构造堆。 这是我的构造函数

public Heap(int maximumSize) {
        this.maximumSize = maximumSize;
        if (maximumSize < 1) {
            this.maximumSize = 100;
        }
        data = new int[this.maximumSize];
}

我也可以这样写

public Heap(int maximumSize) {
        if (maximumSize < 1) {
            this.maximumSize = 100;
        } else {
            this.maximumSize = maximumSize;
        }    
        data = new int[this.maximumSize];
}

我想知道考虑到所有低级进程，哪种方法更有效？

这些日子不太流行，但你可以使用三元运算符将其全部折叠起来

this.maximumSize = maximumSize < 1 ? 100 : maximumSize;

这听起来像。在第一种情况下，我们应该担心正确性和可读性，只有当有直接证据（通常通过分析获得）表明所讨论的代码是性能瓶颈时，才关注性能

考虑到这一点，我会写

public Heap() {
    this(100);
}

public Heap(int maximumSize) {
    if (maximumSize < 1) {
        throw new IllegalArgumentException(
            String.format("invalid maximumSize: %d", maximumSize));
    }
    this.maximumSize = maximumSize;
    data = new int[this.maximumSize];
}

---

拥有两个单独的构造函数背后的想法是，当maximumSize为零时，消除不直观的使用默认值。两个构造函数使默认与非默认行为显式化。

根据我对微观层次的理解，方法二是更好的方法，因为方法一遵循以下步骤： 1使用默认值创建变量maximumsize。 2使用传递的参数初始化变量。 3检查状况。 4如果为真，则重新初始化它。 同时，步骤2遵循以下步骤： 1使用默认值创建变量maximumsize。 2.检查考虑因素。 3初始化最大大小。

第一个方法类：

public class Heap {

        private int maximumSize;

        public Heap(int maximumSize) {
            this.maximumSize = maximumSize;
            if (maximumSize < 1) {
                this.maximumSize = 100;
            }
        }

        public static void main(String[] args) {
            Heap heap = new Heap(10);
        }

}

编译并获取字节码，如下所示：

rakesh@Rakesh-KR:/media/rakesh/WorkZ$ javap -c Heap
Compiled from "Heap.java"
public class Heap {
  public Heap(int);
    Code:
       0: aload_0       
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: aload_0       
       5: iload_1       
       6: putfield      #2                  // Field maximumSize:I
       9: iload_1       
      10: iconst_1      
      11: if_icmpge     20
      14: aload_0       
      15: bipush        100
      17: putfield      #2                  // Field maximumSize:I
      20: return        

  public static void main(java.lang.String[]);
    Code:
       0: new           #3                  // class Heap
       3: dup           
       4: bipush        10
       6: invokespecial #4                  // Method "<init>":(I)V
       9: astore_1      
      10: return        
}

rakesh@Rakesh-KR:/media/rakesh/WorkZ$ javap -c Heap
Compiled from "Heap.java"
public class Heap {
  public Heap(int);
    Code:
       0: aload_0       
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: iload_1       
       5: iconst_1      
       6: if_icmpge     18
       9: aload_0       
      10: bipush        100
      12: putfield      #2                  // Field maximumSize:I
      15: goto          23
      18: aload_0       
      19: iload_1       
      20: putfield      #2                  // Field maximumSize:I
      23: return        

  public static void main(java.lang.String[]);
    Code:
       0: new           #3                  // class Heap
       3: dup           
       4: bipush        10
       6: invokespecial #4                  // Method "<init>":(I)V
       9: astore_1      
      10: return        
}

第二种方法

if (maximumSize < 1) {
      this.maximumSize = 100;
 } else {
      this.maximumSize = maximumSize;
 }

字节码为

rakesh@Rakesh-KR:/media/rakesh/WorkZ$ javap -c Heap
Compiled from "Heap.java"
public class Heap {
  public Heap(int);
    Code:
       0: aload_0       
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: aload_0       
       5: iload_1       
       6: putfield      #2                  // Field maximumSize:I
       9: iload_1       
      10: iconst_1      
      11: if_icmpge     20
      14: aload_0       
      15: bipush        100
      17: putfield      #2                  // Field maximumSize:I
      20: return        

  public static void main(java.lang.String[]);
    Code:
       0: new           #3                  // class Heap
       3: dup           
       4: bipush        10
       6: invokespecial #4                  // Method "<init>":(I)V
       9: astore_1      
      10: return        
}

rakesh@Rakesh-KR:/media/rakesh/WorkZ$ javap -c Heap
Compiled from "Heap.java"
public class Heap {
  public Heap(int);
    Code:
       0: aload_0       
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: iload_1       
       5: iconst_1      
       6: if_icmpge     18
       9: aload_0       
      10: bipush        100
      12: putfield      #2                  // Field maximumSize:I
      15: goto          23
      18: aload_0       
      19: iload_1       
      20: putfield      #2                  // Field maximumSize:I
      23: return        

  public static void main(java.lang.String[]);
    Code:
       0: new           #3                  // class Heap
       3: dup           
       4: bipush        10
       6: invokespecial #4                  // Method "<init>":(I)V
       9: astore_1      
      10: return        
}

我分享这一点，并不是作为一个答案。通过读取字节码，任何人都可以编辑此答案。我在这里补充了一点

在第一种方法中，整个过程分20步完成。但在第二 它需要23个步骤。

---

没关系。这种微观优化毫无意义。写一篇可读性最好的文章；那是主观的。我投1票。我更担心的是，你允许maximumSize为负数或为零。这有意义吗？检查您的前提条件。使用工具显示为每个代码生成的字节码低级指令，并搜索这些指令的实际成本。@Mephy您能告诉我该工具的名称吗？很有可能，编译器将为两个片段生成相同的代码。就我个人而言，如果MaximumSize<1，我会投赞成票抛出新的IllegalArgumentException大小必须大于0；this.maximumSize=maximumSize；这当然是正确的，但实际上并没有回答这个问题，这个问题要求对这两段代码进行性能分析。