#ifdef #ifndef em Java

Duvido que haja uma maneira de criar condições de tempo de compilação em Java como #ifdef #ifndef em C ++.

Meu problema é que tenho um algoritmo escrito em Java, e tenho diferentes melhorias de tempo de execução para esse algoritmo. Portanto, quero medir quanto tempo economizo quando cada melhoria é usada.

No momento eu tenho um conjunto de variáveis ​​booleanas que são usadas para decidir durante o tempo de execução quais melhorias devem ser usadas e quais não. Mas mesmo o teste dessas variáveis ​​influencia o tempo total de execução.

Portanto, quero descobrir uma maneira de decidir durante o tempo de compilação quais partes do programa devem ser compiladas e usadas.

Alguém conhece uma maneira de fazer isso em Java. Ou talvez alguém saiba que não existe tal caminho (também seria útil).

private static final boolean enableFast = false;

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

Condicionais como o mostrado acima são avaliados em tempo de compilação. Se ao invés você usar isto

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

Então, quaisquer condições dependentes de enableFast serão avaliadas pelo compilador JIT. A sobrecarga para isso é insignificante.

javac não produzirá código compilado que esteja inacessível. Use uma variável final definida com um valor constante para seu #definee uma ifdeclaração normal para o #ifdef.

Você pode usar o javap para provar que o código inacessível não está incluído no arquivo de classe de saída. Por exemplo, considere o seguinte 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 fornece a seguinte saída, indicando que apenas um dos dois caminhos foi compilado (e a instrução if não foi):

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

Acho que encontrei a solução, é muito mais simples.
Se eu definir as variáveis ​​booleanas com o modificador "final", o próprio compilador Java resolve o problema. Porque sabe de antemão qual seria o resultado do teste dessa condição. Por exemplo, 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++;
    }

corre cerca de 3 segundos no meu computador.
E este

    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++;
    }

corre cerca de 1 segundo. O mesmo tempo que este código leva

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

Nunca usei, mas existe

JCPP é uma implementação Java completa, compatível, autônoma e pura do pré-processador C. Destina-se a ser útil para pessoas que escrevem compiladores de estilo C em Java usando ferramentas como sablecc, antlr, JLex, CUP e assim por diante. Este projeto foi usado para pré-processar com sucesso grande parte do código-fonte da biblioteca GNU C. A partir da versão 1.2.5, ele também pode pré-processar a biblioteca Apple Objective C.

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

Se você realmente precisa de compilação condicional e usa Ant , pode filtrar seu código e fazer uma busca e substituição nele.

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

Da mesma forma você pode, por exemplo, escrever um filtro para substituir LOG.debug(...);com /*LOG.debug(...);*/. Isso ainda seria executado mais rápido do que if (LOG.isDebugEnabled()) { ... }outras coisas, sem mencionar que seria mais conciso ao mesmo tempo.

Se você usa o Maven , há um recurso semelhante descrito aqui .

O Manifold fornece um pré-processador Java totalmente integrado (sem etapas de construção ou fonte gerada). Ele visa exclusivamente a compilação condicional e usa diretivas de estilo C.

Usar o Padrão de Fábrica para alternar entre as implementações de uma classe?

O tempo de criação do objeto não pode ser uma preocupação agora, pode? Quando calculada a média de um longo período de tempo de execução, o maior componente de tempo gasto deve estar no algoritmo principal agora, não é?

Estritamente falando, você realmente não precisa de um pré-processador para fazer o que você busca alcançar. Provavelmente, há outras maneiras de atender às suas necessidades além da que propus, é claro.

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