Array Variable

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

  • Array Variable

    hi erstmal,
    hab jetzt mein FH als informatiker angefangen und ab leide mein erstes problem beim programmieren mit java.
    Meine aufgabe ist es grad eine bestimmte anzahl von zeichen in einem array zu speicher und dann am stück auszugeben.

    Quellcode

    1. int a = 1;
    3. String ZeichenSpeicher [];
    5. ZeichenSpeicher = new String [a];
    7. for (int i=0; i<ZeichenSpeicher.length; i++){
    9. String Einlesen = Eingabe.readString();
    11. a++;
    12. }
    Alles anzeigen


    mein problem ist das die variable a nicht mit wachst.
    hoffe mir kann jemand helfen

  • hmm...
    Da du denke ich schon die Semantik mit String-Array verwenden sollst (wahrscheinlich in der Aufgabenstellung vorgegeben, nehme ich an), würde ich dir empfehlen, einfach das Array mit einem ausreichend großen Anfangswert zu initialisieren.
    In der Aufgabenstellung ist ja vielleicht sogar ein Maximalwert fuer die einzugebenden char-Zeichen angegeben, den könntest du ja benutzen. Falls dem nicht so ist, nimm einfach mal 200 als Parameter für die Array-Größe... (Speicherbegrenzung habt ihr ja sicher für die Programmieraufgabe noch nicht :lol: ) und fang dann den möglicherweise auftretenden Fehler (Array-Überschreitung bei mehr als 200Zeichen) mit ner if-Abfrage ab. D.h. alles was mehr als 200 Zeichen enthält, wird nicht mehr gespeichert.
    Das sollte denke ich für die Aufgabenstellung reichen.
    Also so würde ichs machen =).
    Dein Array im Beispiel hat nur 2 Felder, [0] und [1]... jedes Zeichen, das zuviel eingegeben ist, bemängelt der Compiler. Du wirst aber sicher bei einem Array mit 200 Feldern im Standardfall keine Fehlermeldung bekommen, denn wer schreibt schon einen Roman als Aufrufparameter für ein Java-Programm!! :D :P
    \\.-'´´ Alw4ys k33p on burn!ng, 'cAu$e if you are buRnT out y0ur l!fe sURreNd3Rs deAth! ``'-.//

  • Ja du hattest recht, leider hab ich erst nachdem ich selber herausgefunden hab gelesen ^^. Dumm gelaufen. Trozdem Danke.


    Quellcode

    1. String ZeichenSpeicher [];
    3. ZeichenSpeicher = new String [50];
    4. int i =0;
    5. double AOperant = Eingabe.readDoubleValue();
    6. String AOperantString = Double.toString(AOperant);
    7. ZeichenSpeicher[i] = AOperantString;
    8. i++;
    10. String Operator = Eingabe.readString();
    11. ZeichenSpeicher[i] = Operator;
    12. i++;
    14. if(Operator == "+")
    15. double BOperant = Eingabe.readDoubleValue();
    16. String BOperantString = Double.toString(BOperant);
    17. ZeichenSpeicher[i] = BOperantString;
    18. AOperant = AOperant + BOperant;
    19. i++;
    21. if(Operator == "-")
    22. double BOperant = Eingabe.readDoubleValue();
    23. String BOperantString = Double.toString(BOperant);
    24. ZeichenSpeicher[i] = BOperantString;
    25. AOperant = AOperant - BOperant;
    26. i++;
    Alles anzeigen


    Neues Problem...
    Zeigt immer so ein Fehler an beim einlesen der BOperanten.

    PS: Die aufgaben stellung lautete ungefäher:
    Taschenrechner mit bestimmten Operatoren zu programmieren in dem die Operanten und Operatoren in einem 50 Stelligen Array gespeichert werden...

  • hm... sollte mit den richtigen Klammern auf jeden Fall funktionieren wie d0nUt schon gesagt hat.
    Das separate Speichern in diesem Array macht schon Sinn, denke ich.
    Damit könnte man hinterher (evtl Erweiterung der Aufgabe) algebraische Gesetze (kommutativ-, assoziativ-,...) etc einbauen, indem man z.B. die Arrays sortieren lässt... weiss ja nicht, ob das vielleicht die Absicht dabei ist.
    Bleibt noch die Frage, ob und vor allem warum man die Zahlen als String speichern sollte... :shock: :?:

    Vielleicht für Typecast vom char zum int... oO Und wenn wir grad beim Thema Typecast sind, hab ich dazu gleich ne Frage, die sich mir da auftut:

    Das Casten von Typ double in String (und damit char) läuft doch ähnlich ab wie beim Cast zu int, oder?? Demnach würden ja die Nachkommastellen abgesägt und somit bei eventuellem Re-Casting ungenaue Werte produziert...? Oder täusche ich mich da jetzt?

    PS: Anm., "Operand" schreibt man meines Wissens mit "d" am Ende, normalerweise jedenfalls.
    :shock: :wink:
    \\.-'´´ Alw4ys k33p on burn!ng, 'cAu$e if you are buRnT out y0ur l!fe sURreNd3Rs deAth! ``'-.//

  • Dann nochmal ein dickes thx, das ist voll nervig wen man das dann gesagt bekommt fällt das immmer voll ins auge^^.
    Nach der Logic bei diesen Programm würde ich nicht suchen. Das ist only train wo einfach alles mal durch probiert wird und das alles zum thema Taschenrechner.

    So da stellt sich bei meinem Programm das nächste Problem

    Quellcode

    1. import HfT.Eingabe;
    2. import java.lang.Math;
    4. public class Main {
    9. public Main() {
    10. }
    12. public static void main(String[] args) {
    15. String ZeichenSpeicher [];
    17. ZeichenSpeicher = new String [50];
    19. int i =0;
    20. double AOperant = Eingabe.readDoubleValue();
    21. String AOperantString = Double.toString(AOperant);
    22. ZeichenSpeicher[i] = AOperantString;
    23. i++;
    25. String Operator = Eingabe.readString();
    26. ZeichenSpeicher[i] = Operator;
    27. i++;
    29. if(Operator == "+"){
    30. double BOperant = Eingabe.readDoubleValue();
    31. String BOperantString = Double.toString(BOperant);
    32. ZeichenSpeicher[i] = BOperantString;
    33. AOperant = AOperant + BOperant;
    34. i++;
    35. }
    36. if(Operator == "-"){
    37. double BOperant = Eingabe.readDoubleValue();
    38. String BOperantString = Double.toString(BOperant);
    39. ZeichenSpeicher[i] = BOperantString;
    40. AOperant = AOperant - BOperant;
    41. i++;
    42. }
    43. if(Operator == "*"){
    44. double BOperant = Eingabe.readDoubleValue();
    45. String BOperantString = Double.toString(BOperant);
    46. ZeichenSpeicher[i] = BOperantString;
    47. AOperant = AOperant * BOperant;
    48. i++;
    49. }
    50. if(Operator == "/"){
    51. double BOperant = Eingabe.readDoubleValue();
    52. String BOperantString = Double.toString(BOperant);
    53. ZeichenSpeicher[i] = BOperantString;
    54. AOperant = AOperant / BOperant;
    55. i++;
    56. }
    57. if(Operator == "#"){
    59. AOperant = -AOperant;
    60. i++;
    61. }
    62. if(Operator == "x²"){
    64. AOperant = AOperant * AOperant;
    65. i++;
    66. }
    67. if(Operator == "sin"){
    69. AOperant = Math.sin(AOperant);
    70. i++;
    71. }
    72. if(Operator == "c"){
    74. i--;
    75. }
    78. }
    79. }
    Alles anzeigen


    Der rechnet mir einfach diesen 2. Operant nicht rein. Der bleicbt immer vor der IF schleife stehen.

  • jut jut, 1 Vorlesung später haben wit dan auch equals durchgenomen ^^.
    war wieder zu schnell.

    so hab das teil jetzt fertig... bitte alle mal mosern und verbesern, aber bitte konstruktiv und mit erklärungen ^^. Wie gesagt habe nicht mal ganz die grundlagen durch mit java.

    Quellcode

    1. package aufgabe_2;
    2. import HfT.Eingabe;
    3. /**
    4. *
    5. * @author xmoO
    6. */
    7. public class Main {
    11. /** Creates a new instance of Main */
    12. public Main() {
    13. }
    15. /**
    16. * @param args the command line arguments
    17. */
    18. public static void main(String[] args) {
    19. // TODO code application logic here
    21. double COperand = 0;
    22. System.out.println("Aufgabe_2 von otdif110 bzw Dennis Ottenbacher\n");
    23. String ZeichenSpeicher [];
    24. ZeichenSpeicher = new String [50];
    26. int i =0;
    27. double AOperand = Eingabe.readDoubleValue();
    28. String AOperandString = Double.toString(AOperand);
    29. ZeichenSpeicher[i] = AOperandString;
    31. i++;
    35. do {
    38. String Operator = Eingabe.readString();
    39. ZeichenSpeicher[i] = Operator;
    41. i++;
    44. if( Operator.equals("+") ){
    45. double BOperand = Eingabe.readDoubleValue();
    46. String BOperandString = Double.toString(BOperand);
    47. ZeichenSpeicher[i] = BOperandString;
    48. COperand = AOperand + BOperand;
    49. String COperandString = Double.toString(COperand);
    50. ZeichenSpeicher[49] = COperandString;
    51. i++;
    52. }
    53. if( Operator.equals("-") ){
    54. double BOperand = Eingabe.readDoubleValue();
    55. String BOperandString = Double.toString(BOperand);
    56. ZeichenSpeicher[i] = BOperandString;
    57. COperand = AOperand - BOperand;
    58. String COperandString = Double.toString(COperand);
    59. ZeichenSpeicher[49] = COperandString;
    60. i++;
    61. }
    62. if(Operator.equals("*")){
    63. double BOperand = Eingabe.readDoubleValue();
    64. String BOperandString = Double.toString(BOperand);
    65. ZeichenSpeicher[i] = BOperandString;
    66. COperand = AOperand * BOperand;
    67. String COperandString = Double.toString(COperand);
    68. ZeichenSpeicher[49] = COperandString;
    69. i++;
    70. }
    71. if(Operator.equals("/")){
    72. double BOperand = Eingabe.readDoubleValue();
    73. String BOperandString = Double.toString(BOperand);
    74. ZeichenSpeicher[i] = BOperandString;
    75. COperand = AOperand / BOperand;
    76. String COperandString = Double.toString(COperand);
    77. ZeichenSpeicher[49] = COperandString;
    78. i++;
    79. }
    80. if(Operator.equals("#")){
    81. COperand = -AOperand;
    82. String COperandString = Double.toString(COperand);
    83. ZeichenSpeicher[49] = COperandString;
    85. }
    86. if(Operator.equals("x2")){
    88. COperand = AOperand * AOperand;
    89. String COperandString = Double.toString(COperand);
    90. ZeichenSpeicher[49] = COperandString;
    92. }
    93. if(Operator.equals("sin")){
    95. COperand = Math.sin(AOperand);
    96. String COperandString = Double.toString(COperand);
    97. ZeichenSpeicher[49] = COperandString;
    100. }
    101. if(Operator.equals("c")){
    102. ZeichenSpeicher = new String [50];
    103. COperand = 0;
    104. i = 0;
    105. double ANew = Eingabe.readDoubleValue();
    106. String ANewString = Double.toString(ANew);
    107. ZeichenSpeicher[i] = ANewString;
    108. AOperand = ANew;
    109. i++;
    111. }
    112. if(Operator.equals("=")){
    113. for (int j = 0 ; j < i ; j++ ) {
    114. System.out.print(ZeichenSpeicher[j] + " ");
    116. }
    117. System.out.println(ZeichenSpeicher[49]);
    118. ZeichenSpeicher[i] = ZeichenSpeicher[49];
    119. i++;
    122. }
    124. AOperand = COperand;
    126. } while (true);
    128. }
    129. }
    Alles anzeigen


    der array mit 50 und noch ein paar andere sachen waren vorgegeben.

  • Das ganze Zeug was du bei einem Operator machst:

    Quellcode

    1. if( Operator.equals("+") ){
    2. double BOperand = Eingabe.readDoubleValue();
    3. String BOperandString = Double.toString(BOperand);
    4. ZeichenSpeicher[i] = BOperandString;
    5. COperand = AOperand + BOperand;
    6. String COperandString = Double.toString(COperand);
    7. ZeichenSpeicher[49] = COperandString;
    8. i++;
    9. }

    kann man auch so machen:

    Quellcode

    1. if( Operator.equals("+") ){
    2. ZeichenSpeicher[i++] = Double.toString(Eingabe.readDoubleValue());
    3. ZeichenSpeicher[49] = Double.toString(AOperand + BOperand);
    4. }

    Und muss es wirklich ein "String[50]" sein, oder kann es auch ein "double[50]" sein?
    Und Kommentare sind übrigens etwas schönes :)