Ich habe ein letztes Problem mit meinem Projekt:
Hier ist mein Java Code:
ich weiß dass manches teilweise sehr umständlich ist. Aber jetzt zu meinem Problem:
wenn ich einen Text wähle, der eigentlich mit Leerzeichen aufgefüllt werden sollte, d.h. ein Text (streingabe) der nicht ohne rest durch den code (code1) geteilt werden kann, dann bekomme ich eine java.lang.NullPointerException in Zeile 306. Ich habe null Ahnung wo der Fehler liegt.
Hier ist mein Java Code:
Java:
public class codieren1 {
static String momstr;
private static String strtexteingabe;
static String code1;
private static String z1;
private static String z2;
private static String z3;
private static String z4;
private static String z5;
private static String z6;
private static String z7;
private static String z8;
private static String z9;
private static String z10;
private static String z11;
private static String z12;
private static String z13;
private static String z14;
private static String z15;
private static String z16;
private static String z17;
private static String z18;
private static String z19;
private static String z20;
private static String z21;
private static String z22;
private static String z23;
private static String z24;
private static String z25;
private static double l1;
private static double zpt;
private static int z;
public static String textuebergabe = "";
private static int x = 0;
private static int y = 1;
private static int spaces;
public static void main(String[] args) {
new codieren1();
}
public codieren1() {
super();
code1();
new codieren2();
}
private static void code1() {
strtexteingabe = codeframe.strtext;
code1 = codeframe.strcode1;
code1 = code1.replaceAll("Ä", "ae");
code1 = code1.replaceAll("ä", "ae");
code1 = code1.replaceAll("Ö", "oe");
code1 = code1.replaceAll("ö", "oe");
code1 = code1.replaceAll("Ü", "ue");
code1 = code1.replaceAll("ü", "ue");
code1 = code1.replaceAll("ß", "ss");
l1 = code1.length();
zpt = strtexteingabe.length() / l1;
if (zpt - (int) zpt == 0) {
} else {
spaces = code1.length() - strtexteingabe.length()
% code1.length();
for (int i = 0; i < spaces; i++) {
strtexteingabe += " ";
}
}
switch ((int) zpt) {
case 25:
z25 = strtexteingabe.substring(24 * (int) l1, 25 * (int) l1);
case 24:
z24 = strtexteingabe.substring(23 * (int) l1, 24 * (int) l1);
case 23:
z23 = strtexteingabe.substring(22 * (int) l1, 23 * (int) l1);
case 22:
z22 = strtexteingabe.substring(21 * (int) l1, 22 * (int) l1);
case 21:
z21 = strtexteingabe.substring(20 * (int) l1, 21 * (int) l1);
case 20:
z20 = strtexteingabe.substring(19 * (int) l1, 20 * (int) l1);
case 19:
z19 = strtexteingabe.substring(18 * (int) l1, 19 * (int) l1);
case 18:
z18 = strtexteingabe.substring(17 * (int) l1, 18 * (int) l1);
case 17:
z17 = strtexteingabe.substring(16 * (int) l1, 17 * (int) l1);
case 16:
z16 = strtexteingabe.substring(15 * (int) l1, 16 * (int) l1);
case 15:
z15 = strtexteingabe.substring(14 * (int) l1, 15 * (int) l1);
case 14:
z14 = strtexteingabe.substring(13 * (int) l1, 14 * (int) l1);
case 13:
z13 = strtexteingabe.substring(12 * (int) l1, 13 * (int) l1);
case 12:
z12 = strtexteingabe.substring(11 * (int) l1, 12 * (int) l1);
case 11:
z11 = strtexteingabe.substring(10 * (int) l1, 11 * (int) l1);
case 10:
z10 = strtexteingabe.substring(9 * (int) l1, 10 * (int) l1);
case 9:
z9 = strtexteingabe.substring(8 * (int) l1, 9 * (int) l1);
case 8:
z8 = strtexteingabe.substring(7 * (int) l1, 8 * (int) l1);
case 7:
z7 = strtexteingabe.substring(6 * (int) l1, 7 * (int) l1);
case 6:
z6 = strtexteingabe.substring(5 * (int) l1, 6 * (int) l1);
case 5:
z5 = strtexteingabe.substring(4 * (int) l1, 5 * (int) l1);
case 4:
z4 = strtexteingabe.substring(3 * (int) l1, 4 * (int) l1);
case 3:
z3 = strtexteingabe.substring(2 * (int) l1, 3 * (int) l1);
case 2:
z2 = strtexteingabe.substring(((int) l1), 2 * (int) l1);
case 1:
z1 = strtexteingabe.substring(0, (int) l1);
break;
default:
Object[] options = { "OK" };
JOptionPane.showOptionDialog(null, "Fehler!", "Achtung",
JOptionPane.DEFAULT_OPTION, JOptionPane.ERROR_MESSAGE,
null, options, options[0]);
}
code1 = code1.replaceAll("A", "a");
code1 = code1.replaceAll("B", "b");
code1 = code1.replaceAll("C", "c");
code1 = code1.replaceAll("D", "d");
code1 = code1.replaceAll("E", "e");
code1 = code1.replaceAll("F", "f");
code1 = code1.replaceAll("G", "g");
code1 = code1.replaceAll("H", "h");
code1 = code1.replaceAll("I", "i");
code1 = code1.replaceAll("J", "j");
code1 = code1.replaceAll("K", "k");
code1 = code1.replaceAll("L", "l");
code1 = code1.replaceAll("M", "m");
code1 = code1.replaceAll("A", "n");
code1 = code1.replaceAll("O", "o");
code1 = code1.replaceAll("P", "p");
code1 = code1.replaceAll("Q", "q");
code1 = code1.replaceAll("R", "r");
code1 = code1.replaceAll("S", "s");
code1 = code1.replaceAll("T", "t");
code1 = code1.replaceAll("U", "u");
code1 = code1.replaceAll("V", "v");
code1 = code1.replaceAll("W", "w");
code1 = code1.replaceAll("X", "x");
code1 = code1.replaceAll("Y", "y");
code1 = code1.replaceAll("Z", "z");
z = (int) (strtexteingabe.length() / l1);
String first = code1;
String second = momstr;
switch (z) {
case 25:
momstr = z25;
OrderablePair<String> ordered24 = orderCharactersAfterFirstString(
first, second);
z25 = ordered24.b;
case 24:
momstr = z24;
OrderablePair<String> ordered23 = orderCharactersAfterFirstString(
first, second);
z24 = ordered23.b;
case 23:
momstr = z23;
OrderablePair<String> ordered22 = orderCharactersAfterFirstString(
first, second);
z23 = ordered22.b;
case 22:
momstr = z22;
OrderablePair<String> ordered21 = orderCharactersAfterFirstString(
first, second);
z22 = ordered21.b;
case 21:
momstr = z21;
OrderablePair<String> ordered20 = orderCharactersAfterFirstString(
first, second);
z21 = ordered20.b;
case 20:
momstr = z20;
OrderablePair<String> ordered19 = orderCharactersAfterFirstString(
first, second);
z20 = ordered19.b;
case 19:
momstr = z19;
OrderablePair<String> ordered18 = orderCharactersAfterFirstString(
first, second);
z19 = ordered18.b;
case 18:
momstr = z18;
OrderablePair<String> ordered17 = orderCharactersAfterFirstString(
first, second);
z18 = ordered17.b;
case 17:
momstr = z17;
OrderablePair<String> ordered16 = orderCharactersAfterFirstString(
first, second);
z17 = ordered16.b;
case 16:
momstr = z16;
OrderablePair<String> ordered15 = orderCharactersAfterFirstString(
first, second);
z16 = ordered15.b;
case 15:
momstr = z15;
OrderablePair<String> ordered14 = orderCharactersAfterFirstString(
first, second);
z15 = ordered14.b;
case 14:
momstr = z14;
OrderablePair<String> ordered13 = orderCharactersAfterFirstString(
first, second);
z14 = ordered13.b;
case 13:
momstr = z13;
OrderablePair<String> ordered12 = orderCharactersAfterFirstString(
first, second);
z13 = ordered12.b;
case 12:
momstr = z12;
OrderablePair<String> ordered11 = orderCharactersAfterFirstString(
first, second);
z12 = ordered11.b;
case 11:
momstr = z11;
OrderablePair<String> ordered10 = orderCharactersAfterFirstString(
first, second);
z11 = ordered10.b;
case 10:
momstr = z10;
OrderablePair<String> ordered9 = orderCharactersAfterFirstString(
first, second);
z10 = ordered9.b;
case 9:
momstr = z9;
OrderablePair<String> ordered8 = orderCharactersAfterFirstString(
first, second);
z9 = ordered8.b;
case 8:
momstr = z8;
OrderablePair<String> ordered7 = orderCharactersAfterFirstString(
first, second);
z8 = ordered7.b;
case 7:
momstr = z7;
OrderablePair<String> ordered6 = orderCharactersAfterFirstString(
first, second);
z7 = ordered6.b;
case 6:
momstr = z6;
OrderablePair<String> ordered5 = orderCharactersAfterFirstString(
first, second);
z6 = ordered5.b;
case 5:
momstr = z5;
OrderablePair<String> ordered4 = orderCharactersAfterFirstString(
first, second);
z5 = ordered4.b;
case 4:
momstr = z4;
OrderablePair<String> ordered3 = orderCharactersAfterFirstString(
first, second);
z4 = ordered3.b;
case 3:
momstr = z3;
OrderablePair<String> ordered2 = orderCharactersAfterFirstString(
first, second);
z3 = ordered2.b;
case 2:
momstr = z2;
OrderablePair<String> ordered1 = orderCharactersAfterFirstString(
first, second);
z2 = ordered1.b;
case 1:
momstr = z1;
OrderablePair<String> ordered = orderCharactersAfterFirstString(
first, second);
z1 = ordered.b;
break;
}
public static OrderablePair<String> orderCharactersAfterFirstString(
String a, String b) {
if (a.length() != b.length()) {
throw new InputMismatchException(
"Strings have to be in same length!");
}
List<OrderablePair<Character>> list = new ArrayList<>();
for (int i = 0; i < a.length(); i++) {
list.add(new OrderablePair<Character>(a.charAt(i), b.charAt(i)));
}
Collections.sort(list);
StringBuilder outFirst = new StringBuilder("");
StringBuilder outSecond = new StringBuilder("");
for (OrderablePair<Character> op : list) {
outFirst.append(op.a);
outSecond.append(op.b);
}
return new OrderablePair<String>(outFirst.toString(),
outSecond.toString());
}
static class OrderablePair<T extends Comparable<T>> implements
Comparable<OrderablePair<T>> {
final T a;
final T b;
public OrderablePair(T a, T b) {
this.a = a;
this.b = b;
}
@Override
public int compareTo(OrderablePair<T> oth) {
return a.compareTo(oth.a);
}
}
}ich weiß dass manches teilweise sehr umständlich ist. Aber jetzt zu meinem Problem:
wenn ich einen Text wähle, der eigentlich mit Leerzeichen aufgefüllt werden sollte, d.h. ein Text (streingabe) der nicht ohne rest durch den code (code1) geteilt werden kann, dann bekomme ich eine java.lang.NullPointerException in Zeile 306. Ich habe null Ahnung wo der Fehler liegt.
Zuletzt bearbeitet:
