Einerseits gibst du nicht an, in welchem Tabellenblatt der Range ausgewählt werden soll, andererseits kann VBA mit dem Range nichts anfangen:

Range("Cells(AZeile + Anzahl, ASpalte - Anzahl):Cells(AZeile + Anzahl, ASpalte + Anzahl)")

Wenn du den Range so umbaust, dass es funktioniert, läufst du direkt ins nächste Problem, dass du eine Endlosschleife hast, weil weder ADZ, noch Anzahl in der Schleife verändert werden.

Private Sub Zeichnen_Click()
    ' Daten laden
    Dim AZeile As Integer, ASpalte As Integer, ADZ As Integer
    AZeile = [TbAZ]
    ASpalte = [TbAS]
    ADZ = [TbADZ]
    
    ' Tabellenblatt referenzieren
    Dim tbl As Worksheet
    Set tbl = ActiveSheet
    
    ' Tabellenblatt beschreiben
    Dim aktuelleZeile As Integer
    For aktuelleZeile = AZeile To AZeile + ADZ
        Dim startZelle As Range, endZelle As Range, spalteOffset As Integer
        spalteOffset = aktuelleZeile - AZeile ' spalteOffset = Wie weit es nach links/rechts gehen soll
        Set startZelle = tbl.Cells(aktuelleZeile, ASpalte - spalteOffset)
        Set endZelle = tbl.Cells(aktuelleZeile, ASpalte + spalteOffset)
        tbl.Range(startZelle.AddressLocal & ":" & endZelle.AddressLocal).Value = "*"
    Next aktuelleZeile
End Sub
...zur Antwort

Der einzige Fehler, der mir auffällt, ist dieses "if (bombeliegt[koordx][koordy] = false) {", was schon gesagt wurde. Da musst du halt entweder das = durch == austauschen oder du nimmst den Vergleich raus, weil in dem Array ja sowieso schon booleans gespeichert sind.

Wenn du ein Boolean-Array erzeugst, werden die Felder automatisch alle mit false initialisiert, also brauchst du da nicht großartig was machen.

Was ich dir aber eigentlich empfehlen will: So, wie es aussieht, willst du einen Minesweeper-Klon bauen. Die jeweiligen Felder können also mehrere Zustände haben (leer, leer aber angeklickt, versteckte Bombe, Bombe angeklickt, mit einer Flagge markiert, Anzahl der umliegenden Bomben etc.). Es wäre aber schlecht, wenn du für jede der Eigenschaften ein Array baust, also solltest du eine Klasse bauen, die die ganzen Eigenschaften für jede Zelle speichern kann. Davon kannst du dann Objekte erzeugen, die du in dein Array packen kannst.

...zur Antwort

Hmm, einerseits würde man sowas normalerweise nicht in eine einzelne Zeile schreiben, andererseits hört die Schleife dadurch auf, dass der int überläuft und ein negatives Ergebnis rauskommt, obwohl kein negatives Ergebnis da sein sollte.

Und ich hab das Gefühl, dass mit der Methode ein mathematisches Problem (vermutlich ähnlich der Collatz-Vermutung) ausgerechnet werden soll, was aber bedeuten würde, dass da noch Bedingungen fehlen (wenn q gerade ist, tue dies, ansonsten tue das...)

...zur Antwort

Die zweite Version ist schon fast richtig. Du solltest allerdings den String "original" erst erzeugen, nachdem du Gruß und Anrede festgelegt hast. Also direkt über dem if, mit dem du den label1.Text einstellst. Außerdem muss der label1.text natürlich aus der Instanziierung vom String original raus.

String original = Gruß + textBox1.Text + " Wie geht es " + anrede;
if (checkBox1.Checked) label1.Text = original.ToUpper()
else label1.text = original;

oder mit interpolierten Strings und dem ternären Operator:

string original = $"{Gruß} {textBox1.Text}, wie geht es {anrede}?";
label1.Text = checkBox1.Checked? original.ToUpper() : original;
...zur Antwort

Entweder du machst eine Schleife für alle Zahlen zwischen 70 und 700 und prüfst für jede Zahl mittels Modulo, ob sie durch 7 teilbar ist, oder du überlegst dir kurz, welche Zahlen durch 7 teilbar sind und kommst zu dem Schluss, dass das jede siebte Zahl ist. Also 70, 77, 84, 91, 98 etc. Also du kannst auch eine Schleife machen, die den Zähler jedes mal um 7 erhöht und alles ausgibt.

for (int i = 70; i<=700; i+=7) System.out.print(i + " ");
...zur Antwort

Mal von der Einrückung abgesehen (auf die bin ich beim lesen der Frage selbst reingefallen): Ich würde dir empfehlen, nicht den Dateinamen auszulesen, sondern die Datei-Objekte selbst im Array zu speichern. Das ist meistens besser, wenn du damit weiter arbeiten willst.

Das "Get-Childitem" (ich kürze das immer ab mit "dir") hat auch noch einen Parameter -File, mit dem du sagen kannst, dass du nur Dateien und keine Ordner zurückkriegen willst. Und du kannst den Filter auch da direkt angeben.

Also z.B.

$source = 'E:\Powershell_Skripts\99 - Ordner für Tests\Source\MFU\'

// Alle *.dfq Dateien in dem Ordner suchen
$file_list = @(dir $source "*.dfq")

// Alle Dateien ausgeben, die vor mehr als einer Minute bearbeitet wurden
($file_list | where LastAccessTime -le (Get-Date).AddMinutes(-1)).FullName


...zur Antwort

Wenn er einfach nur auf der Scratch-Webseite suchen muss und sieht, dass da genau so ein Programm, wie deins ist, wird er es natürlich merken. Wenn dein Projekt vielleicht sogar ein Remix eines anderen Projekts ist, ist es natürlich sehr offensichtlich, dass du es nicht selbst gemacht hast.

Eine kleine Anekdote aus meiner Ausbildungszeit: Ich habe damals eine Projektarbeit mit einem Klassenkameraden zusammen gemacht. Wir haben das Projekt über GitHub geteilt, damit wir beide dran arbeiten konnten. Wir haben eine 6 gekriegt, weil "den Quelltext habt ihr 1:1 aus dem Internet kopiert".

...zur Antwort

Das eigentliche Problem wurde ja schon genannt. Wenn du char minus char rechnest, kommt ein int raus und das wird nicht implizit in ein char umgewandelt, wenn du versuchst, es einer char-Variable zuzuweisen. Lösung "wort = (char)(wort - 32);"

Was ich aber eigentlich sagen will:

Erstmal das offensichtliche: mit eingabe.ToUpperCase() kannst du die Eingabe in Großbuchstaben umwandeln, ohne dich um die ASCII-Codes kümmern zu müssen. Dadurch werden dann z.B. auch Umlaute umgewandelt, die dein jetziger Code nicht umwandeln würde.

Dann eine Sache, die wichtig ist, wenn du das mal professionell machen willst: Gib den Variablen, Methoden, Klassen etc. sinnvolle Namen. text() = umwandlungGross(), leer = ergebnis, wort = buchstabe.

Achte drauf, dass die Einrückungen übersichtlich sind (das meiste macht Eclipse automatisch. Du kannst aber auch Strg+Shift+F drücken, um den Quelltext einmal komplett automatisch formatieren zu lassen)

Du kannst dir das If einfacher machen, indem du if (wort >= 'a' && wort <= 'z') machst. Das gleiche bei der Berechnung: wort = wort - 'a' + 'A';

...zur Antwort

Wenn du einfach nur zwei int-Werte hast, kannst du mit Math.min die kleinere Zahl kriegen:

int a = 1980;
int b = 1990;

int oldest = Math.min(a,b);

Wenn es Datum-Objekte sind, gibt es die Funktionen .isBefore und .isAfter, mit denen du das Ältere rauskriegen kannst:

LocalDate a = LocalDate.of(1980, 1, 1);
LocalDate b = LocalDate.of(1990, 1, 1);

LocalDate oldest = a.isBefore(b) ? a:b;

oder mit if:

LocalDate a = LocalDate.of(1980, 1, 1);
LocalDate b = LocalDate.of(1990, 1, 1);

LocalDate oldest = a;
if (b.isBefore(oldest)) 
	oldest = b;

Ich denke aber mal, dass du eine ganze Liste mit irgendwelchen Objekten hast, von denen in einer Eigenschaft das Erscheinungsdatum steht und du aus der Liste das älteste haben willst. Das würde ich am ehesten mit einem Stream lösen:

import java.time.*;
import java.util.*;


record Movie(String name, LocalDate publishedDate) {}


public class SortDates {
    public static void main(String[] args) {
        // Liste von Filmen erzeugen
        List<Movie> movies = List.of(
            new Movie("Doctor Strange in the Multiverse of Madness", LocalDate.of(2022, 5, 6)),
            new Movie("Top Gun 2: Maverick", LocalDate.of(2022, 5, 27)),
            new Movie("Jurassic World: Dominion", LocalDate.of(2022, 6, 10)),
            new Movie("Thor 4: Love and Thunder", LocalDate.of(2022, 7, 7)),
            new Movie("Mission: Impossible 7", LocalDate.of(2022, 9, 30)),
            new Movie("Avatar 2", LocalDate.of(2022, 12, 16))
        );
        
        // den Film mit dem kleinsten "publishedDate" raussuchen
        Movie oldest = movies.stream().min(Comparator.comparing(Movie::publishedDate)).get();
        
        // und ausgeben
        System.out.printf("Der älteste Film ist \"%s\". Er ist am %td.%<tm.%<tY erschienen.%n", oldest.name(), oldest.publishedDate());
    }
}
...zur Antwort

Wäre einfacher, das Handy einfach irgendwo zu lassen, wo es keinen Verdacht erweckt und dann ohne Handy zum verbotenen Ort zu gehen.

...zur Antwort

Also du willst alle Dateien in allen Unterordnern haben und dazu jeweils den Namen vom Ordner in dem die Dateien liegen (ohne den kompletten Pfad)?

$files = dir C:\temp\ -Recurse -File | foreach {$_.Directory.Name + "\" + $_.Name}

Ich weiß zwar nicht, was du vorhast, aber meistens ist es besser, direkt mit den File-Objekten weiterzuarbeiten und nicht mit den Strings.

...zur Antwort

Wieder mehrere Probleme.

  1. In deiner for-Schleife gehst du jeden Buchstaben und nicht jedes Wort durch. Also, wenn du z.B. im Text "Ich bin ein Berliner" nach "ch" suchst, prüft deine Routine in der ersten Runde, ob "Ich bin ein Berliner" mit "ch" anfängt und in der nächsten Runde sucht er im Text "ch bin ein Berliner" und packt das Ergebnis in das Array.
  2. Der Grund für das Problem, was du gefunden hast: Wenn du ein Ergebnis gefunden hast, kürzt du die Variable text auf das Ergebnis. Also bei meinem Beispiel oben hättest du dann das "ch" von "ch bin ein Berliner" gefunden und setzt dann text auf "ch", wodurch du natürlich nicht noch mehr findest.

Ich geb dir mal wieder zwei Varianten. Einmal, wie ich es normalerweise machen würde, mit regulären Ausdrücken:

public static String[] getWordsStartWith(String text, String start) {
    return Pattern
            // Das Symbol \\b bedeutet "word boundary", also Start oder Ende eines Wortes
            // Danach starten wir eine "capture group" (die Klammern), womit wir sagen,
            // dass wir den Teil im Ergebnis haben wollen
            // Dann kommt das, was wir suchen und danach noch beliebig viele "word characters"
            // also Buchstaben oder Zahlen
            // Case_Insensitive ist klar. Das "Unicode_Character_Class" sorgt dafür, dass z.B.
            // auch Umlaute als Buchstaben erkannt werden.
            .compile("\\b(" + Pattern.quote(start) + "\\w*)", Pattern.CASE_INSENSITIVE + Pattern.UNICODE_CHARACTER_CLASS)
            .matcher(text)
            .results()
            // Diesmal wollen wir nur das haben, was jeweils in der ersten "capture group" gefunden wurde
            .map(match -> match.group(1))
            .toArray(String[]::new);
}

und einmal die Alternative per Scanner:

public static String[] getWordsStartWith(String text, String start) {
    // Erstmal text und start in Kleinbuchstaben umwandeln
    text = text.toLowerCase();
    start = start.toLowerCase();
    
    // Der Scanner kann uns gleich den Text immer Wortweise geben
    Scanner scanner = new Scanner(text);
    
    // Mit der List müssen wir uns nicht darum kümmern, dass wir
    // von Anfang an die richtige Größe wissen müssen.
    List<String> result = new LinkedList<>();
    
    // Wir gehen jedes Wort im Scanner durch
    while (scanner.hasNext()) {
        String word = scanner.next();
        // und fügen es ans Ergebnis an, falls es mit <start> anfängt
        if (word.startsWith(start))
            result.add(word);
    }
    scanner.close();
    
    // Zum Schluss müssen wir es noch in ein Array umwandeln, bevor
    // wir es zurückgeben.
    return result.toArray(String[]::new);
}
...zur Antwort

Ein paar Probleme:

  1. Dein Ergebnisarray "ia" erstellst du mit der gleichen Länge, wie das Wort, in dem du suchst. In deinem Beispiel ist das Array also 6 Stellen lang, auch wenn du nur zwei Ergebnisse findest.
  2. Du prüfst in jedem Schleifendurchlauf, ob find irgendwo in s auftaucht. Also wenn der Suchbegriff nur einmal enthalten ist, wird das if bei jedem Schleifendurchlauf ausgeführt.

Den Rest hat dir regex9 schon erklärt.

Ich würde den String am ehesten mit regulären Ausdrücken durchsuchen. Da wird dir für jeden Fund ein Objekt ausgespuckt, was allerlei Infos hat (wo fängt es an, wo hört es auf, welche Gruppen sind drin, wo fangen die jeweils an oder hören auf...) und du kannst die einfach in ein int[] packen.

Ausführlich mit Kommentaren (man könnte das auch in einer Zeile machen):

public static int[] getIndicies(String s, String find) {
    // Wir benutzen ein Regex-Pattern
    return Pattern
            // und suchen nach find
            // Das "Pattern.quote" ist dafür da, dass man auch nach Zeichen
            // suchen kann, die eigentlich Regex-Steuerzeichen sind
            // Mit Pattern.CASE_INSENSITIVE ist Groß-/Kleinschreibung egal
            .compile(Pattern.quote(find), Pattern.CASE_INSENSITIVE)
            // im String s
            .matcher(s)
            // Dann nehmen wir uns alle Ergebnisse
            .results()
            // Und nehmen uns daraus die start-indizes
            .mapToInt(result -> result.start()) // oder MatchResult::start
            // und wandeln das in ein int[] um, damit wir es zurückgeben können
            .toArray();
}

Falls das eine Schulaufgabe ist und du keine regulären Ausdrücke benutzen darfst und auch keine Objekte, wie z.B. eine List benutzen darfst, kannst du die Funktion so bauen, dass sie immer ab dem letzten Vorkommen des Suchbegriffs weitersucht. Und du musst mitzählen, wie viele Ergebnisse du gefunden hast, damit du am Ende nur die gefundenen Ergebnisse zurückgibst:

public static int[] getIndicies(String s, String find) {
    // beide Parameter in lowerCase umwandeln, damit die Suche ohne
    // Beachtung der Groß-/Kleinschreibung geschieht
    s = s.toLowerCase();
    find = find.toLowerCase();
    // Ergebnisarray erstellen. Die maximale Anzahl an Ergebnissen
    // kann nur so viel sein, wie der String s lang ist.
    int[] indices = new int[s.length()];
    // in count zählen wir einfach, wie oft was gefunden wurde
    int count = 0;
    
    // Suchstring suchen
    int previousIndex = s.indexOf(find);
    // So lange der Suchstring gefunden wird
    while (previousIndex >= 0) {
        // letzten Fund zum Array hinzufügen
        // und Zähler erhöhen
        indices[count++] = previousIndex;
        // und ab dem letzten Fund nochmal suchen
        previousIndex = s.indexOf(find, previousIndex + 1);
    }
    
    // Nur die gefundenen Stellen zurückgeben 
    return Arrays.copyOf(indices, count);
}
...zur Antwort

Naja, du hast fest in deinem Code stehen, dass er "0.1+ BTC" anzeigen soll. Die URL, die du dir da rausgesucht hast, gibt leider eine komplette Webseite zurück. Wenn du Daten automatisch verarbeiten willst, geht das einfacher mit einer Web-Api (z.B. die von Blockchain.info. Die Dokumentation kannst du dir hier ansehen: https://www.blockchain.com/api/blockchain_api)

Ich weiß nicht, ob du mit deinem Programm am Ende nur deine Freunde verarschen willst, oder ob du wirklich denkst, dass du so an Bitcoins kommst, aber mit der Bitcoin-Adresse kannst du nur den Kontostand der jeweiligen Adresse anschauen. Um an die Bitcoins zu kommen, bräuchtest du den privaten Schlüssel zu der Adresse.

So kannst du z.B. den neuesten Block auslesen und kriegst damit gleich mehrere Adressen mit Bitcoins (ohne dass du dich durch haufenweise leere Konten kämpfen musst)

import requests

def get_block_outputs(block_hash):
    block_data = requests.get("https://blockchain.info/rawblock/" + block_hash).json()
    transactions = block_data["tx"]
    out_data = [tx["out"] for tx in transactions]
    # Die Scripts von Transaktionen ohne Adresse können leider nicht berücksichtigt werden
    out_addresses = [record["addr"] for output in out_data for record in output if "addr" in record.keys()]
    return out_addresses

# Neuesten Block ermitteln und alle Ausgangsadressen extrahieren
latest_block_hash = requests.get("https://blockchain.info/latestblock").json()["hash"]
addresses = get_block_outputs(latest_block_hash)

# Immer nur 100 Adressen auf einmal einlesen
balance_data = dict()
while len(addresses) > 0:
    balance_data.update(requests.get("https://blockchain.info/balance?active=" + "|".join(addresses[:100])).json())
    addresses = addresses[100:]

# Ergebnisse ausgeben    
for key, value in balance_data.items():
    print(f"{key}: {value['final_balance']} sats ({value['final_balance']/100000000} BTC)")

print("======================================================")
total = sum([address["final_balance"] for address in balance_data.values()])
print(f"Total: {total/100000000} BTC")
...zur Antwort

Schön mit Kommentaren:

public static void main(String[] args) {
	Scanner scanner = new Scanner(System.in); 
	scanner.useDelimiter("\\D+");
	
	// Zahlen einlesen
	System.out.println("Bitte Zahlen eingeben (0 = Ende)");
	int[] numbers = scanner.tokens().mapToInt(Integer::parseInt).takeWhile(num->num!=0).limit(20).toArray();
	scanner.close();
	
	// Prüfen, ob 0 als erstes eingegeben wurde
	if (numbers.length == 0) {
		System.out.println("Naja, du musst auch schon was anderes als 0 eingeben, wenn ich was tauschen soll.");
		return;
	}
	
	// Zahlen tauschen
	for (int i = 1; i<numbers.length; i+=2) {
		int temp = numbers[i-1];
		numbers[i-1] = numbers[i];
		numbers[i] = temp;
	}
	
	// Array ausgeben
	System.out.println("Tadaa, ein Ergebnis: " + Arrays.toString(numbers));
}
...zur Antwort

Das Konzept mit den Cmdlets ist am Anfang ziemlich gewöhnungsbedürftig. Vor allem weiß man am Anfang nicht, welche Cmdlets die Daten von anderen Cmdlets über die Pipe empfangen und verarbeiten können. Und an die Vergleichsoperatoren muss man sich auch erst gewöhnen.

Um den Umstieg von Batch zu Powershell ein bisschen einfacher zu haben, gibt es viele Aliase von Funktionen, die unter Batch bekannt sind (dir, cd, md, rmdir, del, echo, cls, copy, move etc.), die zumindest ähnlich zu bedienen sind, wie unter Batch.

Man kann, wie in Batch einfach Programme starten, indem man den Namen eingibt, man kann aber z.B. auch das "Laufwerk" HKLM aufrufen und damit in der Registry navigieren, als wenn man in der Dateistruktur wäre.

Und Powershell ist objektorientiert. Also kann man mit Powershell alles machen, was man auch in C# machen kann (auch wenn es in Powershell teilweise ziemlich umständlich ist).

Powershell ist also aus ziemlich vielen Dingen zusammengewürfelt, aber nicht wirklich schwerer, als andere Sprachen.

...zur Antwort

Also der Eintrag aus Datei 2 soll über das Haustier mit dem jeweiligen Eintrag aus Datei 1 gematcht werden? (z.B. wenn aus Datei 2 der Eintrag mit dem Haustier Papagei ausgegeben wird, soll dazu der Eintrag mit Papagei aus Datei 1 ausgegeben werden?)

Das wäre (im größeren Maßstab) am ehesten was für eine SQL-Datenbank. Java hat leider keine integrierten Klassen, um CSV-Dateien zu verarbeiten, deshalb muss man da etwas selbst basteln.

Ich würde die Einträge einfach als records anlegen (das sind im Prinzip Klassen, die hauptsächlich zum Speichern von Daten da sind und sonst nicht viel können), die CSV mit einer selbst programmierten Funktion einlesen und dann halt vergleichen und passende Einträge ausgeben:

import java.io.File;
import java.io.FileNotFoundException;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.List;
import java.util.Scanner;

public class CSVTools {
	public static void main(String[] args) throws FileNotFoundException {
		// Personen einlesen
		Scanner personenCsv = new Scanner(new File("C:\\temp\\Personen.csv"), "utf-8");
		personenCsv.useDelimiter("\\R"); // pro Token eine ganze Zeile einlesen
		List<Person> personen = personenCsv.tokens()
				.skip(1) // Überschriftenzeile überspringen
				.map(Person::parse) // Jede Zeile mit der parse-Funktion in Person übersetzen
				.toList(); // Als Liste speichern
		
		// PersonenEigenschaften einlesen
		Scanner personenEigenschaftenCsv = new Scanner(new File("C:\\temp\\PersonenEigenschaften.csv"), "utf-8");
		personenEigenschaftenCsv.useDelimiter("\\R"); // pro Token eine ganze Zeile einlesen
		List<PersonEigenschaft> personenEigenschaften = personenEigenschaftenCsv.tokens()
				.skip(1) // Überschriftenzeile überspringen
				.map(PersonEigenschaft::parse) // Jede Zeile mit der parse-Funktion in PersonEigenschaft übersetzen
				.toList(); // Als Liste speichern
		
		// Zusammengehörige Einträge ausgeben (Matching über Haustiere)
		for (Person person: personen) {
			// Die jeweilige Person ausgeben
			System.out.println(person);
			// Die dazugehörigen Eigenschaften ausgeben (kann auch keine oder mehrere sein)
			personenEigenschaften.stream()
						.filter(eigenschaft->eigenschaft.haustier().equals(person.haustier()))
						.forEach(System.out::println);
			System.out.println(); // Eine Leerzeile, damit man die zusammengehörenden Einträge besser sehen kann
		}
	}
}

record Person(int nummer, String vorname, int alter, String haarfarbe, String land, String haustier) {
	public static Person parse(String line) {
		String[] fields = line.split("'?;\\s*'?"); // Zeile teilen bei Semikolon mit optionalen Leerzeichen und Hochkommas
		return new Person(
				Integer.parseInt(fields[0]),
				fields[1],
				Integer.parseInt(fields[2]),
				fields[3],
				fields[4],
				fields[5].replace("'", "") // Hochkomma am Ende vom Haustier entfernen
		);
	}
}

record PersonEigenschaft(int nummer, String traumberuf, String lieblingsessen, String hobby, String haustier) {
	public static PersonEigenschaft parse(String line) {
		String[] fields = line.split("'?;\\s*'?"); // Zeile teilen bei Semikolon mit optionalen Leerzeichen und Hochkommas
		return new PersonEigenschaft(
				Integer.parseInt(fields[0]),
				fields[1],
				fields[2],
				fields[3],
				fields[4].replace("'", "") // Hochkomma am Ende vom Haustier entfernen
		);
	}
}

// Da du irgendwas mit der SacramentocrimeJanuary2006.csv machen willst, ist hier der passende record dazu
record Crime (LocalDateTime cdatetime, String address, int district, String beat, int grid, String crimedescr, int ucr_ncic_code, double latitude, double longitude) {
	public static Crime parse(String line) {
		String[] fields = line.split(",");
		return new Crime(
				LocalDateTime.parse(fields[0], DateTimeFormatter.ofPattern("M/d/y H:m")),
				fields[1],
				Integer.parseInt(fields[2]),
				fields[3].strip(), // Die ganzen Leerzeichen entfernen
				Integer.parseInt(fields[4]),
				fields[5],
				Integer.parseInt(fields[6]),
				Double.parseDouble(fields[7]),
				Double.parseDouble(fields[8])
		);
	}
}

Um noch auf die Frage im Text einzugehen, wie du auf die einzelnen Elemente einer ArrayList zugreifen kannst:

Statt z.B. person = personen[5] machst du person = personen.get(5). Und statt personen[5] = person machst du personen.set(5, person);

...zur Antwort