Die wurde doch schon gepostet 
Aber wenn du die Frage nach der effizientesten meintest, dann dürfte es wohl keine eindeutige Lösung geben 
:rolleyes: Ähm… ja, das meinte ich.
[QUOTE=Natac]Fast… Deine Funktion ist falsch für Zahlen < 2.[/QUOTE]nur für int kleiner 1…
bye
TT
1 ist aber (per Definition) keine Primzahl. Die kleinste Primzahl ist 2.
[QUOTE=Natac]1 ist aber (per Definition) keine Primzahl. Die kleinste Primzahl ist 2.[/QUOTE]gut, wieder was gelernt…
bye
TT
Mal was neues: Geht das?
String [] blubb [] = null;
Sollte gehen und einen 2D-Array liefern. Der alte Kampf zwischen den Befürwortern von
String s[][];
und
String[][] s;
Spätestens in C mit Pointer kann man da rieeesen Spaß haben 
Ich geh’ mal (ungetestet) davon aus, dass das stimmte
Die Frage ist ein bißchen gemein: Sie hat nichts mit Java an sich zu tun, und ich hätte bei der Antwort wohl auch nur händewedelnd rumraten können. Aber mal schauen, ob das „richtige“ Stichwort fällt:
Das folgende Programm erstellt zwei Arrays mit zufälligen Zahlen zwischen 0 und 256. Die Elemente des Arrays aufsummiert, wenn sie nicht kleiner als 128 sind (die mit !!! markierte Schleife). Wenn man das Array vor dem Aufsummieren sortiert, läuft das ganze wesentlich schneller. Warum?
import java.util.Arrays;
import java.util.Random;
public class SortedArraySumSpeed
{
public static void main(String[] args)
{
for (int size = 1<<15; size<= 1<<17; size<<=1)
{
runTest(size);
}
}
private static int[] generate(int size)
{
int data[] = new int[size];
Random random = new Random(0);
for (int i=0; i<size; i++)
{
data** = random.nextInt() % 256;
}
return data;
}
private static void runTest(int size)
{
int data0[] = generate(size);
int data1[] = generate(size);
Arrays.sort(data1);
for (int i=0; i<3; i++)
{
runTest(data0, "Normal");
runTest(data1, "Sorted");
}
}
private static void runTest(int data[], String type)
{
long before = System.nanoTime();
long sum = 0;
for (int j=0; j<10000; j++)
{
for (int i=0; i<data.length; i++) // ------------------ !!!
{
if (data** >= 128)
{
sum += data**;
}
}
}
long after = System.nanoTime();
System.out.println(type+" size "+data.length+" sum "+sum+" time "+(after-before)/1e6);
}
}
Ist jetzt auch nur geraten, aber möglicherweise macht sich hier eine Branch Prediction bemerkbar? 
Die Frage hat es doch bei StackOverflow ganz nach oben geschafft… 
Jupp, da stammt die auch her: http://stackoverflow.com/questions/11227809/why-is-processing-a-sorted-array-faster-than-an-unsorted-array (mit leichten Micro-Benchmark-üblichen Anpassungen).
Gerechnet hätte ich mit einem SO deutlichen Unterschied aber nicht.
Danke drück - wieder was gelernt. Der Hinweis auf SO auf die Intel-Optimierung hat mich zum Lachen gebracht. Einfach genial.
Ich hätte noch was:
public class Foo {
public static System s = null;
public static void main(String... args) {
s.out.println("Foo");
}
}
Funktioniert das oder nicht?
Es sieht zwar nach einer NPE aus, aber es funktioniert trotzdem, wenn der Zugriff auf statische Elemente der Klasse des vermeindlichen Null-Objektes (naja, eine Instanz gibt es ja genau genommen nicht, daher eigentlich Null-Variable) stattfindet.
Richtig!
Oh, und als Betthupferl:
//Version 1
String s = (Math.random() > 0.5 ? new StringBuilder("Hi ") : new StringBuffer("Hello ")).append(" world!").toString();
System.out.println(s);
//Version 2
Appendable app = (Math.random() > 0.5 ? new StringBuilder("Hi ") : new StringBuffer("Hello ")).append(" world!");
System.out.println(app.toString());
Funktionieren beide Versionen?
Interessant (Habe gerade mal probiert, ob man ihn da mit einem “Diamant aus Interfaces” oder Generics irgendwie raushauen kann, aber auf die schnelle nix dergleichen hingekriegt…)
Ahahahaha ist das hart, ich hab 5 Minuten gebraucht beim Hinschauen um zu verstehen wo das Problem lag. 
Ich hatte (vielleicht auch wegen der Uhrzeit) erst Probleme deinen Worten zu folgen, deswegen nochmal in meinen eigenen, um sicher zu gehen, dass ich das richtig verstehe. Da Zugriffe auf statische Variablen einer Klasse ohnehin unabhängig von der einer Instanz sind, ist es hier egal was mit der Variable vorher passiert.
Öhm… willst du behaupten, dass du durch draufschauen erkannt hast, was da die Fehlerursache ist!?
Ja, mit Hilfe von Eclipse und der Fehlermeldung hab ichs dann verstanden. Aber ob ich es dir auch verraten soll?