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
- Zamianę stringa na tablicę stringów można zrobić przy pomocy metody split.
java
String str = "J a v a";
String[] actualStringArray = str.split(" ");
String[] expectedStringArray = {"J", "a", "v", "a"};
assertArrayEquals(expectedStringArray, actualStringArray);
- Zamiana stringa na tablicę charów.
java
str = "Java";
char[] actualCharArray = str.toCharArray();
char[] expectedCharArray = {'J', 'a', 'v', 'a'};
assertArrayEquals(expectedCharArray, actualCharArray);
Array to String
- Zamiana przy pomocy metody: Arrays.toString
java
String[] array = {"a", "b", "c"};
String actualValue = Arrays.toString(array);
String expectedValue = "[a, b, c]";
assertEquals(expectedValue, actualValue);
- Zamiana przy pomocy metody: String.join
java
actualValue = String.join(", ", array);
expectedValue = "a, b, c";
assertEquals(expectedValue, actualValue);
- Zamiana za pomocą Java Stream
java
actualValue = Stream.of(array).collect(Collectors.joining(", "));
expectedValue = "a, b, c";
assertEquals(expectedValue, actualValue);
- Zamiana z wykorzystaniem zwykłej pętli
java
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);
- Dla zagnieżdżonych tabel można wykorzystać metodę: Arrays.deepToString
java
String[][] deepArray = {{"a"}, {"b"}, {"c"}};
actualValue = Arrays.deepToString(deepArray);
expectedValue = "[[a], [b], [c]]";
assertEquals(expectedValue, actualValue);
Char array to String
- Zamiana tablicy znaków (charów) na stringa przez konstruktor klasy String
java
char[] charArray = {'J', 'a', 'v', 'a'};
String actualValue = new String(charArray);
String expectedValue = "Java";
assertEquals(expectedValue, actualValue);
- Zamiana przy pomocy metody: String.copyValueOf
java
actualValue = String.copyValueOf(charArray);
expectedValue = "Java";
assertEquals(expectedValue, actualValue);
- Zamiana przy pomocy metody: String.valueOf
java
actualValue = String.valueOf(charArray);
expectedValue = "Java";
assertEquals(expectedValue, actualValue);
- Zamiana przy pomocy metody: Arrays.toString
java
actualValue = Arrays.toString(charArray);
expectedValue = "[J, a, v, a]";
assertEquals(expectedValue, actualValue);
Array to ArrayList
- Zamiana za pomocą metody: Arrays.asList
java
String[] array = {"J", "a", "v", "a"};
List<String> actualValue = Arrays.asList(array);
List<String> expectedValue = Arrays.asList(new String[]{"J", "a", "v", "a"});
- Zamiana za pomocą konstruktora i metody: Arrays.asList
java
actualValue = new ArrayList<>(Arrays.asList(array));
- Zamiana przez dodanie wszystkich elementów przy pomocy metody: Collections.addAll
java
actualValue = new ArrayList<>();
Collections.addAll(actualValue, array);
- Zamiana przez Java stream I
java
actualValue = Stream.of(array).collect(Collectors.toCollection(ArrayList::new));
- Zamiana przez Java stream II
java
actualValue = Stream.of(array).collect(Collectors.toList());
ArrayList to array
- Zamiana przy pomocy metody: toArray tworzy tablicę z referencjami typu Object
java
List<String> list = Arrays.asList("J", "a", "v", "a");
String[] expectedValue = {"J", "a", "v", "a"};
Object[] actualValue = list.toArray();
Assert.assertArrayEquals(expectedValue, actualValue);
- 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.
java
String[] actualValue = list.toArray(new String[list.size()]);
- Do metody można również przekazać pustą tablicę
java
actualValue = list.toArray(new String[0]);
- Zamiana z wykorzystaniem Java stream
java
actualValue = list.stream().toArray(String[]::new);
- Zamiana przy pomocy zwykłej pętli
java
actualValue = new String[list.size()];
for (int i = 0; i < list.size(); i++) {
actualValue[i] = list.get(i);
}
Int to String
- Zamiana przez statyczną metodę: Integer.toString
java
Integer i = 123;
String actualValue = Integer.toString(i);
String expectedValue = "123";
assertEquals(expectedValue, actualValue);
- Zamiana przez statyczną metodę: String.valueOf
java
actualValue = String.valueOf(i);
- Zamiana przez metodę: toString na obiekcie typu Integer
java
actualValue = i.toString();
- Zamiana przez dodanie stringa
java
actualValue = "" + i;
String to int
- Parsując string przy pomocy statycznej metody: Integer.valueOf otrzymamy obiekt typu Integer. Dla nierozpoznanych liczb zostanie wyrzucony wyjątek: NumberFormatException.
java
String str = "123";
Integer valueOf = Integer.valueOf(str);
assertEquals(Integer.valueOf(123), valueOf);
- Metoda Integer.decode działa bardzo podobnie do valueOf
java
Integer decode = Integer.decode(str);
assertEquals(Integer.valueOf(123), decode);
- 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.
java
int parseInt = Integer.parseInt(str);
assertEquals(123, parseInt);
- Podczas parsowania stringów należy uważać na wyjątek: NumberFormatException. Taką sytuację można jednak obsłużyć z wykorzystaniem klasy Optional
java
Optional<Integer> maybeInteger;
try {
maybeInteger= Optional.of(Integer.valueOf(str));
} catch (NumberFormatException e) {
maybeInteger = Optional.empty();
}
