Perché il nome generato per una classe lambda non è la stessa per i programmi identici

Question

codice fonte (ovviamente il progetto ha molte altre classi)

import java.util.HashMap; 
import java.util.List; 
import java.util.Map; 
import java.util.Optional; 
import java.util.function.Function; 
import java.util.stream.Stream; 


public class Test { 
    public static void main(String[] args) { 
     Map<Integer, Integer> src = new HashMap<>(); 
     Map<Integer, List<Integer>> dst = new HashMap<>(); 
     Optional<Object> f = dst.values().stream().flatMap((Function<List<Integer>, Stream<?>>) integers -> integers.stream()).filter(b -> !src.containsKey(b)).findFirst(); 
     f.ifPresent(b -> { 
      throw new IllegalStateException("exception [" + b + "]"); 
     }); 
    } 
} 

1.Copia progetto diverso percorso

d: \ Users \ sul posto di lavoro della shell \ Documenti \ \ bak \ 1

d: \ Users \ shell \ Documenti \ sul posto di lavoro \ bak \ 2

2.execute pacchetto mvn sia percorso

3.Controllare il file di classe

eseguire il comando javap -p in d: \ Users \ shell \ Documenti \ posto di lavoro \ bak \ 1 \ data \ obiettivo \ classes

public class Test { 
    public Test(); 
    public static void main(java.lang.String[]); 
    private static void lambda$main$84(java.lang.Object); 
    private static boolean lambda$main$83(java.util.Map, java.lang.Object); 
    private static java.util.stream.Stream lambda$main$82(java.util.List); 
} 

eseguire il comando javap -p in d: \ Users \ shell \ Documenti \ posto di lavoro \ bak \ 2 \ Data \ obiettivo \ classes

public class Test { 
    public Test(); 
    public static void main(java.lang.String[]); 
    private static void lambda$main$75(java.lang.Object); 
    private static boolean lambda$main$74(java.util.Map, java.lang.Object); 
    private static java.util.stream.Stream lambda$main$73(java.util.List); 
} 

perché il numero di funzione lambda è diversa?

c'è un modo per renderli uguali?

Answer 1

Guardando fonte javac si può notare che the corresponding counter (che viene aggiunta al nome del metodo lambda) è definito come un campo di istanza nella LambdaAnalyzerPreprocessor che viene riutilizzata per l'intero processo di compilazione. È incrementato ad ogni occorrenza lambda. Quindi, se compilo la classe unica, avrò i numeri hanno cominciato da 0:

> javac Test.java 
> javap -p Test 
Compiled from "Test.java" 
public class Test { 
    public Test(); 
    public static void main(java.lang.String[]); 
    private static void lambda$main$2(java.lang.Object); 
    private static boolean lambda$main$1(java.util.Map, java.lang.Object); 
    private static java.util.stream.Stream lambda$main$0(java.util.List); 
} 

Ma se creo un altro classe

public class Test2 { 
    Runnable r =() -> {}; 
} 

e compilarli insieme vedrò il contatore incrementato:

> javac Test2.java Test.java 
> javap -p Test 
Compiled from "Test.java" 
public class Test { 
    public Test(); 
    public static void main(java.lang.String[]); 
    private static void lambda$main$3(java.lang.Object); 
    private static boolean lambda$main$2(java.util.Map, java.lang.Object); 
    private static java.util.stream.Stream lambda$main$1(java.util.List); 
} 

Quindi questo non è il problema di Maven, questo è il modo in cui funziona il compilatore javac.

Se hai sicuramente bisogno di risultati di compilazione stabili, ti suggerisco di provare Eclipse Compiler per Java. Sembra che non ha nessun problema del genere:

>java -jar org.eclipse.jdt.core_3.11.1.v20150902-1521.jar -8 Test2.java Test.java 
>javap -p Test 
Compiled from "Test.java" 
public class Test { 
    public Test(); 
    public static void main(java.lang.String[]); 
    private static java.util.stream.Stream lambda$0(java.util.List); 
    private static boolean lambda$1(java.util.Map, java.lang.Object); 
    private static void lambda$2(java.lang.Object); 
} 

Fare riferimento a this question su come integrare Corte di giustizia europea con Maven.