Découper une chaîne uniquement si elle contient plusieurs années et créer une chaîne personnalisée

Question

J'ai une chaîne dans le format ci-dessous:

[string1][string2][string3][string4][string5][string6]

dans lequel la première chaîne qui est string1 sera toujours Year et elle sera dans ce format AAAA donc l'exemple est:

[2010][Toyota][ALL][Hatchback][998ccm 68HP 50KW]

Maintenant, dans certains cas, string1 est dans ce format 2010^K2011^K2012^K2013^K2014^K2015^K2016^K2017 dans lequel chaque année est séparée par le délimiteur ^K. Exemple:

[2010^K2011^K2012^K2013^K2014^K2015^K2016^K2017][Toyota][ALL][Hatchback][998ccm 68HP 50KW]

Maintenant, chaque fois que je vois des chaînes dans le format ci-dessus, je dois analyser la chaîne d'années, la diviser par le délimiteur et extraire chaque année individuelle, puis faire une liste de chaînes dans ce format ci-dessous:

[2010][Toyota][ALL][Hatchback][998ccm 68HP 50KW]
[2011][Toyota][ALL][Hatchback][998ccm 68HP 50KW]
[2012][Toyota][ALL][Hatchback][998ccm 68HP 50KW]
[2013][Toyota][ALL][Hatchback][998ccm 68HP 50KW]
[2014][Toyota][ALL][Hatchback][998ccm 68HP 50KW]
[2015][Toyota][ALL][Hatchback][998ccm 68HP 50KW]
[2016][Toyota][ALL][Hatchback][998ccm 68HP 50KW]
[2017][Toyota][ALL][Hatchback][998ccm 68HP 50KW]

Donc je peux penser aux cas suivants:

• Si la chaîne d'années n'a qu'une seule année alors je l'utiliserai telle quelle sans la diviser.
• Si la chaîne d'années a plusieurs années séparées par un délimiteur alors je vais diviser ces années et créer une liste de chaînes comme indiqué ci-dessus.
• Si la chaîne d'années n'a pas d'année pour quelque raison que ce soit alors je vais utiliser la chaîne telle quelle sans la diviser ou autre chose.

Est-il possible de le faire? Je sais comment diviser une chaîne sur un caractère spécial ^ mais la confusion est comment extraire string1 et vérifier s'il contient plusieurs années (si oui alors le diviser) ou s'il contient une seule année ou autre chose.

  public static void main(String[] args) {
    // String myString =
    // "[2010^K2011^K2012^K2013^K2014^K2015^K2016^K2017][Toyota][ALL][Hatchback][998ccm 68HP 50KW]";
    String myString = "[2010][Toyota][ALL][Hatchback][998ccm 68HP 50KW]";

  }

Answer 1

J'ai trouvé cette méthode:

public static String[] splitYears(String str) {
    // obtenir la partie année de la chaîne en utilisant une regex
    Matcher m = Pattern.compile("^\\[([\\d^K]+)\\]").matcher(str);
    if(m.find()) {
        String yearPart = m.group(1);
        // séparer les autres parties. Le + 2 ici est pour prendre en compte les deux crochets dans yearPart
        String otherParts = str.substring(yearPart.length() + 2);
        // séparer par ^K
        String[] years = yearPart.split("\\^K");
        // Construire une nouvelle chaîne pour chaque année
        String[] newYears = new String[years.length];
        for (int i = 0; i < years.length; i++) {
            newYears[i] = String.format("[%s]%s", years[i], otherParts);
        }
        return newYears;
    } else {
        return new String[] {str};
    }
}

Utilisation:

System.out.println(Arrays.toString(splitYears("[2010^K2011^K2012^K2013^K2014^K2015^K2016^K2017][Toyota][ALL][Hatchback][998ccm 68HP 50KW]")));

Answer 2

Maintenant que je vois qu'il y a une réponse acceptée pour votre question, je veux vous montrer mes tentatives pour résoudre votre problème - vous pourriez vouloir essayer ou peut-être trouver quelque chose d'intéressant ici de toute façon (j'ai ajouté quelques explications dans les commentaires du code)

Solution avec l'utilisation de regex:

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Test {

    public static void main(String[] args) {
       String s1 = "[2010][Toyota][ALL][Hatchback][998ccm 68HP 50KW]";
       String s2 = "[2010^K2011^K2012^K2013^K2014][Toyota][ALL][Hatchback][998ccm 68HP 50KW]";

       String[] oneYearString = transformString(s1);
       String[] moreYearsString = transformString(s2);

       for(String s : oneYearString) {
                      System.out.println(s);
       }
       System.out.println();

       for(String s : moreYearsString) {
          System.out.println(s);
       }
    }

    public static String[] transformString(String source) {
        Pattern pattern = Pattern.compile("^\\[([^]]+)(.*)"); // contents of first square bracket are in first matching group
                                                                     // in first parenthesis (), the following part is in second matching group parenthesis 
        Matcher m = pattern.matcher(source); // matcher that compares source String with given pattern
        String[] result;
        while(m.find()) {
            if(m.group(1).length() == 4) { //if there are 4 characters in first square bracket... 
                result = new String[] {source};
                return result; // return String[] containing only one element
            } else { // if there are more than 4 characters... 
                String[] splittedYears = m.group(1).split("\\^K"); // split content of first bracket on given delimiter
                result = new String[splittedYears.length]; // here you're gonna store result Strings
                for(int i = 0; i < result.length; i++) {
                    String entry = "[" + splittedYears[i] + m.group(2); // creating properly formatted string for each year
                    result[i] = entry; // adding properly prepared String to array
                }
                return result; // return String[] with results
            }
        }
        return null;
    }
}

Résultat obtenu lors de son exécution:

[2010][Toyota][ALL][Hatchback][998ccm 68HP 50KW]

[2010][Toyota][ALL][Hatchback][998ccm 68HP 50KW]
[2011][Toyota][ALL][Hatchback][998ccm 68HP 50KW]
[2012][Toyota][ALL][Hatchback][998ccm 68HP 50KW]
[2013][Toyota][ALL][Hatchback][998ccm 68HP 50KW]
[2014][Toyota][ALL][Hatchback][998ccm 68HP 50KW]

Solution sans regex:

(Affichage uniquement de la méthode modifiée)

public static String[] transformString(String source) {
    String firstBracket = source.substring(source.indexOf('[') + 1, source.indexOf(']'));
    String[] result;
    if(firstBracket.length() == 4) {
        result = new String[] {source};
        return result;
    } else {
        System.out.println(firstBracket);
        String[] splittedYears = firstBracket.split("\\^K");
        result = new String[splittedYears.length];
        for(int i = 0; i < result.length; i++) {
            String entry = "[" + splittedYears[i] + source.substring(source.indexOf(']'));
            result[i] = entry;
        }
        return result;
    }
}

Answer 3

Même cela fonctionnera

String str = "([0-9]{4})(.*?(?=\\d))?(?:.*?)(\\[.*)";
    Pattern pattern = Pattern.compile(str);
    String input = "[2010^K2011^K2012^K2013^K2014^K2015^K2016^K2017][Toyota][ALL][Hatchback][998ccm 68HP 50KW]";
    Matcher matcher;
    do
    {
        matcher = pattern.matcher(input);
        if (matcher.find())
        {
            System.out.println("[" + matcher.group(1) + "]" + matcher.group(3));
            input = input.replace(matcher.group(1) + matcher.group(2), "");
        }
    } while (matcher.group(2) != null);

Answer 4

Java.lang.String a quelques méthodes pour faciliter cela.

Vous devriez probablement diviser pour séparer chaque chaîne en isolant "string1" comme l'a suggéré Scary Wombat. quelque chose comme :

String[] stringArray = myString.split("]\\[|\\[|]");

Remarque : cela créera une chaîne vide à [0].

Pour éviter cela, je retirerais préventivement le premier "[" avec

myString.replaceFirst();

Maintenant que vous avez un tableau de chaînes, le premier élément est votre année.

for(String year : stringArray.split("\\^K")
{
    faire des choses ici.
}