#ifdef #ifndef en Java

Dudo que haya una manera de crear condiciones en tiempo de compilación en Java como #ifdef #ifndef en C ++.

Mi problema es que tengo un algoritmo escrito en Java, y tengo diferentes mejoras de tiempo de ejecución para ese algoritmo. Por eso quiero medir cuánto tiempo ahorro cuando se usa cada mejora.

En este momento tengo un conjunto de variables booleanas que se utilizan para decidir durante el tiempo de ejecución qué mejora se debe utilizar y cuál no. Pero incluso probar esas variables influye en el tiempo total de ejecución.

Así que quiero encontrar una manera de decidir durante el tiempo de compilación qué partes del programa deben compilarse y usarse.

¿Alguien sabe una forma de hacerlo en Java? O tal vez alguien sepa que no existe tal forma (también sería útil).

private static final boolean enableFast = false;

// ...
if (enableFast) {
  // This is removed at compile time
}

Los condicionales como el que se muestra arriba se evalúan en tiempo de compilación. Si en cambio usas esto

private static final boolean enableFast = "true".equals(System.getProperty("fast"));

Entonces, cualquier condición que dependa de enableFast será evaluada por el compilador JIT. La sobrecarga para esto es insignificante.

javac no generará código compilado que sea inalcanzable. Utilice una variable final establecida en un valor constante para su #definey una ifdeclaración normal para #ifdef.

Puede usar javap para demostrar que el código inalcanzable no está incluido en el archivo de clase de salida. Por ejemplo, considere el siguiente código:

public class Test
{
   private static final boolean debug = false;

   public static void main(String[] args)
   {
       if (debug) 
       {
           System.out.println("debug was enabled");
       }
       else
       {
           System.out.println("debug was not enabled");
       }
   }
}

javap -c Test da el siguiente resultado, lo que indica que solo se compiló una de las dos rutas (y la declaración if no):

public static void main(java.lang.String[]);
  Code:
   0:   getstatic       #2; //Field java/lang/System.out:Ljava/io/PrintStream;
   3:   ldc     #3; //String debug was not enabled
   5:   invokevirtual   #4; //Method java/io/PrintStream.println:(Ljava/lang/String;)V
   8:   return

Creo que encontré la solución, es mucho más simple.
Si defino las variables booleanas con el modificador "final", el propio compilador de Java resuelve el problema. Porque sabe de antemano cuál sería el resultado de probar esta condición. Por ejemplo este código:

    boolean flag1 = true;
    boolean flag2 = false;
    int j=0;
    for(int i=0;i<1000000000;i++){
        if(flag1)
            if(flag2)
                j++;
            else
                j++;
        else
            if(flag2)
                j++;
            else
                j++;
    }

se ejecuta aproximadamente 3 segundos en mi computadora.
Y éste

    final boolean flag1 = true;
    final boolean flag2 = false;
    int j=0;
    for(int i=0;i<1000000000;i++){
        if(flag1)
            if(flag2)
                j++;
            else
                j++;
        else
            if(flag2)
                j++;
            else
                j++;
    }

dura aproximadamente 1 segundo. El mismo tiempo que tarda este código

    int j=0;
    for(int i=0;i<1000000000;i++){
        j++;
    }

Nunca lo usé, pero esto existe

JCPP es una implementación Java pura, completa, compatible y autónoma del preprocesador C. Está destinado a ser útil para las personas que escriben compiladores de estilo C en Java utilizando herramientas como sablecc, antlr, JLex, CUP, etc. Este proyecto se ha utilizado para preprocesar con éxito gran parte del código fuente de la biblioteca GNU C. A partir de la versión 1.2.5, también puede preprocesar la biblioteca de Apple Objective C.

http://www.anarres.org/projects/jcpp/

Si realmente necesita una compilación condicional y usa Ant , es posible que pueda filtrar su código y hacer una búsqueda y reemplazo en él.

Por ejemplo: http://weblogs.java.net/blog/schaefa/archive/2005/01/how_to_do_condi.html

De la misma manera se puede, por ejemplo, escribir un filtro para reemplazar LOG.debug(...);con /*LOG.debug(...);*/. Esto aún se ejecutaría más rápido que las if (LOG.isDebugEnabled()) { ... }cosas, sin mencionar que sería más conciso al mismo tiempo.

Si usa Maven , hay una función similar que se describe aquí .

Manifold proporciona un preprocesador Java completamente integrado (sin pasos de compilación ni fuente generada). Se dirige exclusivamente a la compilación condicional y utiliza directivas de estilo C.

¿Usar el patrón de fábrica para cambiar entre implementaciones de una clase?

El tiempo de creación del objeto no puede ser una preocupación ahora, ¿verdad? Cuando se promedia durante un período de tiempo de ejecución prolongado, el mayor componente del tiempo invertido debería estar en el algoritmo principal ahora, ¿no es así?

Estrictamente hablando, realmente no necesita un preprocesador para hacer lo que busca lograr. Lo más probable es que existan otras formas de cumplir con sus requisitos además de la que he propuesto, por supuesto.

final static int appFlags = context.getApplicationInfo().flags;
final static boolean isDebug = (appFlags & ApplicationInfo.FLAG_DEBUGGABLE) != 0