la fonction Java String indexOf () peut-elle rechercher plusieurs caractères? - java, chaîne

J'essaye de réduire le temps d'exécution d'un programme sur lequel je travaille et je veux trouver un moyen plus simple de trouver l'index d'un caractère avec une valeur entière.

Pour le moment, ma fonction trace à travers chaque caractère d'une chaîne et renvoie le indice du premier entier qu'il trouve. A titre d'exemple, si j'avais la chaîne JohnCena1237728394712 (oui, c'est la première chaîne à laquelle j'ai pensé), leLa fonction doit retourner 8 car le premier entier qui apparaît dans la chaîne, 1, est à l'index 8. Elle doit d'abord parcourir chaque caractère avant de trouver cet index, cependant, et cela devient parfois coûteux.

Si cela aide lorsque vous essayez de penser à un moyen plus simplepour ce faire, je peux être sûr en entrant dans la fonction que le format de la chaîne sera toujours "[lettres]" + "[nombres]" donc je dois simplement trouver la fin du segment (vraisemblablement aléatoire) de lettres pour obtenir ce que je veux.

Ce que je voudrais faire, c’est utiliser indexOf (), donc je n’aurai pas à utiliser une boucle, mais je ne connais pas un moyen d’utiliser la fonction sans avoir dix instructions if (ce qui, bien sûr, irait à l’encontre du but).

Existe-t-il un moyen de vérifier plusieurs entiers à la fois tout en utilisant indexOf () ou une autre fonction?

Réponses:

2 pour la réponse № 1

Vous pouvez le faire avec un matcher regex.

Quelque chose comme:

 Pattern pattern = Pattern.compile("\d");
Matcher matcher = pattern.matcher(inputString);
if(matcher.find()) {
return matcher.first();
}
return -1;

C'est assez lisible et extensible. Certains pourraient le considérer comme excessif par rapport à un simple for boucle à travers la chaîne. Compiler le regex prend du temps, et vous avez quelques objets créés, et tout cela coûte si vous êtes fanatique de la performance.

 for(int i=0; i<str.length; i++) {
char c = str.charAt(i);
if(c >="0" && c <= "9") {
return i;
}
}
return -1;

Nécessaire, quelque chose devra regarder chaque caractère tour à tour, donc il y aura une boucle quelque part, que vous l'écriviez ou que ce soit dans la méthode de bibliothèque que vous appelez.

Vous pourrez peut-être réduire la vitesseplusieurs cœurs en divisant la chaîne en morceaux et en faisant quelque chose de map-reduction-ish. Mais cela ne valait la peine que pour des chaînes vraiment énormes dans lesquelles les chiffres étaient rares.

---

1 pour la réponse № 2

La méthode consiste à utiliser l 'expression régulière, qui est un moyen très puissant de représenter le contenu de la chaîne.

String str = "Hello world";
str.matches("\w+ \w+");                   // returns true

Et l'exemple d'utilisation des classes Pattern et Matcher.

String line = "Hello amazing world";
String pattern = "(\w+) \w+ (\w+)";

Pattern r = Pattern.compile(pattern);
Matcher m = r.matcher(line);

if (m.find( )) {
System.out.println(m.group(1));        // Prints "Hello"
System.out.println(m.group(2));        // Prints "world"
}

---

0 pour la réponse № 3

Vous pouvez vérifier l'ascii des caractères pour voir s'il s'agit d'un entier ou non

Remarque: en supposant que l'entier n'est qu'à 1 chiffre

String str = "hello123";
for(int i=0; i < str.length(); i++) {
char c = str.charAt(i);
if(c >= "0" && c <= "9") {
// Code goes here
}
}

Solutions alternatives:

• Utilisez indexOf () pour chaque caractère cible, mais cela aura une complexité temporelle de O (n ^ 2)
• Stockez l'ensemble des entiers cibles dans un ensemble, puis bouclez sur la chaîne et vérifiez si les caractères sont dans l'ensemble (c'est bien si l'entier est à plus d'un chiffre)

---

0 pour la réponse № 4

Vous pouvez également éviter .charAt(i), bien qu'il n'y ait pas grand-chose à y voir ... Obtenez simplement un tableau de char à partir de la chaîne, et en boucle avec un index FOR boucle qui renvoie l'index en atteignant le premier chiffre:

char[] chars = string.toCharArray();
for (int i=0; i<chars.lenght; i++) {
if(chars[i] >= "0" && chars[i] <= "9")
return i; //Or whatever code you need.
}

---

0 pour la réponse № 5

Si je comprends bien votre question, vous avez un tas de caractères suivis d'un tas d'entiers.

Vous pouvez utiliser un recherche binaire pour trouver le point de la chaîne où la transition se produit. Cela devrait s'avérer utile si vous devez analyser de très grandes chaînes. La pire performance des cas est O (log n).

J'ai codé un exemple ci-dessous:

public class binSearch {

static int indexFinder(String s) {

// this doesn"t check for invalid inputs btw
int beg = 0;
int end = s.length() - 1;
int mid;
int iter = 0;
while (beg < end) {
System.out.println("Iteration: " + iter + "   String: " + s.substring(beg, end+1));
mid = (end + beg) / 2;
System.out.println("Mid: " + mid + "   char: " + s.charAt(mid));
if (Character.isDigit(s.charAt(mid))) {
if (Character.isDigit(s.charAt(beg))) {
return beg;
}
end = mid;
} else {
beg = mid + 1;
}
iter++;
}
return beg;
}

public static void main(String[] args) {
System.out.println("Running");
String[] strings = {"joohhhnnnnnCEEENNAAAAAA123829898", "efi1029082198"};

for (String s : strings) {
StringBuilder check = new StringBuilder();
for(int i = 0; i < s.length(); i++) {
check.append(i % 10);
}
System.out.println(s);
System.out.println(check.toString() + "n");
System.out.println("First int index: " + indexFinder(s) + "nn");
}
}
}

Sortie:

Running
joohhhnnnnnCEEENNAAAAAA123829898
01234567890123456789012345678901

Iteration: 0   String: joohhhnnnnnCEEENNAAAAAA123829898
Mid: 15   char: N
Iteration: 1   String: NAAAAAA123829898
Mid: 23   char: 1
Iteration: 2   String: NAAAAAA1
Mid: 19   char: A
Iteration: 3   String: AAA1
Mid: 21   char: A
Iteration: 4   String: A1
Mid: 22   char: A
First int index: 23


efi1029082198
0123456789012

Iteration: 0   String: efi1029082198
Mid: 6   char: 9
Iteration: 1   String: efi1029
Mid: 3   char: 1
Iteration: 2   String: efi1
Mid: 1   char: f
Iteration: 3   String: i1
Mid: 2   char: i
First int index: 3

---