Posted: März 21st, 2013 | Filed under: Java, Programmieren, Tutorials | Tags: absteigend, alphabetisch, ArrayList, aufsteigend, Collection, Collections, Java, List, Liste, sortieren | 8 Comments »
In Zukunft will ich mal wieder öfters was zum Thema Java schreiben. Ich werde versuchen ein Sammelsurium an Java Grundlagen zu erarbeiten so dass nach und nach eine Art Nachschlagewerk entsteht.
Anfangen will ich mit dem Sortieren von Listen welche Strings enthalten. Über die Klasse Collections besteht die Möglichkeit Listen automatisiert zu sortieren bzw. neu anzuordnen. Das folgende Beispiel beschreibt wie einfach dies zu realisieren ist.
Beispiel – ArrayList alphabetisch sortieren
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class SortableExample {
public static void main(String[] args) {
/* Liste anlegen, die Strings enthält */
List<String> namen = new ArrayList<String>();
/* Namen hinzufügen */
namen.add("Peter");
namen.add("Frank");
namen.add("Hans");
/* Liste alphabetisch aufsteigend sortieren (a...z) */
Collections.sort(namen);
/* Ausgabe: Frank Hans Peter */
for(String name : namen){
System.out.println(name);
}
/* Liste alphabetisch absteigend sortieren (z...a) */
Collections.sort(namen);
Collections.reverse(namen);
/* Ausgabe: Peter Hans Frank */
for(String name : namen){
System.out.println(name);
}
}
} |
Posted: Oktober 25th, 2011 | Filed under: Java, Programmieren | Tags: ArrayList, Collections, Java, List, mischeln, mischen, shuffle ArrayList, shuffle List, sort, sortieren, zufällig | 1 Comment »
Schon oft in meinem Programmierer-Dasein habe ich eine List oder eine ArrayList in Java zufällig mischen müssen. Das ganze geht ziemlich einfach. Die Klasse Collections bietet uns die Methode shuffle an. Folgendes Code-Beispiel zeigt wie:
import java.util.ArrayList;
import java.util.Collections;
public class ListZufaelligSortieren {
public static void main(String[] args) {
ArrayList<String> namensListe = new ArrayList<String>();
String name1 = new String("Peter");
String name2 = new String("Paul");
String name3 = new String("Maria");
String name4 = new String("Otto");
namensListe.add(name1);
namensListe.add(name2);
namensListe.add(name3);
namensListe.add(name4);
// List durcheinander mischen
Collections.shuffle(namensListe);
for(String name : namensListe){
System.out.print(name);
System.out.print(" ");
}
// Ausgabe: Maria Paul Otto Peter
}
} |
Posted: Januar 21st, 2011 | Filed under: Programmieren | Tags: ArrayList, Collection, Element löschen, Iterator, Java, java.util.ConcurrentModificationException, LinkedList, List, während Iteration | 7 Comments »
Oft kommt es vor dass man in Java während der Iteration über eine ArrayList oder eine LinkedList ein Element nach einem gewissen Kriterium heraus löschen will. Über die gewöhnliche Schleife for(String name : namen) geht dies jedoch nur über Umwege mit einer zweiten Hilfsliste. Löscht man Elemente während der Iteration mit obiger Schleife erhält man eine java.util.ConcurrentModificationException.
Folgende Lösung ist weitaus einfacher und effizienter. Hier wird nämlich ein Iterator verwendet und es ist möglich während der Iteration zu löschen:
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class ListRemoveDuringIteration {
public static void main(String[] args) {
List<String> namen = new ArrayList<String>();
namen.add("Peter");
namen.add("Paul");
namen.add("Maria");
namen.add("Frank");
for (Iterator<String> nameIter = namen.iterator(); nameIter.hasNext();){
String name = nameIter.next();
if(name.equals("Paul")){
nameIter.remove();
System.out.println("Paul wurde während der Iteration aus der Liste gelöscht!");
}
}
}
} |
Quelltextdatei herunterladen: ListRemoveDuringITeration.java
Posted: November 3rd, 2010 | Filed under: Programmieren | Tags: Beispiel, Checkbox, Example, JCheckBox, JList, List, ListCellRenderer, ListModel, toString(), Tutorial | 7 Comments »
Für mein neustes Programm jCalFilter, welches Einträge in einem Kalender im ICS-Format filtern kann, habe ich eine JList gebraucht in der ich Termine auswählen kann. Dafür eignete sich am Besten eine JList die JCheckboxes beinhaltet. Mit diesem kleinen Tutorial möchte ich euch zeugen wie ihr das realisieren könnt.
Das fertige Programm soll so aussehen:
Als Datenkapsel verwende ich ein Objekt Person welches lediglich die Informationen Vorname, Name und Alter abspeichert. Des weiteren bietet die Klasse Person noch eine toString()-Methode. In dieser wird der Text zurückgegeben der jeweils in der Liste angezeigt werden soll.
Person.java
public class Person {
private String name;
private String vorname;
private int alter;
public Person(String name, String vorname, int alter){
this.name = name;
this.vorname = vorname;
this.alter = alter;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getVorname() {
return vorname;
}
public void setVorname(String vorname) {
this.vorname = vorname;
}
public int getAlter() {
return alter;
}
public void setAlter(int alter) {
this.alter = alter;
}
@Override
public String toString() {
return vorname + " " + name + " (" + alter + ")";
}
} |
Nun kommen wir zum eigentlichen Kern der Implementierung. Die Klasse JCheckBoxList erbt einfach von JList. Diese beinhaltet einen ListCellRenderer in dem Formatierungen verändert werden können. Zusätzlich bietet die Klasse JCheckBoxList eine Methode selectAll() und deselectAll() an, um eben alle Häkchen zu setzten oder um die Auswahl aller Häkchen zu entfernen.
JCheckBoxList.java
import java.awt.Component;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import javax.swing.JCheckBox;
import javax.swing.JList;
import javax.swing.ListCellRenderer;
import javax.swing.ListSelectionModel;
import javax.swing.UIManager;
public class JCheckBoxList extends JList {
public JCheckBoxList() {
setCellRenderer(new CellRenderer());
addMouseListener(new MouseAdapter() {
public void mousePressed(MouseEvent e) {
int index = locationToIndex(e.getPoint());
if (index != -1) {
JCheckBox checkbox = (JCheckBox) getModel().getElementAt(
index);
checkbox.setSelected(!checkbox.isSelected());
repaint();
}
}
});
setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
}
protected class CellRenderer implements ListCellRenderer {
public Component getListCellRendererComponent(JList list, Object value,
int index, boolean isSelected, boolean cellHasFocus) {
JCheckBox checkbox = (JCheckBox) value;
if (isSelected) {
// checkbox.setBorderPainted(true);
// checkbox.setForeground(UIManager.getColor("List.selectionForeground"));
// checkbox.setBackground(UIManager.getColor("List.selectionBackground"));
} else {
// checkbox.setBorderPainted(false);
// checkbox.setForeground(UIManager.getColor("List.foreground"));
checkbox.setBackground(UIManager.getColor("List.background"));
}
return checkbox;
}
}
public void selectAll() {
int size = this.getModel().getSize();
for (int i = 0; i < size; i++) {
JCheckBox checkbox = (JCheckboxWithObject) this.getModel()
.getElementAt(i);
checkbox.setSelected(true);
}
this.repaint();
}
public void deselectAll() {
int size = this.getModel().getSize();
for (int i = 0; i < size; i++) {
JCheckBox checkbox = (JCheckboxWithObject) this.getModel()
.getElementAt(i);
checkbox.setSelected(false);
}
this.repaint();
}
} |
Um die Verbindung zwischen einer Person und der Checkbox herzustellen habe ich das Objekt JCheckboxWithObject erstellt. Diese Klasse erbt von JCheckBox aber beinhaltet zusätzlich noch ein Objekt vom Typ Object in dem man irgendein Objekt ablegen kann. In unserem Fall ein Objekt vom Typ Person. Die Checkbox wird, im Konstruktor und der Setter-Methode, nun mit dem Rückgabestring der toString()-Methode des jeweiligen Objektes(Person) beschriftet.
JCheckboxWithObject.java
import javax.swing.JCheckBox;
public class JCheckboxWithObject extends JCheckBox{
private Object object;
public JCheckboxWithObject (Object object){
this.object = object;
this.setText(object.toString());
}
public Object getObject() {
return object;
}
public void setObject(Object object) {
this.object = object;
this.setText(object.toString());
}
} |
Nun kann die Datenstruktur wie folgt angewendet werden. Das Ergebnis seht ihr ja oben.
Main.java
import javax.swing.DefaultListModel;
import javax.swing.JFrame;
import javax.swing.SwingUtilities;
import javax.swing.UIManager;
public class Main {
{
// Set Look & Feel
try {
UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
} catch (Exception e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
SwingUtilities.invokeLater(new Runnable() {
public void run() {
// Fenster
JFrame frame = new JFrame();
// Checkboxliste
DefaultListModel personenListModel = new DefaultListModel();
JCheckBoxList list = new JCheckBoxList();
list.setModel(personenListModel);
// Daten hinzufügen
Person hans = new Person("Wurst", "Hans", 24);
Person peter = new Person("Müller", "Peter", 36);
Person klaus = new Person("Wagner", "Klaus", 29);
JCheckboxWithObject hansCheckbox = new JCheckboxWithObject(hans);
JCheckboxWithObject peterCheckbox = new JCheckboxWithObject(
peter);
JCheckboxWithObject klausCheckbox = new JCheckboxWithObject(
klaus);
personenListModel.addElement(hansCheckbox);
personenListModel.addElement(peterCheckbox);
personenListModel.addElement(klausCheckbox);
frame.getContentPane().add(list);
frame.setVisible(true);
frame.setTitle("JCheckbox in JList");
frame.setSize(200, 200);
}
});
}
} |
Download
Hier könnt ihr euch denn ganzen Quellcode herunterladen.
Ein Karlsruher Bloggt!
