konwersja ciągów na tablice ciągów w java

Mam string = "name"; Chcę przekonwertować na tablicy ciągów. Jak mam to zrobić? Czy jest jakaś wbudowana funkcja java? Mogę to zrobić ręcznie, ale szukam wbudowanej funkcji Java.

Chcę mieć tablicę, w której każdy znak ciągu będzie ciągiem. podobnie jak char 'n' będzie teraz ciągiem „n” przechowywanym w tablicy.

Aby rozpocząć zadanie, String.splitdzieli ciągi na wyrażenie regularne, a to wyrażenie może być pustym ciągiem:

String[] ary = "abc".split("");

Daje tablicę:

(java.lang.String[]) [, a, b, c]

Pozbycie się pustego pierwszego wpisu pozostawiamy jako ćwiczenie dla czytelnika :-)

Uwaga: w Javie 8 pusty pierwszy element nie jest już uwzględniany.

String strName = "name";
String[] strArray = new String[] {strName};
System.out.println(strArray[0]); //prints "name"

Drugi wiersz przydziela tablicę String o długości 1. Pamiętaj, że nie musisz samodzielnie określać długości, na przykład:

String[] strArray = new String[1];

zamiast tego długość jest określana przez liczbę elementów w inicjatorze. Za pomocą

String[] strArray = new String[] {strName, "name1", "name2"};

tworzy tablicę o długości 3.

Zakładając, że naprawdę chcesz mieć tablicę ciągów jednoznakowych (nie a char[]lub Character[])

1. Korzystanie z wyrażenia regularnego:

public static String[] singleChars(String s) {
    return s.split("(?!^)");
}

Ujemne antycypowanie o zerowej szerokości zapobiega dopasowaniu wzorca na początku danych wejściowych, więc nie otrzymasz wiodącego pustego ciągu.

2. Korzystanie z guawy :

import java.util.List;

import org.apache.commons.lang.ArrayUtils;

import com.google.common.base.Functions;
import com.google.common.collect.Lists;
import com.google.common.primitives.Chars;

// ...

public static String[] singleChars(String s) {
    return
        Lists.transform(Chars.asList(s.toCharArray()),
                        Functions.toStringFunction())
             .toArray(ArrayUtils.EMPTY_STRING_ARRAY);
}

Myślę, że po prostu nie ma takiej potrzeby, ponieważ nie będzie to prostsze niż

String[] array = {"name"};

Oczywiście, jeśli nalegasz, możesz napisać:

static String[] convert(String... array) {
   return array;
}

String[] array = convert("name","age","hobby"); 

[Edytuj] Jeśli chcesz ciągi jednoliterowe, możesz użyć:

String[] s = "name".split("");

Niestety s [0] będzie puste, ale po nim pojawią się litery n, a, m, e. Jeśli jest to problem, możesz użyć np. System.arrayCopy, aby pozbyć się pierwszego wpisu tablicy.

String data = "abc";
String[] arr = explode(data);

public String[] explode(String s) {
    String[] arr = new String[s.length];
    for(int i = 0; i < s.length; i++)
    {
        arr[i] = String.valueOf(s.charAt(i));
    }
    return arr;
}

W java 8 istnieje metoda, za pomocą której można to zrobić: toCharArray ():

String k = "abcdef";
char[] x = k.toCharArray();

Z tego wynika następująca tablica:

[a,b,c,d,e,f]

Tablica ciągów = tablica znaków?

A może masz ciąg zawierający wiele słów, z których każde powinno być elementem tablicy?

String[] array = yourString.split(wordSeparator);

Po prostu użyj .toCharArray()metody w Javie:

String k = "abc";
char[] alpha = k.toCharArray();

To powinno działać dobrze w Javie 8.

Konwertować na tekst Char?

http://www.javadb.com/convert-string-to-character-array

Możesz użyć string.chars().mapToObj(e -> new String(new char[] {e}));, chociaż jest to dość długie i działa tylko z Javą 8. Oto kilka innych metod:

string.split(""); (Has an extra whitespace character at the beginning of the array if used before Java 8) string.split("|"); string.split("(?!^)"); Arrays.toString(string.toCharArray()).substring(1, string.length() * 3 + 1).split(", ");

Ostatni jest po prostu niepotrzebnie długi, to po prostu dla zabawy!

Dodatkowa metoda:

Jak już wspomniano, można dość łatwo przekonwertować oryginalną „nazwę” ciągu na tablicę znaków:

String originalString = "name";
char[] charArray = originalString.toCharArray();

Aby kontynuować ten tok myśli, możesz następnie przekonwertować tablicę char na tablicę String:

String[] stringArray = new String[charArray.length];
for (int i = 0; i < charArray.length; i++){
    stringArray[i] = String.valueOf(charArray[i]);
}

W tym momencie twój stringArray zostanie wypełniony oryginalnymi wartościami z oryginalnego ciągu „name”. Na przykład teraz dzwonię

System.out.println(stringArray[0]);

W tym przypadku zwróci wartość „n” (jako ciąg znaków).

Dzielenie pustego ciągu za pomocą String.split () zwraca tablicę pojedynczego elementu zawierającą pusty ciąg . W większości przypadków prawdopodobnie wolisz otrzymać pustą tablicę lub wartość null, jeśli przekazałeś wartość null, co jest dokładnie tym, co dostajesz za pomocą org.apache.commons.lang3.StringUtils.split (str) .

import org.apache.commons.lang3.StringUtils;

StringUtils.split(null)       => null
StringUtils.split("")         => []
StringUtils.split("abc def")  => ["abc", "def"]
StringUtils.split("abc  def") => ["abc", "def"]
StringUtils.split(" abc ")    => ["abc"]

Inną opcją jest google guava Splitter.split () i Splitter.splitToList (), które zwracają odpowiednio iterator i listę. W przeciwieństwie do wersji Apache Splitter wyrzuci NPE na null:

import com.google.common.base.Splitter;

Splitter SPLITTER = Splitter.on(',').trimResults().omitEmptyStrings();

SPLITTER.split("a,b,   c , , ,, ")     =>  [a, b, c]
SPLITTER.split("")                     =>  []
SPLITTER.split("  ")                   =>  []
SPLITTER.split(null)                   =>  NullPointerException

Jeśli wolisz listę niż iterator, użyj Splitter.splitToList () .

/**
 * <pre>
 * MyUtils.splitString2SingleAlphaArray(null, "") = null
 * MyUtils.splitString2SingleAlphaArray("momdad", "") = [m,o,m,d,a,d]
 * </pre>
 * @param str  the String to parse, may be null
 * @return an array of parsed Strings, {@code null} if null String input
 */
public static String[] splitString2SingleAlphaArray(String s){
    if (s == null )
        return null;
    char[] c = s.toCharArray();
    String[] sArray = new String[c.length];
    for (int i = 0; i < c.length; i++) {
        sArray[i] = String.valueOf(c[i]);
    }
    return sArray;
}

Metoda String.splitwygeneruje pusty pierwszy, musisz go usunąć z tablicy. To jest nudne.

Opierając się na tytule tego pytania, przyszedłem tutaj, aby przekonwertować ciąg znaków na tablicę podciągów podzielonych przez jakiś separator. Dodam tutaj tę odpowiedź dla innych, którzy mogą mieć to samo pytanie.

To tworzy tablicę słów, dzieląc ciąg w każdej spacji:

String str = "string to string array conversion in java";
String delimiter = " ";
String strArray[] = str.split(delimiter);

Tworzy to następującą tablicę:

// [string, to, string, array, conversion, in, java]

Źródło

Przetestowano w Javie 8

tutaj jest przekonwertowanie prostego ciągu na tablicę ciągów przy użyciu metody podziału.

String [] stringArray="My Name is ABC".split(" ");

Wynik

stringArray[0]="My";
stringArray[1]="Name";
stringArray[2]="is";
stringArray[3]="ABC";