# charsequence mit collections



## kenux (23. Mai 2009)

Hallo,
habe das untere Programm geschrieben, bei diesem Programm wird die charsequence implementiert. Es werden Zeichen gespeichert und diese werden dann wieder mittels definierter funktionen ausgegeben. Jetzt lautet meine Frage: Wie kann ich das Programm so umschreiben, dass die Zeichen mittels collections, wie z.B List<String> gespeichert und ausgegeben wird?

```
import java.util.*;

// Klasse CharSeq implementiert das Interface CharSequence
public class CharSeq implements CharSequence {
	
	// private-Attribut als String
	private String seq;
	
	// Konstruktor
	public CharSeq(String seq) 
	{
		this.seq = seq;
	}

	/**
	 * Liefert das Zeichen aus der Kette zurück, das an der 
	 * Position index steht
	 */
	// Methode charAt()
	public char charAt(int index) 
	{
		// auf Gueltigkeit pruefen
		if (index > -1 && index < seq.length()) 
		{
			return seq.charAt(index);
		} 
		else {
			System.out.println("Index ungueltig!");
		}
		return 0;
	}
	
	/**
	 * Liefert die Anzahl der Zeichen zurück, 
	 * die die Zeichenkette enthaelt
	 */
	// Methode length()
	public int length() 
	{
		return seq.length();
	}

	/**
	 * Liefert den Teil der Zeichenkette zurueck, der von der 
	 * Position start bis zur Position end liegt
	 */
	// Kontsruktor/Methode subSequence()
	public CharSequence subSequence(int start, int end) 
	{
		if (start > end) 
		{
			System.out.println
			("Endindex muss gleich oder groesser sein als Startindex!");
		} 
		else if (start < 0) {
			System.out.println("Ungueltiger Startindex!");
		} 
		else if (end > seq.length()) {
			System.out.println("Ungueltiger Endindex!");
		}
		
		return seq.subSequence(start, end);
	}

	/**
	 * Liefert die Zeichenfolge als String zurück
	 */
	// Methode toString()
	public String toString() 
	{
		return new String(seq);
	}


// Hauptprogramm
public static void main(String[] args) {
	
	CharSeq chseq = new CharSeq("kenux");
	for(int i = 0; i < chseq.length(); i++) 
	{
		System.out.println("charAt " + i + ": " + chseq.charAt(i));
	}
	
	// Laenge der Zeichen ausgeben
	System.out.println("Laenge der Zeichen: " + chseq.length());
	
	// einen Teil der Zeichenkette ausgeben
	System.out.println("Teil der Zeichenkette: " + chseq.subSequence(3, 5));
	
	// als String ausgeben 
	System.out.println("Als String: " + chseq.toString());
	
	/*
	// Collection
	List<String> liste = new ArrayList<String>();
	liste.add("hallo");
	
	for (String str : liste)
	{
		System.out.println(str);
	}
	*/

	}
}
```


----------



## Marco13 (23. Mai 2009)

Beschreib mal genauer. Eine List<Character> meinst du ja vermutlich nicht...?!


----------



## kenux (23. Mai 2009)

Marco13 hat gesagt.:


> Beschreib mal genauer. Eine List<Character> meinst du ja vermutlich nicht...?!



Also die Zeichen, in diesem Fall "kenux" sollen intern als Collection-Klassen gespeichert werden. Ob es mit List<String> oder List<CahrSeq> gemacht werden muss das weiß ich leider nicht


----------



## Landei (23. Mai 2009)

Wenn, dann ergibt eigentlich nur List<Character> Sinn, weil man ja nicht *mehrere* Char-Sequenzen speichern will.

```
public class CharSeq implements CharSequence {

	private List<Character> seq = new ArrayList<Character>();
	
	// Konstruktor
	public CharSeq(String seq) 
	{
                for(c : seq.toCharArray()) {
                    this.seq.append(c);
                }
	}
   
        //noch'n Konstruktor
        public CharSeq(List<Character> seq) {
            this.seq.addAll(seq);
        }

        //und noch einer
	public CharSeq(char[] seq) 
	{
               for(c : seq) {
                    this.seq.append(c);
               }
	}

	/**
	 * Liefert das Zeichen aus der Kette zurück, das an der 
	 * Position index steht
	 */
	public char charAt(int index) 	{
		// auf Gueltigkeit pruefen
		if (index > -1 && index < length()) {
			return seq.get(index);
		} else {
			throw new IndexOutOfBoundsException("Index ungueltig!");
		}
	}
	
	/**
	 * Liefert die Anzahl der Zeichen zurück, 
	 * die die Zeichenkette enthaelt
	 */
	public int length()  {
              return seq.size();
        }

	/**
	 * Liefert den Teil der Zeichenkette zurueck, der von der 
	 * Position start bis zur Position end liegt
	 */
	public CharSequence subSequence(int start, int end) 	{
               if (start > end) {
                     throw new IndexOutOfBoundsException("Endindex muss gleich oder groesser sein als Startindex!");
                } else if (start < 0) {
                       throw new IndexOutOfBoundsException("Ungueltiger Startindex!");
                } else if (end > length()) {
                       throw new IndexOutOfBoundsException("Ungueltiger Endindex!");
                }
                return new CharSeq(seq.subList(start, end));
         }

	/**
	 * Liefert die Zeichenfolge als String zurück
	 */
	// Methode toString()
	public String toString() 
	{
              StringBuilder sb = new StringBuilder();
              for(c : seq) {
                 sb.append(c);
              }
	      return sb.toString();
	}
}
```

...oder so ähnlich...


----------



## kenux (24. Mai 2009)

danke für die Antwort Landei.

wie kann ich denn jetzt im Hauptprogramm die Zeichen hinzufügen?


----------



## SlaterB (24. Mai 2009)

was bedeutet es, 'etwas hinzuzufügen'?

du kannst offensichtlich im Konstruktor einen String übergeben,
falls danach noch weitere Zeichen hinzukommen sollen, brauchst du eine add-Methode


----------



## kenux (24. Mai 2009)

ich will "kenux" hinzufügen und dann folgende Methoden abfragen im Hauptprogramm:

charAt()
length()
subSequence()
toString()

ich habs schon mehrere mal versucht doch immer kommen fehlermeldungen


----------



## SlaterB (24. Mai 2009)

und diese Versuche + Fehlermeldungen willst du nun noch detailliert darlegen
oder soll die jemand hellsehen?

Komplettlösung wird es eher nicht geben, obwohl Landei natürlich schon viel geschrieben hat


----------



## kenux (24. Mai 2009)

wenn ich folgendes im hauptprogramm eingebe:

List<CharSeq> liste = new ArrayList<CharSEq>("kenux");

bekomm ich Konstruktor-Fehlermeldungen.

Wenn ich
List<Character> liste = new ArrayList<Character>();
versuche, dann werden die oben genannten Methoden (cahrAt, length...) nicht erkannt


----------



## SlaterB (24. Mai 2009)

weder List noch ArrayList verfügen über die genannten Methoden oder einen Konstruktor für String,
wieso sollten sie?

Landei hat eine neue Klasse CharSeq beschrieben,
CharSeq != ArrayList
?!


----------



## kenux (24. Mai 2009)

das habe ich ja gemerkt, aber ehrlich gesagt weiß ich nicht wie ich es machen soll. 
Ohne Collections klappt es ja, wie oben gezeigt:

CharSeq chseq = new CharSeq("kenux");

aber wie es mit Collections klappen soll das weiß ich nicht und hatte gehofft, dass ich mir helfen könnt


----------



## SlaterB (24. Mai 2009)

keine der Collections-Klassen hat eine Methode charAt(),
diese Grundkonstante des Universums wird sich auch nicht ändern wenn du hoffst oder fragst,

üblicherweise schreibt man in einer solchen Situation eigene Klassen wie CharSeq,
die im Inneren Collections verwenden und Methoden wie charAt() neu definieren und auf bekannte Methoden von Collections umdrehen,

ein anderes Vorgehen wurde hier bisher nicht angesprochen,
aber du denkst anscheinend noch über den grundsätzlichen Sinn der Aufgabe nach?
so kann wohl keiner helfen


----------



## kenux (24. Mai 2009)

SlaterB hat gesagt.:


> keine der Collections-Klassen hat eine Methode charAt(),



Jetzt wird es ja richtig lustig mit dir, jetzt kann ich mir schon denken wie du deine Beiträge zusammenkriegst.
Ich habe niemals behauptet, dass irgendeine der Collection-Klasse eine Methode charAt() hat. Nicht umsonst habe ich doch in meiner Klasse CharSeq die Methode charAt() und andere definiert.
Meine Frage war nur wie kann ich eine einzelne Zeichenkette wie "kenux" in einer Collection Klasse speichern und dann mit Hilfe meiner SELBSTDEFINIERTEN Methoden wie z.b charAt die Position ermitteln wo ein Zeichen liegt.
Übrigens habe gemerkt, dass du mir nicht helfen kannst


----------



## madboy (24. Mai 2009)

kenux hat gesagt.:


> Meine Frage war nur wie kann ich eine einzelne Zeichenkette wie "kenux" in einer Collection Klasse speichern




```
Collection<String> collection = new ArrayList<String>();
collection.add("kenux");
```



kenux hat gesagt.:


> und dann mit Hilfe meiner SELBSTDEFINIERTEN Methoden wie z.b charAt die Position ermitteln wo ein Zeichen liegt.




```
public int charAt(Collection<String> collection)
{
}
```

P.S.: Wenn dir SlaterB nicht helfen kann, liegt das zu 99,999% an deiner Fragestellung


----------



## Marco13 (24. Mai 2009)

kenux hat gesagt.:


> Jetzt lautet meine Frage: Wie kann ich das Programm so umschreiben, dass die Zeichen mittels collections, wie z.B List<String> gespeichert und ausgegeben wird?



Das ist ganz einfach: In der main musst du einfügen:
List<String> list = new ArrayList<String>();
list.add("someString");
System.out.println(list);

Der Rest des Programmes bleibt unverändert. Dann werden _die Zeichen mittels collections, wie z.B List<String> gespeichert und ausgegeben_, d.h. die Frage ist beantwortet und das Problem gelöst.


----------



## kenux (24. Mai 2009)

dankeschön an alle


----------



## Marco13 (24. Mai 2009)

Offenbar bist du sarkastische Bemerkungen nicht gewohnt. Aber meine erste Antwort war schon nicht-sarkastisch, und näher erläutert, was du eigentlich willst, hast du irgendwie nicht...


----------

