regex, split, iteracja

Split / iteracja [po, czyms, takim] ,aby otrzymać podczas iteracji tylko same słowa?

wymyśliłam coś takeigo, ale nie działa przy slowkach

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

public class Main {
    public static void main(String[] args) {
        String slowka = "[po, czyms, takim]";
        String slowka2 = "[albotakim]";

        Pattern p = Pattern.compile("\\[(.*?)\\]");
        Matcher m = p.matcher(slowka);
        Matcher m2 = p.matcher(slowka2);

        while (m2.find())
            System.out.println(m2.group(1));

        while (m.find()) {
            System.out.println(m.group(1));
        }
    }
}

A nie możesz szukac po prostu [a-zA-Z]+ ?

public class Main {
    static void wypisz(String s) {
        for (String x : s.substring(1, s.length() - 1).split(", ")) {
            System.out.println(x);
        }
    }

    public static void main(String[] args) {
        wypisz("[po, czyms, takim]");
        wypisz("[albotakim]");
    }
}

Jest spilt, regex (w splicie) i iteracja (w foreachu) :]

public class Test {

	@org.junit.Test
	public void testName() throws Exception {
		String slowka = "[po, czyms, takim]";
		String slowka2 = "[albotakim]";
		splitAndDo(slowka, System.out::println);
		splitAndDo(slowka2, System.out::println);
	}

	public void splitAndDo(String input, Consumer<String> s){
		Arrays.stream(input.split(","))
				.map(a-> a.replaceAll("[^a-zA-Z\\p{L}]", ""))
				.filter(b->b.length()>0)
				.forEach(s);

	}
}

split, replace, iteracja.

// edit: dodałem usuwanie pustych ciągów tak by łapało np. [ala, ma, kota, sierściucha, @#$@#$@] choć regex nie łapie polskich znaków już łapie ;)

Jesli chodzi o szybkosc (ktos pytal wczesniej) to wydaje mi sie ze rozwiazanie koziolka jest najgorsze bo wielokrotnie uzywa tych samych regexow: 1. najpierw split(", ") wewnetrznie ich uzywa 2. replaceAll rowniez, przy czym split jest raz, a replaceAll za kazdym razem, dla kazdego elementu.
No ale najwazniejsze ze mozna sie popisac znajomoscia modnych, 'nowoczesnych' lambd i strumieni w jdk8.

@the real mućka, ale można je wyekstrahować do czegoś już skompilowanego za pomocą Pattern.compile(regex).matcher(str).replaceAll(repl):

static Pattern  p =Pattern.compile("[^a-zA-Z\\p{L}]");
// i dalej:
    public void splitAndDo(String input, Consumer<String> s){
        Arrays.stream(input.split(","))
                .map(a-> p.matcher(a).replaceAll(""))
                .filter(b->b.length()>0)
                .forEach(s);
 
    }

i od ręki można to zrównoleglić.
Względnie można zrobić splita za pomocą wyrażenia zamieniającego (split("[^\\p{L}]")):

	@Test
	public void testName() throws Exception {
		String slowka = "[po, czyms, takim]";
		String slowka2 = "[albotakim]";
		splitAndDo(slowka, System.out::println);
		splitAndDo(slowka2, System.out::println);
	}

	public void splitAndDo(String input, Consumer<String> s){
		Arrays.stream(input.split("[^\\p{L}]{1,}"))
				.forEach(s);

	}

tylko pytanie, czy w takim wypadku kod nie zaczyna się zbytnio motać na poziomie wyrażenia. Zresztą ciekawe, ze split wyłapałeś, a powtórzenia w grupie, które powoduje znacznie większy narzut już nie...

Prawde mowiac nawet na tego regexa nie spojrzalem, tylko stwierdzilem fakt na temat tego 'potworka' ;d

Splitter.on(",").split(array);

i pozamiatane ;)

Bardzo daleko od pozamiatania, przeczytaj uważnie pytanie.