Dotaz: JAVA - rozdelit slovo na pismena

[tomes.io]

Ahoj, bojuju s rozdelenim slova na jednotliva pismena. Konkretne bych potreboval ze slova(jednoho retezce), kuprikladu:

M41

dostat jako vystup :

M<41>

. Potrebuju oddelit prvni pismeno a cisla za nim dat do sipek.

Zkousel jsem :

slovo.split("")

s tim ze bych si tam pak ty sipky concatoval, ale ten split() me to na pismena nerozdeli.

Pokud bych rozdelil slovo na pole charu, tak zas asi tezko concatuju ty sipky...

Mohl by nekdo poradit pls?

---

---

Odpovědi

[Franta]

Pokud bych rozdelil slovo na pole charu, tak zas asi tezko concatuju ty sipky...

Pak to pole projdeš v cyklu a pomocí StringBuilderu postupně sestavíš nový řetězec – na některá místa přidáš ty šipky.

Měl bys ale upřesnit zadání. Proč chceš šipky přidat zrovna kolem 41? Možná by se ti hodily regulární výrazy – definuješ si vzor, ten může obsahovat skupiny (části textu) a ty si pak vytáhneš a třeba obalíš šipkami.

[tomes.io]

Kolem cisla musi byt sipky. Mam to v zadani. Slouzi to potom pro lepsi parsovani, objekty budou nadale sortovany podle cisel, takze az budu definovat comparTo tak se to bude hodit.

Kazdopadne nakonec jsem to vyresil pres regularni vyrazy, jak jsi rekl. Dostal jsem diky tomu aspon String s cislem, coz uz mi pomohlo:

char[] charArray = word.toCharArray();
String temp = Character.toString(charArray[0]); //getting object letter
                
Pattern pattern = Pattern.compile("^"+temp+"(\\d+)$"); //setting a regex pattern
Matcher matcher = pattern.matcher(word);
    
if(!(matcher.matches())) {
                    
    throw new CatalogIOException("wrong ID format");
}
                
                        
String ID = temp.concat("<").concat(matcher.group(1)).concat(">"); //matcher.gorup(1) returns a string with the object number

[xkucf03]

Tak v druhém kroku můžeš zkusit OOP Místo vymýšlení nějakého pseudojazyka s čísly v závorkách z toho udělej instance nějaké tvé třídy, kde to číslo bude uložené jako int v privátní proměnné.

[danaketh]

jsou v jave regexy?

v perlu bych to napsal takhle:

s/^([a-z])([0-9]+)/$1<$2>/i;

[xkucf03]

Ano, součástí základní knihovny Javy SE jsou regulární výrazy. Napíšeš to třeba takhle:

"M41".replaceAll("([0-9]+)", "<$1>")

(a při opakovaném použití je dobré si regulární výrazy předkompilovat)

[Robo]

public static String updateText(String str) {
        StringBuffer updatedText = new StringBuffer();
        Matcher matcher = Pattern.compile("\\d+").matcher(str);
        while(matcher.find()) {
            String group = matcher.group();
            StringBuilder replacement = new StringBuilder();
            replacement.append("<").append(group).append(">");
            matcher.appendReplacement(updatedText, replacement.toString());
        }
        matcher.appendTail(updatedText);
        return updatedText.toString();
}

[DarkKnightCZ]

no to potes, takova prasarna... proc navic komentujete 100 dni stary dotaz, kde navic padlo elegantni reseni?

[Nobody]

Vubec jste nepochopil vtip.

[potato]

Žádný vtip tady není. Jen nesmyslný komentář sto dní starého dotazu.

[R]

No az taka "prasarna" to teda nie je, pretoze moja funkcia je o polovicu rychlejsia pri kratkych Stringoch, pri dlhych Stringoch sa to vyrovnava s Tvojim "elegantnym resenim". Este lepsie je ale pouzit pri velmi velkych Stringoch/suboroch Scanner (hasNextInt() + nextInt()), ktory sa da napojit na input stream a nezadrbavat pamat. Ale uznavam, ze 1 riadkova funkcia je elegantna.

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

public class Test {

    private static final String TEST_STRING = "M23";

    public static void main(String[] args) {
        Date d = new Date();
        Pattern pattern = Pattern.compile("\\d+");

        for(int i = 0; i < 10000000; i++) {
            TEST_STRING.replaceAll("([0-9]+)", "<$1>");

        }

        System.out.println(new Date().getTime() - d.getTime());

        d = new Date();

        for(int i = 0; i < 10000000; i++) {
            updateText(pattern, TEST_STRING);
        }

        System.out.println(new Date().getTime() - d.getTime());

    }

    public static String updateText(Pattern pattern, String str) {
        StringBuffer updatedText = new StringBuffer();
        Matcher matcher = pattern.matcher(str);
        while(matcher.find()) {
            String group = matcher.group();
            StringBuilder replacement = new StringBuilder();
            replacement.append("<").append(group).append(">");
            matcher.appendReplacement(updatedText, replacement.toString());
        }
        matcher.appendTail(updatedText);
        return updatedText.toString();
    }

}

[R]

Sorac, samozrejme v teste ma byt kompilacia patternu pred prvym Date d = new Date(); Vysvetlenie ale plati. Na priklade a na mojej masine 7 sekund (dlha fkcia) vs 4 sekundy (1 riadkovy replaceAll).

[R]

7 sekund replaceAll vs 4 sekundy dlha fkcia.