servus!

die erste abfrage könnte direkt in archivement.unlock() wandern, sodass sich der aufrufer nicht darum kümmern muss, ob irgendwas gelocked ist, oder nicht. dieses muster findet man oft in diversen büchern, tutorials, talks und papers zu gutem software design.

meiner meinung nach darf das aber nicht zur glaubensfrage mutieren ... man muss einfach ein gespür dafür entwickeln, wann etwas sinnvoll ist, und wann nicht.

dein zweites beispiel sieht man ob bei sprachen, die eine art von null kennen (z. B. nullptr in C++, None in Python, Nil in Pascal, usw.). dabei wird oft empfohlen, grundsätzlich auf nullzeiger zu verzichten. stattdessen nimmt man dann oft statische dummy-objekte. das hat den vorteil, dass man nirgendwo mehr auf null prüfen muss.

also ja, beide deiner beispiele kann man als indiz für schlechten code sehen, aber das hängt seeeeehhhr vom kontext bzw. dem gesamten quelltext ab, und so pauschal kann man beide codeschnipsel nicht per se als schlecht bezeichnen.

servus!

deine algorithmen sind sehr ineffizient, da du einen viel zu großen bereich überprüfst. von vornherein könntest du gerade zahlen auslassen, weil es sich bei denen (mit ausnahme der 2) niemals um eine primzahl handeln wird. (du kannst also in der schleife in zweier-schritten zählen)

negative zahlen kannst du ebenfalls weglassen und der maximal mögliche teiler ist maximal die wurzel aus deiner gesuchten zahl, also kannst du alle zahlen darüber von einer überprüfung ausschließen.

hier ist eine kurz zusammen gepfuschte lösung (die hoffentlich keinen fehler enthält):

public class Primes {

  public static boolean isPrime(final long num) {
    if (num < 2) {
      return false;
    } else if (num == 2) {
      return true;
    } else if ((num & 1) == 0) {
      return false;
    }

    for (long i = 3; i*i <= num; i += 2) {
      if((num % i) == 0) {
        return false;
      }
    }

    return true;
  }

  public static void main(String[] args) {
    for (long i = -2; i <= 20; ++i) {
      System.out.printf(
        "#%d: %b\n", i, isPrime(i)
      );
    }
  }

}

das liefert für die zahlen von -2 bis +20 diese ausgabe:

#-2: false                                                           
#-1: false                                                           
#0: false                                                            
#1: false                                                            
#2: true                                                             
#3: true                                                             
#4: false                                                            
#5: true                                                             
#6: false                                                            
#7: true                                                             
#8: false                                                            
#9: false
#10: false
#11: true
#12: false
#13: true
#14: false
#15: false
#16: false
#17: true
#18: false
#19: true
#20: false

zum schluss muss ich aber sagen, dass java in der BigInteger-klasse einen mordsmäßig effizienten algorithmus implementiert hat, der dir blitzschnell und sehr sehr zuverlässig mitteilt, ob eine zahl prim ist, oder nicht:

import java.math.BigInteger;

public class Main {

  public static boolean isPrime(final long num) {
    return BigInteger.valueOf(num).isProbablePrime(1);
  }

  public static void main(String[] args) {
    for (long i = -2; i <= 20; ++i) {
      System.out.printf(
        "#%d: %b\n", i, isPrime(i)
      );
    }
  }

}

die isProbablePrime()-methode ist zwar nicht perfekt akkurat, aber für kleinere zahlen im long-bereich stimmen die ergebnisse zu 100%.

servus!

das programm wird so nicht funktionieren und selbst einen raspi im lokalen netzwerk wirst du damit nicht dosen können ... der server lacht sich dabei höchstens schlapp. :)

allerdings merkt man an deiner fragestellung und an deinem c++ code, dass dir viel zu viele grundlagen fehlen, um eine vernünftige antwort verstehen zu können. deshalb lasse ich das jetzt hier an dieser stelle sein.

lerne lieber erst mal vernünftig programmieren, danach etwas über netzwerktechnik und irgendwann in ferner zukunft guckst du dir nochmal deinen heute hier veröffentlichen code an und hast was zum schmunzeln. :)

def blabla():
  return 123

results = []
for i in range(3):
  results.append(blablabla())

print(results) # [123, 123, 123]

servus! :)

Scanner nutzt standardmäßig die textkodierung der aktuellen locale-einstellung des systems.

finde erst mal heraus, welche kodierung deine datei hat und wenn es z. B. UTF-8 ist, übergebe diese deinem Scanner als zweites argument:

Scanner sc = new Scanner(config, "UTF-8");

Die kodierung deiner datei findest du auf der kommandozeile mit ...

chardet datei.txt

... oder falls das bei dir nicht installiert ist, als notlösung mit ...

file datei.txt

... raus.

wenn es dann immer noch nicht funktioniert, liegt der fehler vermutlich in deiner "config" variable. :)

ein kumpel hat mit fast 60 angefangen mathematik zu studieren. deshalb sollte informatik mit 29 kein problem sein. :)

ich weiß zwar nicht, wie dir unsere persönliche meinung hier weiter helfen soll, aber wenn es dich glücklich macht. :)

positiv finde ich die funktionalen aspekte und die möglichkeit der programmierung mit metaklassen. die große standardbibliothek hat eigentlich alles an board, um häufig anfallende aufgaben zu automatisieren und auch größere projekte umzusetzen.

so wirklich negativ ist mir noch nichts aufgefallen, außer dass man probleme mit dem GIL bekommt, sofern man auf multiprocessing verzichtet und stattdessen multithreading nutzt. außerdem haben die gzip und bzip2 module einen fehler, der sich leider erst bei mehreren terabyte großen archiven bemerkbar macht, aber das liegt glaube ich nicht an python, sondern an der entsprechenden c-bibliothek.

die syntax mit den einrückungen finde ich sehr ordentlich und sie zwingt vor allem einsteiger dazu, ordentlich zu programmieren.

mir gefällt python eigentlich sehr. aber alles hat seine vor- und nachteile, und auch python ist nicht perfekt. :)

servus!

theoretisch ist es so, wie du es dir vorstellst: im incognito-tab bzw. incognito-fenster sollte keine verbindung zu deinem sonstigen surfverhalten herzustellen sein.

das problem: praktisch geht es trotzdem, und alle tracking-firmen machen das auch, z. B. facebook, twitter, usw. mit ihren social-buttons oder tracking-pixeln.

es gibt X verschiedene möglichkeiten, deinen browser deinem vorherigen surfverhalten zuordnen zu können, selbst wenn du einen incognito-tab nutzt. (das nennt sich übrigens fingerprinting)

deshalb reicht ein reiner incognito-tab überhaupt nicht aus, um nicht "wiedererkannt" zu werden. allein hier auf GF werden tracking-skripte von gleich mehreren firmen eingebunden, die diesen incognito-schutz umgehen können. (in den datenschutzbestimmungen von GF steht genau welche firmen das sind und welche daten erhoben werden)

um dich effektiv schützen zu können musst du viiiieeel mehr tun, als dich nur auf incognito zu verlassen, aber das würde hier zu viel werden, weshalb ich mir das jetzt verkneife.

der einfachste schutz dürfte ublock-origin in kombination mit umatrix und dem privacy-badger sein. aber selbst damit kann man dich noch tracken, sofern das tracking-skript direkt von der aufgerufenen website selbst kommt.

wie gesagt, wirklicher tracking-schutz ist kompliziert und für laien fast unmöglich umzusetzen.

servus!

am Raspi zu programmieren ist unter X eigentlich etwas unschön, sofern man über VNC verbunden ist, und nicht direkt an einem physischen monitor hängt, einfach wegen der lahmen reaktion und der hohen latenz.

allerdings kannst du dich über die konsole in einem guten terminalemulator über ssh einloggen, und dort dann vi oder emacs nutzen. es dürfte keine ide geben, die auch nur einen bruchteil so mächtig ist, wie diese beiden in kombination mit tmux oder screen.

allerdings ist die lernkurve enorm und die eingewöhnungszeit deutlich länger als bei bunten klickbaren fenstern einer hübschen ide.

aber ich habe mir sogar auf mein tablet "termux" installiert (eine art linux distribution, die unter android als app läuft, open source ohne werbung ist, und sich in allen größeren appstores findet), und darin ein aktuelles clang++, python3, einen gdb, und 1.4GB weitere entwicklertools installiert:

mit physischer bluetooth-tastatur kann man in dieser konsole sehr schick und komfortabel programmieren, sofern man vi / emacs und screen / tmux nutzt. :)

das ist natürlich kein ersatz für ein richtiges system, aber wenn man bibliotheken oder module entwickelt, geht das damit unterwegs oder aufm sofa sehr angenehm.

wenn man allerdings nur arm-cpu-spezifische dinge testen will, ist ein raspi vermutlich leistungsfähiger, als ein tablet oder smartphone.

für eine dicke fette ide mit schicker gui ist der raspi aber etwas zu schwachbrüstig, um damit schnell und effektiv arbeiten zu können.

grüße aus südtirol :)

laut meinem schwerbehinderten ausweis mit einem grad von 100 gelte ich unter anderem als "blind" (neben vielen anderen sog. "merkzeichen").

allerdings heißt "blind" laut gesetz eigentlich nur, dass man über weniger als eine gewisse prozentzahl restsehvermögen verfügt. ich verfüge noch über ca. 0,2% sehvermögen, sehe also nicht nur "schwarz".

und das reicht aus, um als software-entwickler zu arbeiten.

natürlich sehe ich auf einem normalen monitor mit einer normalen ide so gut wie gar nichts, weshalb ich mir die bildschirmauflösung absichtlich runter stelle und eine mindestschriftgröße von 18pt bis 22pt nutze, bei stark erhöhtem kontrast.

eine braille-zeile oder einen screenreader habe ich glücklicherweise (noch) nicht nötig, aber um ganz ehrlich zu sein, komme ich super damit klar.

an meinen eigenen rechnern kann ich problemlos programmieren, aber wenn ich mal irgendwo anders an einem computer sitzen muss, wird das zur qual, die ich meistens nicht länger als fünf bis zehn minuten durchhalte, weil mir dann die augen bzw. der kopf anfängt weh zu tun. aber, wie gesagt, an meinem eigenen rechner mit individuell angepasster konfiguration, kann ich auch mal 12 stunden am stück arbeiten.

außerdem kenne ich komplett blinde, die wirklich nur noch schwarz sehen, und die arbeiten auch recht flott als programmierer.

also ja, es ist möglich. man kann sich an alles gewöhnen. :)

du solltest erst mal generell jede art von gemanagetem code vermeiden, bei dem ein garbage collector im hintergrund läuft. also fällt c#, python und java schon mal flach.

für so etwas einfaches wie einen staubsaugerroboter kann man auch assembler nehmen, da das programm sehr sehr kurz und überschaubar sein wird. aber vermutlich ist c oder gar c++ deutlich komfortabler.

von e-technik musst du natürlich auch einige grundlagen verstehen, mindestens löten können, und möglichst keine zwei linken hände haben. :)

ein 3d-drucker wird dir sehr weiter helfen, um prototypen passender teile herzustellen.

aber mit c# wirst du auf diesem gebiet gar nicht weiter kommen. damit kannst du noch nicht mal die treiber für deinen staubsaugerroboter schreiben, um diesem über usb befehle erteilen zu können. du könntest höchstens irgendwelche dritt-frickel-lösungen nutzen um irgendwie über usb mit deinen geräten kommunizieren zu können, aber das ist nichts halbes und nichts ganzes.

lerne wenigstens c, wenn du in die hardware-programmierung einsteigen willst. mit allem anderen wirst du früher oder später an grenzen stoßen.

servus! :)

was willst du denn damit antellen?

da es ja keine universalprogrammiersprache für alles gibt, mach dir erst mal gedanken darüber, was du überhaupt programmieren willst, und wähle anhand dessen eine passende sprache.

es ist ein sehr großer unterschied, ob du ein kernelmodul, eine website, eine app, eine gui-anwendung, oder wasauchimmer entwickeln willst.

nicht alle programmiersprachen sind für alles gleich gut geeignet ... wenn überhaupt. :)

theorie ist für elektrotechniker enorm wichtig! und auch wenn es hart wird, beiß dich einfach durch.

vermutlich wirst du auch irgendwann anfangen mikrocontroller zu programmieren, wenn du dich mit digitaltechnik beschäftigst.

meiner meinung nach ist hardware-programmieren viiieeel spannender als software.

eine app oder eine website zusammen klicken kann jeder trottel, aber low-level programmierung ist eine kunst!

lass dich einfach mal drauf ein, auch wenn am anfang die lernkurve steil sein dürfte. aber das ist sie beim mathematik-teil eines informatik-studiums auch. :)

servus!

du hast die aufgabe falsch abgetippt.

dein array muss korrekterweise so initialisiert werden:

int i[5] { 1 , 2 , 3 , 4 , 5 };

das erste element darf nicht 10, sondern muss 1 sein, sonst fliegt dir der anschließende code um die ohren. (und die arraygröße von 5 in den eckigen klammern ist optional ... kann also weggelassen werden)

alles andere haben die anderen ja schon erklärt.

allerdings müsstest du wissen, wie iteratoren funktionieren, um die foreach schleife genau verstehen zu können. ohne dieses wissen muss dir die erklärung reichen, dass über jedes element des array iteriert wird. :)

servus! :)

für einsteiger ist oft schwer verständlich, dass "0.1 + 0.1 + 0.1" eben nicht genau "0.3" ergibt. wie das kommt, warum das so sein muss und wie man korrekt damit umgeht, haben dir die anderen ja schon geschrieben, bzw. verlinkt.

hier ist mal ein demo-programm, welches dir für alle drei float-typen die zwischenergebnisse deiner schleife ausgibt:

#include <iostream>
#include <limits>
#include <type_traits>

template <typename T=double>
void dump_loop() {
  using namespace std;

  static_assert(is_floating_point<T>());

  cout << fixed << showpoint << showpos;
  cout.precision(numeric_limits<T>::max_digits10);

  T a = 2.0;
  T b = 0.4;

  cout << "[FLOAT " << sizeof(T) << ']' << endl;
  for (unsigned i = 0; i < 8; ++i) {
    cout << a << endl;

    a -= b;
  }
  cout << endl;
}

int main(void) {
  dump_loop<float>();
  dump_loop<double>();
  dump_loop<long double>();
}

das musst du als anfänger noch lange nicht alles verstehen, da in diesem code recht viele fortgeschrittene features von c++17 verwendung finden. es reicht, wenn du den code ganz grob überfliegst und ungefähr erahnst, was er evtl. tun könnte.

wie auch immer, die ausgabe des programms sieht auf meinem system wie folgt aus:

[FLOAT 4]                                                            
+2.000000000                                                         
+1.600000024                                                         
+1.200000048                                                         
+0.800000072                                                         
+0.400000066                                                         
+0.000000060                                                         
-0.399999946                                                         
-0.799999952                                                         

[FLOAT 8]                                                            
+2.00000000000000000                                                 
+1.60000000000000009                                                 
+1.20000000000000018                                                 
+0.80000000000000016                                                 
+0.40000000000000013
+0.00000000000000011
-0.39999999999999991
-0.79999999999999993

[FLOAT 16]
+2.000000000000000000000
+1.599999999999999977796
+1.199999999999999955591
+0.799999999999999933387
+0.399999999999999911182
-0.000000000000000111022
-0.400000000000000133227
-0.800000000000000155431

guck dir hierbei mal genau den wert an, der eigentlich exakt 0.0 sein sollte! je nach verwendetem float typen (float, double, long double) steht da entweder +0.000000060 oder +0.00000000000000011 oder sogar -0.000000000000000111022 mit negativem vorzeichen.

der fehler liegt also weder an dir, noch an deinem compiler oder deinem rechner. er ist einfach nur dadurch bedingt, dass sich bestimmte gleitpunktzahlen nicht exakt darstellen lassen und es dann zu einer art "fehler" kommt.

falls du meinen obigen code selber übersetzen und ausprobieren willst, beachte dabei, dass du deinem compiler mitteilen musst, dass es moderner c++17 code ist. die meisten compiler haben (noch) als standard-einstellung eine ältere version von c++.

und wundere dich nicht, falls du auf deinem system leicht abweichende werte erhältst, besonders bei dem beispiel mit "long double". die ergebnisse hängen sehr stark von der cpu-architektur ab!

servus!

das ist echt lustig, da diese frage hier gefühlt mindestens einmal pro woche kommt. hier gibt es bestimmt keine programmiersprachen-kategorie, in der das problem noch nicht besprochen wurde. :)

aber genau so wie GanMar es in seiner antwort geschrieben hat, macht man das, und nicht anders:

$nums = range(1, 49);
shuffle($nums);

$part = array_slice($nums, 0, 6);
asort($part);

foreach ($part as $x)
  echo $x . ' ';

das liefert dir schön sortiert die lottozahlen, fast wie im fernsehen. :)

beachte hierbei aber, dass shuffle() eine php-typische drecksfunktion ist, deren "zufall" (sofern man das wort hier überhaupt verwenden kann) so dermaßen grottenschlecht ist, dass er selbst einfachste statistische tests nicht besteht.

deshalb solltest du dir unbedingt ein eigenes shuffle() bauen, welches die zahlen richtig gut durcheinander würfelt, zum beispiel indem du den mersenne twister algorithmus in form von mt_rand() oder noch viel besser random_int() nutzt:

function secure_shuffle(array &$arr) {
  $len = sizeof($arr);

  for ($i = 0; $i < $len; ++$i) {
    $j = mt_rand(0, $len - 1);

    $tmp = $arr[$i];
    $arr[$i] = $arr[$j];
    $arr[$j] = $tmp;
  }
}

wie gesagt, falls du php 7 nutzt, dann solltest du statt mt_rand() lieber random_int() nutzen, weil das die besten zufallszahlen erzeugt.

außerdem kannst du ab php 7.1 die array werte auch ohne temporäre variablen mit der neuen "array destructuring syntax" nutzen:

[$arr[$i], $arr[$j]] = [$arr[$j], $arr[$i]];

so, das war mein senf zu dem thema. mal sehen wann die nächste frage auftaucht, und ob es nächstes mal wieder php ist, oder python, oder java, oder c#, oder c++, ... wie schon so oft all die anderen male zuvor. ;)

servus!

so ein alter existiert nicht.

wenn man natürlich durch gesundheitliche probleme eingeschränkt ist, vor allem im bezug auf demenz, wird es sicherlich sehr schwer werden, aber wenn interesse vorhanden ist, kann man immer lernen.

aussagen von älteren menschen wie "ach, dafür bin ich schon zu alt", ohne erkennbaren grund, sind eigentlich nur synonym für "ach, ich bin einfach nur zu faul" zu sehen.

ein bekannter hat mit 75 angefangen zu programmieren, hat eine nische gefunden, sich selbstständig gemacht und bessert sich seine rente damit nicht unerheblich auf.

zum lernen ist es nie zu spät.

servus!

die zweite variante ist besser!

da java sowieso nur mit referenzen arbeitet, macht das ganze aus performanz-sicht keinen unterschied, allerdings ist variante 2 die deutlich bessere im hinblick auf guten code.

du solltest variablen bei java nicht einfach deklarieren und dann rumgammeln lassen, sondern immer gleich initialisieren und das möglichst auch genau an dem ort, an dem sie verwendet werden. aus diesen beiden gründen ist variante 2 aus deinem beispiel vorzuziehen.

grundsätzlich sollten variablen immer nur viel sichtbarkeit wie nötig und so wenig wie möglich haben. deshalb deklariert man die zählvariable "i" auch in der regel innerhalb des for-schleifenkopfes und nicht irgendwo davor ... die einzige ausnahme ist, wenn man sie danach noch mit dem wert des letzten durchgangs verwenden möchte.

das gilt aber auch nicht immer für alle programmiersprachen, sondern in diesem falle nur für java. bei c++ gäbe es auch kaum performanz-unterschiede, wenn es sich bei der objekt-variablen um eine referenz handeln sollte, aber falls nicht, kann bei C++ mit kopiersemantik (evtl. sogar mit verschiebesemantik) optimiert werden, was je nach anwendungsfall gerne mal hundert mal schneller ist, und weswegen in diesem speziellen falle die variante 1 aus deinem codebeispiel vorzuziehen wäre.

da java aber nur referenzen kennt und auf unterer ebene nix vom verschieben bzw. kopieren weiß, solltest du dich auf alle fälle für die zweite variante entscheiden.

im übrigen sind solche zeitmessungs-spielchen wie aus der anderen antwort totaler blödsinn. die sind immer so dermaßen ungenau, dass man mit den ergebnissen fast nichts anfangen kann, weil jegliche compileroptimierungen und millionen von randeffekten überhaupt nicht berücksichtigt werden.

aus diesem grunde solltest du zeitmessungs-schleifen ganz schnell vergessen und dich mit den profiling-funktionen deiner IDE vertraut machen. nur damit sind halbwegs aussagekräfitge zahlen zu erhalten.

aber auch hierbei sind minimalste zeitunterschiede oft auf eine implementierung der jvm und des jit-compilers zurück zuführen, welche ständig weiter optimiert werden, und deine optimierungen von heute evtl. schon morgen zu einer art bremse mutieren.

deshalb optimiere lieber an anderen zeitkritischen stellen und gewöhne dir ansonsten einen guten, ordentlichen und sauberen programmierstil an. da wirst du langfristig sehr viel mehr von haben!

servus!

wenn es nur 100000 Zeilen sind und wir von einer durchschnittlichen länge von 80 größtenteils ascii-zeichen ausgehen, dann kommen wir auf 8mb speicherbedarf.

an deiner stelle würde ich den gesamten dateiinhalt einmalig am anfang des programms in den speicher laden - entweder als dicken fetten block, oder als ArrayList welche die einzelnen zeilen als string enthält - und dann darüber iterieren.

ich habe das gerade mal mit einer exakt 100000 zeilen langen wörterbuchdatei vom beolingus-projekt ausprobiert, mit diesem code:

import java.util.ArrayList;
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.InputStreamReader;

public class Main {

  private static final int ASSUMED_LINES = 100000;

  private static ArrayList<String> lines = new ArrayList<String>(ASSUMED_LINES);
  private static ArrayList<String> lower = new ArrayList<String>(ASSUMED_LINES);

  public static void readLines(String filename) throws Exception {
    lines.clear();
    lower.clear();

    try (BufferedReader br = new BufferedReader(
      new InputStreamReader(new FileInputStream(filename), "UTF-8"))
    ) {
      String line;
      while ((line = br.readLine()) != null) {
        lines.add(line);
        lower.add(line.toLowerCase());
      }
    }
  }

  public static String findLine(String substring) {
    substring = substring.toLowerCase();

    for (int i = 0; i < lines.size(); ++i) {
      if (lower.get(i).contains(substring)) {
        System.out.printf("%d: ", i);
        return lines.get(i);
      }
    }

    System.out.printf("X: ");
    return null;
  }

  public static void main(String[] args) throws Exception {
    readLines("/tmp/lines.txt");

    long start, end;

    final String[] words = new String[]{
      "building date",
      "grommet",
      "service load",
      "young voter",
      "beeline",
      "pre-emptive strike",
      "to take the blame",
      "cheap night-club",
      "continuation of one's journey",
      "autostereoscopic",
      "- this is never found -"
    };

    for (String word : words) {
      start = System.currentTimeMillis();
      String match = findLine(word);
      end = System.currentTimeMillis();

      System.out.printf("[%s]\n", word);
      System.out.println(match == null ? "- not found -" : match);
      System.out.printf("Time elapsed: %d millis\n\n", end - start);
    }
  }

}

damit erhalte ich diese ausgabezeilen:

9999: [building date]                                                
Baudatum {n} :: building date                                        
Time elapsed: 15 millis                                              

17976: [grommet]                                                     
Dichtkörper {m} | Dichtkörperöffnung {f} :: grommet | grommet cavity 
Time elapsed: 3 millis                                               

29999: [service load]                                                
Gebrauchslast {f} :: service load                                    
Time elapsed: 4 millis                                               

39999: [young voter]                                                 
Jungwähler {m}; Jungwählerin {f} :: young voter                      
Time elapsed: 5 millis                                               

49999: [beeline]                                                     
Luftlinie {f} :: bee-line; beeline                                   
Time elapsed: 3 millis                                               

59999: [pre-emptive strike]                                          
Präventivschlag {m} [mil.] | Präventivschläge {pl} :: pre-emptive strike | pre-emptive strikes                                            
Time elapsed: 4 millis                                               

69999: [to take the blame]                                           
Schuld {f} | jdm. an etw. die Schuld geben | die Schuld bekommen | die Schuld auf sich nehmen | die Schuld tragen :: blame | to put the blame on sb. for sth.; to lay the blame on sb. for sth. | to get the blame | to take the blame | to bear the blame                          
Time elapsed: 4 millis                                               

79999: [cheap night-club]                                            
Tingeltangel {n} :: cheap night-club; honky-tonk                     
Time elapsed: 5 millis                                               

89998: [continuation of one's journey]
Weiterfahrt {f} :: continuation of one's journey
Time elapsed: 6 millis

99997: [autostereoscopic]
autostereoskopisch {adj} (TV) :: autostereoscopic
Time elapsed: 6 millis

X: [- this is never found -]
- not found -
Time elapsed: 7 millis

um eine halbwegs repräsentative übersicht zu erhalten, habe ich nach den Wörtern an 10000ster, 20000ster, 30000ster, ..., 90000ster und 100000ster stelle gesucht. Der schnitt liegt also bei ca. 5 millisekunden.

schneller wird es mit ArrayLists allerdings auch auf sehr schnellen aktuellen rechnern kaum werden, da ArrayLists eine denkbar ungeeignete datenstruktur für diesem fall sind.

wenn du noch schnellere ergebnisse haben willst, wirst du um bäume und hashtabellen nicht drum herum kommen können.

im übrigen ist java eine denkbar ungeeignete programmiersprache für deine textexperimente! viel viel besser dürfte da python geeignet sein. außerdem ist der obige code in python sicherlich nur einen bruchteil so groß und evtl. sogar noch etwas schneller.