String – konwertowanie i zamiana typów: Array, ArrayList, Char, Int, Integer

Konwertowanie i zamiana typów to fragment artykułu na temat klasy String. W tekście zebrane zostały fragmenty kodu pokazujące, w jaki sposób zamienić jeden typ danych na inny.

String to array

1. Zamianę stringa na tablicę stringów można zrobić przy pomocy metody split.

   String str = "J a v a";
   String[] actualStringArray = str.split(" ");
   String[] expectedStringArray = {"J", "a", "v", "a"};
   assertArrayEquals(expectedStringArray, actualStringArray);
   

2. Zamiana stringa na tablicę charów.

   str = "Java";
   char[] actualCharArray = str.toCharArray();
   char[] expectedCharArray = {'J', 'a', 'v', 'a'};
   assertArrayEquals(expectedCharArray, actualCharArray);

Array to String

1. Zamiana przy pomocy metody: Arrays.toString

   String[] array = {"a", "b", "c"};
   String actualValue = Arrays.toString(array);
   String expectedValue = "[a, b, c]";
   assertEquals(expectedValue, actualValue);

2. Zamiana przy pomocy metody: String.join

   actualValue = String.join(", ", array);
   expectedValue = "a, b, c";
   assertEquals(expectedValue, actualValue);

3. Zamiana za pomocą Java Stream

   actualValue = Stream.of(array).collect(Collectors.joining(", "));
   expectedValue = "a, b, c";
   assertEquals(expectedValue, actualValue);

4. Zamiana z wykorzystaniem zwykłej pętli

   actualValue = "";
   for (int i=0; i<array.length; i++) {
       actualValue += array[i];
       if(i!=array.length-1){
           actualValue += ", ";
       }
   }        
   expectedValue = "a, b, c";
   assertEquals(expectedValue, actualValue);

5. Dla zagnieżdżonych tabel można wykorzystać metodę: Arrays.deepToString

   String[][] deepArray = {{"a"}, {"b"}, {"c"}};
   actualValue = Arrays.deepToString(deepArray);
   expectedValue = "[[a], [b], ]";
   assertEquals(expectedValue, actualValue);

Char array to String

1. Zamiana tablicy znaków (charów) na stringa przez konstruktor klasy String

   char[] charArray = {'J', 'a', 'v', 'a'};
   
   String actualValue =  new String(charArray);
   String expectedValue = "Java";
   assertEquals(expectedValue, actualValue);

2. Zamiana przy pomocy metody: String.copyValueOf

   actualValue = String.copyValueOf(charArray);
   expectedValue = "Java";
   assertEquals(expectedValue, actualValue);

3. Zamiana przy pomocy metody: String.valueOf

   actualValue = String.valueOf(charArray);
   expectedValue = "Java";
   assertEquals(expectedValue, actualValue);

4. Zamiana przy pomocy metody: Arrays.toString

   actualValue = Arrays.toString(charArray);
   expectedValue = "[J, a, v, a]";
   assertEquals(expectedValue, actualValue);

Array to ArrayList

1. Zamiana za pomocą metody: Arrays.asList

   String[] array = {"J", "a", "v", "a"};
   List<String> actualValue = Arrays.asList(array);
   List<String> expectedValue = Arrays.asList(new String[]{"J", "a", "v", "a"});

2. Zamiana za pomocą konstruktora i metody: Arrays.asList

   actualValue = new ArrayList<>(Arrays.asList(array));
   

3. Zamiana przez dodanie wszystkich elementów przy pomocy metody: Collections.addAll

   actualValue = new ArrayList<>();
   Collections.addAll(actualValue, array);

4. Zamiana przez Java stream I

   actualValue = Stream.of(array).collect(Collectors.toCollection(ArrayList::new));

5. Zamiana przez Java stream II

   actualValue = Stream.of(array).collect(Collectors.toList());

ArrayList to array

1. Zamiana przy pomocy metody: toArray tworzy tablicę z referencjami typu Object

   List<String> list = Arrays.asList("J", "a", "v", "a");
   String[] expectedValue = {"J", "a", "v", "a"};
   
   Object[] actualValue = list.toArray();
   Assert.assertArrayEquals(expectedValue, actualValue);

2. Jeżeli do metody toArray przekażemy odpowiednią tablicę, zostanie ona uzupełniona wartościami z listy. W tym wypadku otrzymujemy tablicę referencji typu String.

   String[] actualValue = list.toArray(new String[list.size()]);

3. Do metody można również przekazać pustą tablicę

   actualValue = list.toArray(new String[0]);

4. Zamiana z wykorzystaniem Java stream

   actualValue = list.stream().toArray(String[]::new);

5. Zamiana przy pomocy zwykłej pętli

   actualValue = new String[list.size()];
   for (int i = 0; i < list.size(); i++) {
    actualValue[i] = list.get(i);
   }

Int to String

1. Zamiana przez statyczną metodę: Integer.toString

   Integer i = 123;
   String actualValue = Integer.toString(i);
   String expectedValue = "123";
   assertEquals(expectedValue, actualValue);

2. Zamiana przez statyczną metodę: String.valueOf

   actualValue = String.valueOf(i);

3. Zamiana przez metodę: toString na obiekcie typu Integer

   actualValue = i.toString();

4. Zamiana przez dodanie stringa

   actualValue = "" + i;

String to int

1. Parsując string przy pomocy statycznej metody: Integer.valueOf otrzymamy obiekt typu Integer. Dla nierozpoznanych liczb zostanie wyrzucony wyjątek: NumberFormatException.

   String str = "123";
   Integer valueOf = Integer.valueOf(str);
   assertEquals(Integer.valueOf(123), valueOf);

2. Metoda Integer.decode działa bardzo podobnie do valueOf

   Integer decode = Integer.decode(str);
   assertEquals(Integer.valueOf(123), decode);

3. Parsując stringa przy pomocy statycznej metody: Integer.parseInt otrzymamy typ prosty int. Podobnie jak w przypadku metody valueOf można otrzymać wyjątek: NumberFormatException.

   int parseInt = Integer.parseInt(str);
   assertEquals(123, parseInt);

4. Podczas parsowania stringów należy uważać na wyjątek: NumberFormatException. Taką sytuację można jednak obsłużyć z wykorzystaniem klasy Optional

   Optional<Integer> maybeInteger;
   try {
       maybeInteger= Optional.of(Integer.valueOf(str));
   } catch (NumberFormatException e) {
       maybeInteger = Optional.empty();
   }

    

• Przykłady i testy