Semblable à une question postée ici , je cherche une solution en Java.
Comment trouver l’indice de la nième occurrence d’un caractère/d’une chaîne dans une chaîne?
Exemple: "/folder1/folder2/folder3/". Dans ce cas, si je demande la 3ème occurrence de slash (/), celle-ci apparaît avant folder3 et je compte renvoyer cette position d'index. Mon intention actuelle est de le soustraire de la nième occurrence d'un caractère.
Existe-t-il une méthode pratique/prête à l'emploi disponible dans Java ou devons-nous écrire nous-mêmes une petite logique pour résoudre ce problème?
Aussi,
Si votre projet dépend déjà d’Apache Commons, vous pouvez utiliser StringUtils.ordinalIndexOf
, sinon, voici une implémentation:
public static int ordinalIndexOf(String str, String substr, int n) {
int pos = str.indexOf(substr);
while (--n > 0 && pos != -1)
pos = str.indexOf(substr, pos + 1);
return pos;
}
Cet article a été réécrit sous forme d'article ici .
Je pense que la solution la plus simple pour trouver la nième occurrence d'une chaîne est d'utiliser StringUtils.ordinalIndexOf () d'Apache Commons.
Exemple:
StringUtils.ordinalIndexOf("aabaabaa", "b", 2) == 5
Deux options simples se présentent:
charAt()
à plusieurs reprisesindexOf()
à plusieurs reprisesPar exemple:
public static int nthIndexOf(String text, char needle, int n)
{
for (int i = 0; i < text.length(); i++)
{
if (text.charAt(i) == needle)
{
n--;
if (n == 0)
{
return i;
}
}
}
return -1;
}
Cela pourrait ne pas fonctionner aussi bien que d’utiliser indexOf
à plusieurs reprises, mais c’est peut-être plus simple d’obtenir des résultats corrects.
Vous pouvez essayer quelque chose comme ça:
import Java.util.regex.Matcher;
import Java.util.regex.Pattern;
public class Main {
public static void main(String[] args) {
System.out.println(from3rd("/folder1/folder2/folder3/"));
}
private static Pattern p = Pattern.compile("(/[^/]*){2}/([^/]*)");
public static String from3rd(String in) {
Matcher m = p.matcher(in);
if (m.matches())
return m.group(2);
else
return null;
}
}
Notez que j'ai fait quelques hypothèses dans la regex:
Comme demandé dans un commentaire, je vais essayer d'expliquer la regex: (/[^/]*){2}/([^/]*)
/[^/]*
Est un /
Suivi de [^/]*
(Un nombre quelconque de caractères qui ne sont pas un /
),(/[^/]*)
Regroupe l'expression précédente dans une seule entité. Ceci est le groupe 1
De l'expression,(/[^/]*){2}
Signifie que le groupe doit correspondre parfaitement {2}
Fois,[^/]*
Est encore un nombre quelconque de caractères qui ne sont pas un /
,([^/]*)
Regroupe l'expression précédente dans une seule entité. Ceci est le groupe 2
De l'expression.De cette façon, vous n’avez qu’à obtenir la sous-chaîne qui correspond au deuxième groupe: return m.group(2);
Image fournie par Debuggex
J'ai apporté quelques modifications à la réponse de aioobe, j'ai obtenu la dernière version de LastIndexOf et résolu certains problèmes liés à NPE. Voir le code ci-dessous:
public int nthLastIndexOf(String str, char c, int n) {
if (str == null || n < 1)
return -1;
int pos = str.length();
while (n-- > 0 && pos != -1)
pos = str.lastIndexOf(c, pos - 1);
return pos;
}
([.^/]*/){2}[^/]*(/)
Match tout suivi par/deux fois, puis à nouveau. Le troisième est celui que vous voulez
L’état Matcher peut être utilisé pour indiquer où se trouve le dernier/est
public static int nth(String source, String pattern, int n) {
int i = 0, pos = 0, tpos = 0;
while (i < n) {
pos = source.indexOf(pattern);
if (pos > -1) {
source = source.substring(pos+1);
tpos += pos+1;
i++;
} else {
return -1;
}
}
return tpos - 1;
}
De nos jours, il y a IS prise en charge d'Apache Commons Lang StringUtils ,
C'est la primitive:
int org.Apache.commons.lang.StringUtils.ordinalIndexOf(CharSequence str, CharSequence searchStr, int ordinal)
pour votre problème, vous pouvez coder ce qui suit: StringUtils.ordinalIndexOf(uri, "/", 3)
Vous pouvez également trouver la n-ième occurrence d'un caractère dans une chaîne avec la méthode lastOrdinalIndexOf .
Une autre approche:
public static void main(String[] args) {
String str = "/folder1/folder2/folder3/";
int index = nthOccurrence(str, '/', 3);
System.out.println(index);
}
public static int nthOccurrence(String s, char c, int occurrence) {
return nthOccurrence(s, 0, c, 0, occurrence);
}
public static int nthOccurrence(String s, int from, char c, int curr, int expected) {
final int index = s.indexOf(c, from);
if(index == -1) return -1;
return (curr + 1 == expected) ? index :
nthOccurrence(s, index + 1, c, curr + 1, expected);
}
Cette réponse améliore la réponse de @aioobe. Deux bugs dans cette réponse ont été corrigés.
1. n = 0 devrait retourner -1.
2. La nième occurrence a renvoyé -1, mais elle a fonctionné avec la n-1ième occurrence.
Essaye ça !
public int nthOccurrence(String str, char c, int n) {
if(n <= 0){
return -1;
}
int pos = str.indexOf(c, 0);
while (n-- > 1 && pos != -1)
pos = str.indexOf(c, pos+1);
return pos;
}
public class Sam_Stringnth {
public static void main(String[] args) {
String str="abcabcabc";
int n = nthsearch(str, 'c', 3);
if(n<=0)
System.out.println("Character not found");
else
System.out.println("Position is:"+n);
}
public static int nthsearch(String str, char ch, int n){
int pos=0;
if(n!=0){
for(int i=1; i<=n;i++){
pos = str.indexOf(ch, pos)+1;
}
return pos;
}
else{
return 0;
}
}
}
Peut-être que vous pourriez réaliser cela par la méthode String.split (..) également.
String str = "";
String[] tokens = str.split("/")
return tokens[nthIndex] == null
public static int findNthOccurrence(String phrase, String str, int n)
{
int val = 0, loc = -1;
for(int i = 0; i <= phrase.length()-str.length() && val < n; i++)
{
if(str.equals(phrase.substring(i,i+str.length())))
{
val++;
loc = i;
}
}
if(val == n)
return loc;
else
return -1;
}
Le code retourne la n-ième position d'occurrence sous-chaîne ou largeur de champ. Exemple. Si string "Débordement de pile dans low melow" est la chaîne à rechercher 2nd occurrence du jeton "low", vous conviendrez avec moi que la 2ème occurrence est à la soustraction - "18 et 21". indexOfOccurance ("Débordement de pile dans un faible melow", low, 2) renvoie 18 et 21 dans une chaîne.
class Example{
public Example(){
}
public String indexOfOccurance(String string, String token, int nthOccurance) {
int lengthOfToken = token.length();
int nthCount = 0;
for (int shift = 0,count = 0; count < string.length() - token.length() + 2; count++, shift++, lengthOfToken++)
if (string.substring(shift, lengthOfToken).equalsIgnoreCase(token)) {
// keeps count of nthOccurance
nthCount++;
if (nthCount == nthOccurance){
//checks if nthCount == nthOccurance. If true, then breaks
return String.valueOf(shift)+ " " +String.valueOf(lengthOfToken);
}
}
return "-1";
}
public static void main(String args[]){
Example example = new Example();
String string = "the man, the woman and the child";
int nthPositionOfThe = 3;
System.out.println("3rd Occurance of the is at " + example.indexOfOccurance(string, "the", nthPositionOfThe));
}
}
Ma solution:
/**
* Like String.indexOf, but find the n:th occurance of c
* @param s string to search
* @param c character to search for
* @param n n:th character to seach for, starting with 1
* @return the position (0-based) of the found char, or -1 if failed
*/
public static int nthIndexOf(String s, char c, int n) {
int i = -1;
while (n-- > 0) {
i = s.indexOf(c, i + 1);
if (i == -1)
break;
}
return i;
}
/* program to find nth occurence of a character */
import Java.util.Scanner;
public class CharOccur1
{
public static void main(String arg[])
{
Scanner scr=new Scanner(System.in);
int position=-1,count=0;
System.out.println("enter the string");
String str=scr.nextLine();
System.out.println("enter the nth occurence of the character");
int n=Integer.parseInt(scr.next());
int leng=str.length();
char c[]=new char[leng];
System.out.println("Enter the character to find");
char key=scr.next().charAt(0);
c=str.toCharArray();
for(int i=0;i<c.length;i++)
{
if(c[i]==key)
{
count++;
position=i;
if(count==n)
{
System.out.println("Character found");
System.out.println("the position at which the " + count + " ocurrence occurs is " + position);
return;
}
}
}
if(n>count)
{
System.out.println("Character occurs "+ count + " times");
return;
}
}
}