webentwicklung-frage-antwort-db.com.de

Java-NegativindexOf (Zählen vom Ende [Länge ()])

Gibt es eine Möglichkeit in Java, indexOf eines Zeichens zu finden, das am Ende beginnt und length () als Referenz hat, wie dies bei anderen Sprachen der Fall ist?

   new String("abcd").reverseIndexOf("d"(,[4 or -0]))
or new String("abcd").indexOf("d",-0) // Should return a (-)1

... anstelle des Offensichtlichen 

   new String("abcd").indexOf("d") - newString("abcd").length()     

Vielen Dank!

19
Whimusical

lastIndexOf(int ch) beginnt am Ende und sucht rückwärts und gibt den absoluten Index des letzten Vorkommens zurück. Dann können Sie diese Zahl von der Länge des Strings subtrahieren und negieren, wenn Sie das wirklich wollen.

Sie können auch lastIndexOf(int ch, int fromIndex) verwenden, wenn Sie von einem bestimmten Index aus rückwärts suchen möchten.

Um Ihre Frage zu beantworten, was passiert, wenn Sie eine negative Zahl übergeben, können Sie im Quellcode der String-Klasse suchen. Wie sich herausstellt, setzt die letztlich als indexOf implementierte Implementierung einen negativen fromIndex-Wert auf Null zurück:

static int indexOf(char[] source, int sourceOffset, int sourceCount,
                   char[] target, int targetOffset, int targetCount,
                   int fromIndex) {
if (fromIndex >= sourceCount) {
        return (targetCount == 0 ? sourceCount : -1);
}
    if (fromIndex < 0) {
        fromIndex = 0;
    }
    ...

Zurück zum zweiten Beispiel:

"abcd".indexOf("d",-0)

Das Implementieren eines generischen indexOf, der einen negativen Index akzeptiert und den entsprechenden negativen Index zurückgibt (sofern vorhanden), ist komplizierter, da Java nicht zwischen int0 und int-0 (beide werden als 0 dargestellt) und weil String dargestellt wird .indexOf gibt normalerweise -1 zurück, wenn die Suchzeichenfolge nicht gefunden wird. Sie können jedoch nahe an das herankommen, was Sie möchten. Beachten Sie, dass es einige Einschränkungen gibt:

  1. String.indexOf gibt normalerweise -1 zurück, wenn die Suchzeichenfolge nicht gefunden wird. Da -1 jedoch ein gültiger Index in unserer neuen Implementierung ist, müssen wir einen neuen Vertrag definieren. Integer.MIN_VALUE wird jetzt zurückgegeben, wenn die Suchzeichenfolge nicht gefunden wird.
  2. Da wir nicht auf int-0 testen können, können wir nicht auf den Index des letzten Zeichens als -0 verweisen. Aus diesem Grund verwenden wir -1, um auf den Index des letzten Zeichens zu verweisen und von dort aus rückwärts zu zählen.
  3. Aus Gründen der Konsistenz mit Punkt 2 beginnen auch negative Rückgabewerte abwärts zu zählen, beginnend mit -1 als Index des letzten Zeichens.

Der Code könnte vereinfacht werden, aber ich habe ihn absichtlich ausführlich gemacht, sodass Sie ihn in einem Debugger leicht durchgehen können.

package com.example.string;

public class StringExample {

    public static int indexOf(String str, String search, int fromIndex) {
        if (fromIndex < 0) {
            fromIndex = str.length() + fromIndex; // convert the negative index to a positive index, treating the negative index -1 as the index of the last character
            int index = str.lastIndexOf(search, fromIndex);
            if (index == -1) {
                index = Integer.MIN_VALUE; // String.indexOf normally returns -1 if the character is not found, but we need to define a new contract since -1 is a valid index for our new implementation
            }
            else {
                index = -(str.length() - index); // convert the result to a negative index--again, -1 is the index of the last character 
            }
            return index;
        }
        else {
            return str.indexOf(str, fromIndex);
        }
    }

    public static void main(String[] args) {
        System.out.println(indexOf("abcd", "d", -1)); // returns -1
        System.out.println(indexOf("adbcd", "d", -2)); // returns -4
    }
}
26
rob

Verwenden Sie einfach die String.lastIndexOf()-Methode:

String s = "abcd";
int rindex = s.lastIndexof('d');
System.out.println(rindex); // print 0
4
The Tran

Sie können die Zeichenfolge übrigens leicht umkehren:

String s="abcd";
StringBuilder reverseS = new StringBuilder(s).reverse();
System.out.println(reverseS.indexOf("d")); //print 0
System.out.println(reverseS.indexOf("a")); //print 3
System.out.println(reverseS.indexOf("d",1)); //print -1
0
alain.janinm