mindol1004/spring-boot-rest
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

[JAVA-616] core-java-arrays-convert

Browse Source 
* Creation

* Moved code from https://www.baeldung.com/java-convert-float-to-byte-array

* Moved code from https://www.baeldung.com/java-stream-to-array
This commit is contained in:
dupirefr
2020-04-10 21:08:02 +02:00
parent 62f4452893
commit 2510062202
8 changed files with 35 additions and 2 deletions
Download Patch File Download Diff File Expand all files Collapse all files

44
core-java-modules/core-java-arrays-convert/src/main/java/com/baeldung/array/conversions/FloatToByteArray.java Normal file
View File

@@ -0,0 +1,44 @@
package com.baeldung.array.conversions;
import java.nio.ByteBuffer;
public class FloatToByteArray {
/**
* convert float into byte array using Float API floatToIntBits
* @param value
* @return byte[]
*/
public static byte[] floatToByteArray(float value) {
int intBits = Float.floatToIntBits(value);
return new byte[] {(byte) (intBits >> 24), (byte) (intBits >> 16), (byte) (intBits >> 8), (byte) (intBits) };
}
/**
* convert byte array into float using Float API intBitsToFloat
* @param bytes
* @return float
*/
public static float byteArrayToFloat(byte[] bytes) {
int intBits = bytes[0] << 24 | (bytes[1] & 0xFF) << 16 | (bytes[2] & 0xFF) << 8 | (bytes[3] & 0xFF);
return Float.intBitsToFloat(intBits);
}
/**
* convert float into byte array using ByteBuffer
* @param value
* @return byte[]
*/
public static byte[] floatToByteArrayWithByteBuffer(float value) {
return ByteBuffer.allocate(4).putFloat(value).array();
}
/**
* convert byte array into float using ByteBuffer
* @param bytes
* @return float
*/
public static float byteArrayToFloatWithByteBuffer(byte[] bytes) {
return ByteBuffer.wrap(bytes).getFloat();
}
}

52
core-java-modules/core-java-arrays-convert/src/main/java/com/baeldung/array/conversions/StreamArrayConversion.java Normal file
View File

@@ -0,0 +1,52 @@
package com.baeldung.array.conversions;
import java.util.Arrays;
import java.util.function.IntFunction;
import java.util.stream.IntStream;
import java.util.stream.Stream;
public class StreamArrayConversion {
public static String[] stringStreamToStringArrayUsingFunctionalInterface(Stream<String> stringStream) {
IntFunction<String[]> intFunction = new IntFunction<String[]>() {
@Override
public String[] apply(int value) {
return new String[value];
}
};
return stringStream.toArray(intFunction);
}
public static String[] stringStreamToStringArrayUsingMethodReference(Stream<String> stringStream) {
return stringStream.toArray(String[]::new);
}
public static String[] stringStreamToStringArrayUsingLambda(Stream<String> stringStream) {
return stringStream.toArray(value -> new String[value]);
}
public static Integer[] integerStreamToIntegerArray(Stream<Integer> integerStream) {
return integerStream.toArray(Integer[]::new);
}
public static int[] intStreamToPrimitiveIntArray(Stream<Integer> integerStream) {
return integerStream.mapToInt(i -> i).toArray();
}
public static Stream<String> stringArrayToStreamUsingArraysStream(String[] stringArray) {
return Arrays.stream(stringArray);
}
public static Stream<String> stringArrayToStreamUsingStreamOf(String[] stringArray) {
return Stream.of(stringArray);
}
public static IntStream primitiveIntArrayToStreamUsingArraysStream(int[] intArray) {
return Arrays.stream(intArray);
}
public static Stream<int[]> primitiveIntArrayToStreamUsingStreamOf(int[] intArray) {
return Stream.of(intArray);
}
}

44
core-java-modules/core-java-arrays-convert/src/test/java/com/baeldung/array/conversions/FloatToByteArrayUnitTest.java Normal file
View File

@@ -0,0 +1,44 @@
package com.baeldung.array.conversions;
import org.junit.Test;
import static com.baeldung.array.conversions.FloatToByteArray.*;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
public class FloatToByteArrayUnitTest {
@Test
public void givenAFloat_thenConvertToByteArray() {
assertArrayEquals(new byte[] { 63, -116, -52, -51}, floatToByteArray(1.1f));
}
@Test
public void givenAByteArray_thenConvertToFloat() {
assertEquals(1.1f, byteArrayToFloat(new byte[] { 63, -116, -52, -51}), 0);
}
@Test
public void givenAFloat_thenConvertToByteArrayUsingByteBuffer() {
assertArrayEquals(new byte[] { 63, -116, -52, -51}, floatToByteArrayWithByteBuffer(1.1f));
}
@Test
public void givenAByteArray_thenConvertToFloatUsingByteBuffer() {
assertEquals(1.1f, byteArrayToFloatWithByteBuffer(new byte[] { 63, -116, -52, -51}), 0);
}
@Test
public void givenAFloat_thenConvertToByteArray_thenConvertToFloat() {
float floatToConvert = 200.12f;
byte[] byteArray = floatToByteArray(floatToConvert);
assertEquals(200.12f, byteArrayToFloat(byteArray), 0);
}
@Test
public void givenAFloat_thenConvertToByteArrayWithByteBuffer_thenConvertToFloatWithByteBuffer() {
float floatToConvert = 30100.42f;
byte[] byteArray = floatToByteArrayWithByteBuffer(floatToConvert);
assertEquals(30100.42f, byteArrayToFloatWithByteBuffer(byteArray), 0);
}
}

70
core-java-modules/core-java-arrays-convert/src/test/java/com/baeldung/array/conversions/StreamArrayConversionUnitTest.java Normal file
View File

@@ -0,0 +1,70 @@
package com.baeldung.array.conversions;
import static com.baeldung.array.conversions.StreamArrayConversion.intStreamToPrimitiveIntArray;
import static com.baeldung.array.conversions.StreamArrayConversion.integerStreamToIntegerArray;
import static com.baeldung.array.conversions.StreamArrayConversion.stringStreamToStringArrayUsingFunctionalInterface;
import static com.baeldung.array.conversions.StreamArrayConversion.stringStreamToStringArrayUsingLambda;
import static com.baeldung.array.conversions.StreamArrayConversion.stringStreamToStringArrayUsingMethodReference;
import static com.baeldung.array.conversions.StreamArrayConversion.stringArrayToStreamUsingArraysStream;
import static com.baeldung.array.conversions.StreamArrayConversion.stringArrayToStreamUsingStreamOf;
import static com.baeldung.array.conversions.StreamArrayConversion.primitiveIntArrayToStreamUsingArraysStream;
import static com.baeldung.array.conversions.StreamArrayConversion.primitiveIntArrayToStreamUsingStreamOf;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import com.google.common.collect.Iterators;
import java.util.stream.IntStream;
import java.util.stream.Stream;
import org.junit.Test;
public class StreamArrayConversionUnitTest {
private String[] stringArray = new String[]{"baeldung", "convert", "to", "string", "array"};
private Integer[] integerArray = new Integer[]{1, 2, 3, 4, 5, 6, 7};
private int[] intPrimitiveArray = new int[]{1, 2, 3, 4, 5, 6, 7};
@Test
public void givenStringStream_thenConvertToStringArrayUsingFunctionalInterface() {
Stream<String> stringStream = Stream.of("baeldung", "convert", "to", "string", "array");
assertArrayEquals(stringArray, stringStreamToStringArrayUsingFunctionalInterface(stringStream));
}
@Test
public void givenStringStream_thenConvertToStringArrayUsingMethodReference() {
Stream<String> stringStream = Stream.of("baeldung", "convert", "to", "string", "array");
assertArrayEquals(stringArray, stringStreamToStringArrayUsingMethodReference(stringStream));
}
@Test
public void givenStringStream_thenConvertToStringArrayUsingLambda() {
Stream<String> stringStream = Stream.of("baeldung", "convert", "to", "string", "array");
assertArrayEquals(stringArray, stringStreamToStringArrayUsingLambda(stringStream));
}
@Test
public void givenIntegerStream_thenConvertToIntegerArray() {
Stream<Integer> integerStream = Stream.of(1, 2, 3, 4, 5, 6, 7);
assertArrayEquals(integerArray, integerStreamToIntegerArray(integerStream));
}
@Test
public void givenIntStream_thenConvertToIntegerArray() {
Stream<Integer> integerStream = IntStream.rangeClosed(1, 7).boxed();
assertArrayEquals(intPrimitiveArray, intStreamToPrimitiveIntArray(integerStream));
}
@Test
public void givenStringArray_whenConvertedTwoWays_thenConvertedStreamsAreEqual() {
assertTrue(Iterators
.elementsEqual(stringArrayToStreamUsingArraysStream(stringArray).iterator(),
stringArrayToStreamUsingStreamOf(stringArray).iterator()));
}
@Test
public void givenPrimitiveArray_whenConvertedTwoWays_thenConvertedStreamsAreNotEqual() {
assertFalse(Iterators.elementsEqual(
primitiveIntArrayToStreamUsingArraysStream(intPrimitiveArray).iterator(),
primitiveIntArrayToStreamUsingStreamOf(intPrimitiveArray).iterator()));
}
}