Konwersja ciągu znaków na tablicę „znaków” w Javie

Chcę przekonwertować a Stringna tablicę obiektów klasy Character, ale nie mogę wykonać konwersji. Wiem, że za pomocą toCharArray()metody mogę przekonwertować String na tablicę pierwotnego typu danych „char” , ale nie pomaga to w konwersji ciągu znaków na tablicę obiektów typu Character .

Jak bym to zrobił?

Użyj tego:

String str = "testString";
char[] charArray = str.toCharArray();
Character[] charObjectArray = ArrayUtils.toObject(charArray);

Jedna wkładka z java-8:

String str = "testString";

//[t, e, s, t, S, t, r, i, n, g]
Character[] charObjectArray = 
    str.chars().mapToObj(c -> (char)c).toArray(Character[]::new); 

Co to jest:

• zdobądź jedną IntStreamz postaci (możesz również spojrzeć codePoints())
• odwzoruj wartość każdego znaku na Character(musisz rzucić, aby faktycznie powiedzieć, że to naprawdę a char, a następnie Java automatycznie ustawi go w polu Character)
• uzyskać wynikową tablicę, wywołując toArray()

Może sam napiszesz małą metodę

public Character[] toCharacterArray( String s ) {

   if ( s == null ) {
     return null;
   }

   int len = s.length();
   Character[] array = new Character[len];
   for (int i = 0; i < len ; i++) {
      /* 
      Character(char) is deprecated since Java SE 9 & JDK 9
      Link: https://docs.oracle.com/javase/9/docs/api/java/lang/Character.html
      array[i] = new Character(s.charAt(i));
      */
      array[i] = s.charAt(i);
   }

   return array;
}

Mam nadzieję, że poniższy kod ci pomoże.

String s="Welcome to Java Programming";
char arr[]=s.toCharArray();
for(int i=0;i<arr.length;i++){
    System.out.println("Data at ["+i+"]="+arr[i]);
}

Działa, a wynik to:

Data at [0]=W
Data at [1]=e
Data at [2]=l
Data at [3]=c
Data at [4]=o
Data at [5]=m
Data at [6]=e
Data at [7]= 
Data at [8]=t
Data at [9]=o
Data at [10]= 
Data at [11]=J
Data at [12]=a
Data at [13]=v
Data at [14]=a
Data at [15]= 
Data at [16]=P
Data at [17]=r
Data at [18]=o
Data at [19]=g
Data at [20]=r
Data at [21]=a
Data at [22]=m
Data at [23]=m
Data at [24]=i
Data at [25]=n
Data at [26]=g

String#toCharArrayzwraca tablicę char, co masz jest tablicą Character. W większości przypadków nie ma znaczenia, czy używasz, charczy Characterteż jest to autoboxing . Problem w twoim przypadku polega na tym, że tablice nie są autoboxowane, sugeruję użycie tablicy char ( char[]).

W takim przypadku musisz napisać własną metodę. Użyj pętli i pobierz każdy znak za pomocą charAt(i)i ustaw go na swoją Character[]tablicę za pomocą arrayname[i] = string.charAt[i].

Ta metoda przyjmuje String jako argument i zwraca tablicę znaków

/**
 * @param sourceString
 *            :String as argument
 * @return CharcterArray
 */
public static Character[] toCharacterArray(String sourceString) {
    char[] charArrays = new char[sourceString.length()];
    charArrays = sourceString.toCharArray();
    Character[] characterArray = new Character[charArrays.length];
    for (int i = 0; i < charArrays.length; i++) {
        characterArray[i] = charArrays[i];
    }
    return characterArray;
}

inny sposób, aby to zrobić.

String str="I am a good boy";
    char[] chars=str.toCharArray();

    Character[] characters=new Character[chars.length];
    for (int i = 0; i < chars.length; i++) {
        characters[i]=chars[i];
        System.out.println(chars[i]);
    }

Konwersja ciągu znaków na tablicę znaków, a następnie konwersja tablicy znaków z powrotem na ciąg

   //Givent String
   String given = "asdcbsdcagfsdbgdfanfghbsfdab";

   //Converting String to Character Array(It's an inbuild method of a String)
   char[] characterArray = given.toCharArray();
   //returns = [a, s, d, c, b, s, d, c, a, g, f, s, d, b, g, d, f, a, n, f, g, h, b, s, f, d, a, b]

// JEDEN SPOSÓB: Konwersja tablicy znaków z powrotem na łańcuch

  int length = Arrays.toString(characterArray).replaceAll("[, ]","").length();

  //First Way to get the string back
  Arrays.toString(characterArray).replaceAll("[, ]","").substring(1,length-1)
  //returns asdcbsdcagfsdbgdfanfghbsfdab
  or 
  // Second way to get the string back
  Arrays.toString(characterArray).replaceAll("[, ]","").replace("[","").replace("]",""))
 //returns asdcbsdcagfsdbgdfanfghbsfdab

// DRUGI SPOSÓB: Konwersja tablicy znaków z powrotem na łańcuch

String.valueOf(characterArray);

// TRZECI SPOSÓB: Konwersja tablicy znaków z powrotem na łańcuch

Arrays.stream(characterArray)
           .mapToObj(i -> (char)i)
           .collect(Collectors.joining());

Konwertowanie ciągu znaków na tablicę znaków

Character[] charObjectArray =
                           givenString.chars().
                               mapToObj(c -> (char)c).
                               toArray(Character[]::new);

Konwersja tablicy znaków na tablicę znaków

 String givenString = "MyNameIsArpan";
char[] givenchararray = givenString.toCharArray();


     String.valueOf(givenchararray).chars().mapToObj(c -> 
                         (char)c).toArray(Character[]::new);

korzyści z konwersji tablicy char Array na tablicę znaków możesz użyć funkcji Arrays.stream, aby uzyskać tablicę podrzędną

String subStringFromCharacterArray = 

              Arrays.stream(charObjectArray,2,6).
                          map(String::valueOf).
                          collect(Collectors.joining());

jeśli pracujesz z JTextField, może to być pomocne.

public JTextField display;
String number=e.getActionCommand();

display.setText(display.getText()+number);

ch=number.toCharArray();
for( int i=0; i<ch.length; i++)
    System.out.println("in array a1= "+ch[i]);

łańcuchy są zawsze najlepsze: D

String str = "somethingPutHere";
Character[] c = ArrayUtils.toObject(str.toCharArray());

Jeśli nie chcesz polegać na interfejsach API innych firm, oto działający kod JDK7 lub niższy. Nie tworzę tymczasowych obiektów postaci, jak to robią inne rozwiązania powyżej. wszystkie pętle są bardziej czytelne, zobacz sam :)

public static Character[] convertStringToCharacterArray(String str) {
    if (str == null || str.isEmpty()) {
        return null;
    }
    char[] c = str.toCharArray();
    final int len = c.length;
    int counter = 0;
    final Character[] result = new Character[len];
    while (len > counter) {
        for (char ch : c) {
            result[counter++] = ch;
        }
    }
    return result;
}

Użyłem StringReader klasę w java.io . Jedna z jego funkcji read(char[] cbuf)wczytuje zawartość łańcucha do tablicy.

String str = "hello";
char[] array = new char[str.length()];
StringReader read = new StringReader(str);

try {
    read.read(array); //Reads string into the array. Throws IOException
} catch (IOException e) {
    e.printStackTrace();
}

for (int i = 0; i < str.length(); i++) {
        System.out.println("array["+i+"] = "+array[i]);
}

Uruchomienie tego daje wynik:

array[0] = h
array[1] = e
array[2] = l
array[3] = l
array[4] = o