Generische Liste überschreibt die Daten.

  • Java

Diese Seite verwendet Cookies. Durch die Nutzung unserer Seite erklären Sie sich damit einverstanden, dass wir Cookies setzen. Weitere Informationen

  • Generische Liste überschreibt die Daten.

    HI

    ich bin wirklich seit 2 Tagen an einem Problem für die Uni.

    Ich möchte folgende Aufgabe lösen:

    Programmieren Sie die Klasse List<K> aus der Vorlesung.

    a) Implementieren sie dabei die folgenden Methoden wie in der Vorlesung beschrieben:

    public String toString() {...}
    public boolean isEmpty() {...}
    public void insertFirst(K elem) {...}


    b) Erweitern Sie Ihre Klasse List<K> um die folgenden Methoden:

    Abfragen der Anzahl der Elemente in der Liste:

    public int size() {...}
    Die Methode gibt die Anzahl der in der Liste gespeicherten Objekte zurück.
    Abfragen eines Elements an einer bestimmten Position:

    public K get(int pos) {...}
    Die Methode liefert das Objekt an der Stelle pos zurück. Falls gilt (pos < 0 || pos >= size()) soll ein Objekt der folgenden Runtime-Exception geworfen werden: java.lang.IndexOutOfBoundsException

    Hinzufügen eines Elements an einer bestimmten Position:

    public void add(K elem) {...}
    Die Methode hängt das Objekt elem an die bestehende Liste hinten an. Falls gilt (elem==null) soll ein Objekt der folgenden Runtime-Exception geworfen werden: java.lang.NullPointerException

    Testen Sie Ihre neuen Methoden ausführlich in der main-Methode der Klasse Main.

    Testen Sie die Klasse List mit der Klasse Account als den Typ-Parameter. Fügen Sie 2 Accounts hinzu und geben die Liste auf der Konsole aus. Prüfen Sie vor und nach dem Hinzufügen der Elemente den Rückgabewert der Methode isEmpty(). Fügen Sie einen weiteren Account mit Hilfe der Methode insertFirst(...) vorne in der Liste ein. Überprüfen Sie die Korrektheit indem Sie die Liste erneut auf der Konsole ausgeben.

    c)Ersetzen Sie das Account Array in der Klasse Cashmachine durch Ihre eigene Klasse List. Passen Sie ihre Klasse Cashmachine entsprechend an.

    d) Implementieren Sie die Methode java.util.Iterator<K> iterator() {...} unter Verwendung einer geeigneten (inneren) Klasse wie in der Vorlesung besprochen. Testen Sie Ihren Iterator ausführlich!




    Ich hände an der add Methode, sie funktioniert einfach nicht ( habe die ganze Klasse schon 2 mal neu geschrieben aber ich komme nicht darauf)

    Erstmal die funktionierenden Klassen:


    Quellcode

    1. package A4.bin;
    2. public class Account {
    3. private int accountNumber;
    4. private float overdraft; //Dispokredit des Kontos
    5. private float bankDeposit; //die Höhe des Kontoguthabens
    6. private int pin = 1234;
    7. public Account(int accNumber, float dispo, float guthaben){
    8. accountNumber= accNumber;
    9. overdraft = dispo;
    10. bankDeposit = guthaben;
    11. }
    12. public float getoverdraft(){
    13. return overdraft;
    14. }
    15. public float getbankDeposit(){
    16. return bankDeposit;
    17. }
    18. public int getAccountNumber() {
    19. return accountNumber;
    20. }
    21. public void setAccountNumber(int accountNumber) {
    22. this.accountNumber = accountNumber;
    23. }
    24. public void setOverdraft(float dispo){
    25. this.overdraft = dispo;
    26. }
    27. public void setBankDeposit(float guthaben){
    28. this.bankDeposit = guthaben;
    29. }
    30. public int getPin(){
    31. return pin;
    32. }
    33. @Override
    34. public String toString() {
    35. return ("Accountnummer:" + this.accountNumber + " Guthaben: " + this.bankDeposit + " Dispo:" + this.overdraft);
    36. }
    37. }
    Alles anzeigen





    Quellcode

    1. package A4.bin;
    2. public class Main {
    3. public static void main(String[] args) throws NullPointerException {
    4. Account acc1 = new Account(5, 1.22f, 4.55f);
    5. Account acc2 = new Account(9, 7.66f, 9.44f);
    6. try {
    7. List<Account> test = new List<Account>();
    8. test.insertFirst(acc2);
    9. System.out.println("add aufruf:");
    10. test.add(acc1);
    11. System.out.println(test.isEmpty());
    12. System.out.println("size aufruf:");
    13. System.out.println(test.size());
    14. System.out.println("get(1) aufruf:");
    15. System.out.println(test.get(1));
    16. System.out.println("get(2) aufruf:");
    17. System.out.println(test.get(2));
    18. } catch (NullPointerException exc) {
    19. System.out.println("GROßerfehler");
    20. }
    21. }
    22. }
    Alles anzeigen



    Und mein Problemfall: ( habe die add auf 2 arten Implementiert und den einen Fall auskommentiert)



    Java-Quellcode

    1. package A4.bin;
    2. import java.lang.*;
    3. import java.util.Collections;
    4. import java.util.Iterator;
    5. public class List<K> implements Iterable<K> {
    6. int size = 0;
    7. private ListNode head;
    8. private class ListNode {
    9. ListNode next;
    10. K data;
    11. void setData(K data) {
    12. this.data = data;
    13. }
    14. ListNode getNext(){
    15. if (next != null){
    16. return next;
    17. }
    18. }
    19. boolean hasNext(){
    20. if (head.next != null){
    21. return true;
    22. }else{
    23. return false;
    24. }
    25. }
    26. void setNext(ListNode next) {
    27. this.next = next;
    28. }
    29. public boolean isEmpty() {
    30. return head == null;
    31. }
    32. public K getData(){
    33. return this.data;
    34. }
    35. }
    36. @Override
    37. public String toString() {
    38. ListNode l = head;
    39. StringBuilder sb = new StringBuilder();
    40. System.out.println("a");
    41. while (l != null) {
    42. sb.append("<" + l.data + ">");
    43. l = l.next;
    44. }
    45. return sb.toString();
    46. }
    47. public void insertFirst(K elem) {
    48. ListNode newHead = new ListNode();
    49. newHead.setData(elem);
    50. newHead.setNext(this.head);
    51. this.head = newHead;
    52. }
    53. public boolean isEmpty() {
    54. return head == null;
    55. }
    56. public int size() {
    57. size = 0;
    58. ListNode tempHead = this.head;
    59. System.out.println("size1");
    60. while (tempHead != null) {
    61. System.out.println("size2");
    62. tempHead = tempHead.next;
    63. size++;
    64. }
    65. return size;
    66. }
    67. public K get(int pos) throws IndexOutOfBoundsException {
    68. System.out.println(head.data);
    69. K x = null;
    70. System.out.println("test1");
    71. ListNode tempHead = this.head;
    72. if (pos > 0 || pos <= size()) {
    73. System.out.println(tempHead.data);
    74. System.out.println("test2");
    75. for (int i = 0; i < pos; i++) {
    76. System.out.println("test3" + this.head.data);
    77. tempHead = tempHead.next;
    78. System.out.println("test4");
    79. }
    80. } else {
    81. throw new IndexOutOfBoundsException();
    82. }
    83. System.out.println("letztes get");
    84. // System.out.println(tempHead.data);
    85. return tempHead.data;
    86. }
    87. /* public void add(K elem) throws NullPointerException {
    88. ListNode addHead = new ListNode();
    89. addHead.setData(elem);
    90. System.out.println(head.data);
    91. System.out.println(addHead.data);
    92. for(int i =1; i< size(); i++){
    93. head = head.next;
    94. if( head.next == null ){
    95. head.setNext(addHead);
    96. break;
    97. }
    98. }
    99. */
    100. public void add(K elem) {
    101. ListNode temp = new ListNode();
    102. temp.setData(elem);
    103. ListNode iterating = head;
    104. if (head == null) {
    105. head = temp;
    106. return;
    107. }
    108. for (; iterating.hasNext(); iterating = iterating.getNext())
    109. ;
    110. iterating.setNext(temp);
    111. class myIterator implements Iterator<K> {
    112. public ListNode current;
    113. public myIterator() {
    114. current = head;
    115. }
    116. @Override
    117. public boolean hasNext() {
    118. if (current != null) {
    119. return current.hasNext();
    120. }
    121. return false;
    122. }
    123. @Override
    124. public K next() {
    125. ListNode temp = current;
    126. current = current.getNext();
    127. return temp.getData();
    128. }
    129. @Override
    130. public void remove() {
    131. throw new UnsupportedOperationException();
    132. }
    133. }
    134. }
    135. @Override
    136. public Iterator<K> iterator() {
    137. return new myIterator();
    138. }
    139. }
    Alles anzeigen




    Mit dieser Klasse, die mir ein Kommilitone gegeben hat funktioniert mein Programm super ( bei ihm heißt die ListNode, innerData) wäre echt super wenn mir jemand meinen fehler zeigen könnte. ICh weiß echt nichtmehr weiter :(



    Java-Quellcode

    1. import java.util.*;
    2. public class List<K> implements Iterable<K> {
    3. innerData head;
    4. public List() {
    5. head = null;
    6. }
    7. public class innerData {
    8. K data;
    9. innerData next;
    10. public innerData(K newData) {
    11. data = newData;
    12. next = null;
    13. }
    14. public void setNext(innerData newNext) {
    15. next = newNext;
    16. }
    17. public innerData getNext() {
    18. if (next != null) {
    19. return next;
    20. }
    21. return null;
    22. }
    23. public boolean hasNext() {
    24. if (next == null) {
    25. return false;
    26. }
    27. return true;
    28. }
    29. public String toString() {
    30. return data.toString() + " " + next.toString();
    31. }
    32. public K getData() {
    33. return data;
    34. }
    35. }
    36. public class myIterator implements Iterator<K> {
    37. public innerData current;
    38. public myIterator() {
    39. current = head;
    40. }
    41. @Override
    42. public boolean hasNext() {
    43. if (current != null) {
    44. return current.hasNext();
    45. }
    46. return false;
    47. }
    48. @Override
    49. public K next() {
    50. innerData temp = current;
    51. current = current.getNext();
    52. return temp.getData();
    53. }
    54. @Override
    55. public void remove() {
    56. throw new UnsupportedOperationException();
    57. }
    58. }
    59. public String toString() {
    60. if (head != null) {
    61. return head.toString();
    62. }
    63. return null;
    64. }
    65. public boolean isEmpty() {
    66. if (head == null) {
    67. return true;
    68. }
    69. return false;
    70. }
    71. public void insertFirst(K newElement) {
    72. innerData temp = new innerData(newElement);
    73. if (head != null) {
    74. temp.setNext(head);
    75. }
    76. head = temp;
    77. }
    78. public int size() {
    79. int dataSize = 0;
    80. innerData iterating = head;
    81. while (iterating != null) {
    82. dataSize++;
    83. iterating = iterating.getNext();
    84. }
    85. return dataSize;
    86. }
    87. public K get(int pos) {
    88. innerData iterating = head;
    89. int i;
    90. for (i = 0; i < pos && iterating != null; i++, iterating = iterating
    91. .getNext())
    92. ;
    93. return iterating.getData();
    94. }
    95. public void add(K newElement) {
    96. innerData temp = new innerData(newElement);
    97. innerData iterating = head;
    98. if (head == null) {
    99. head = temp;
    100. return;
    101. }
    102. for (; iterating.hasNext(); iterating = iterating.getNext())
    103. ;
    104. iterating.setNext(temp);
    105. }
    106. @Override
    107. public Iterator<K> iterator() {
    108. return new myIterator();
    109. }
    110. }
    Alles anzeigen







    THX
  • Dein Fehler ist in der Methode hasNext von ListNode. Das Objekt head sollte dich hier nicht interessieren.
    "General, der Mensch ist sehr brauchbar. Er kann fliegen und er kann töten.
    Aber er hat einen Fehler: Er kann denken." - Brecht
    I Don't smoke, I don't drink, I don't fuck! At least I can fucking think!
  • der Code ist doch äquivalent zu dem vorher. Da darf garkein head stehen... (Warum sollte auch? Das gehört doch zu einem ganz anderen Objekt!)

    Quellcode

    1. boolean hasNext(){
    2. return next != null;
    3. }


    Warum Java es überhaupt zulässt, dass du ohne weiteres auf ein private Element eines anderen Objekts zugreifen kannst, erschließt sich mir nicht vollständig. Aber auch wenn Java es dir erlaubt, tu es nicht. Die isEmpty() Methode macht an dieser Stelle genauso wenig Sinn. (Du erstellst ein Objekt um zu prüfen, ob in einem anderen Objekt eine Variable auf null steht. wtf?)
    "General, der Mensch ist sehr brauchbar. Er kann fliegen und er kann töten.
    Aber er hat einen Fehler: Er kann denken." - Brecht
    I Don't smoke, I don't drink, I don't fuck! At least I can fucking think!

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von undeath ()

  • THX

    habe es heute noch einmal mit einem Kommilitone besprochen

    sie müsste so sein:

    Quellcode

    1. boolean hasNext() {
    2. if (next != null) {
    3. return true;
    4. } else {
    5. return false;
    6. }
    7. }



    außerdem haben wir die add geändert:

    Quellcode

    1. public void add(K elem) {
    2. ListNode temp = new ListNode();
    3. temp.setData(elem);
    4. if (isEmpty()) {
    5. head = temp;
    6. } else {
    7. ListNode iterating = head;
    8. while (iterating.hasNext()) {
    9. iterating = iterating.next;
    10. }
    11. iterating.next = temp;
    12. }
    Alles anzeigen



    trotzdem THX :D