Convertir un tableau double pour un float array

J'ai un double[][] tableau, et je veux obtenir une ligne dans un float tableau []. Casting n'a pas travaillé à la première, j'ai donc cherché quelque chose de différent.

J'ai trouvé ici, dans stackoverflow une solution élégante pour convertir Object[] String[], qui serait également travailler si je ont été de la conversion de l'Objet[] pour float[].

Donc: est-il un moyen élégant de conversion de double[] pour float[], double ou[] de l'Objet[] si je peux utiliser le code à l'autre post?

Je vais vous donner un exemple de code de ce que je fais, même je pense qu'il n'est pas nécessaire de le modifier:

double[][] datos = serie.toArray();
double[][] testArray = {{1.0, 2.0, 3.0}, {4.0, 5.0, 6.0}, {7.0, 8.0, 9.0}};
double[] doubleArray = Arrays.copyOf(testArray[1], testArray[1].length);
//This would be great but doesn't exist:
//float[] floatArray = Arrays.copyOf(doubleArray, doubleArray.length, float[].class);

OriginalL'auteur Roman Rdgz | 2011-09-22

20

Pas, coulée dans le tableau ne fonctionne pas. Vous avez besoin de convertir explicitement chaque élément:
```
float[] floatArray = new float[doubleArray.length];
for (int i = 0 ; i < doubleArray.length; i++)
{
    floatArray[i] = (float) doubleArray[i];
}
```
counterintutive, ce type de questions se tourner encore et encore. Je devais être rappelé aussi 🙂
ne fonctionne pas: floatArray est nulle après la boucle!
Ce n'est pas possible - vous avez certainement fait une erreur dans votre code, mais nous ne pouvons pas dire ce que c'est. Il est absolument aucun moyen à la fin du code que j'ai fourni, floatArray est null.
Ok oublier, le code est OK, j'ai eu un problème différent. Merci! 🙂

OriginalL'auteur Jon Skeet
5

Ici est une fonction que vous pourriez placer dans une bibliothèque et d'utiliser encore et encore:
```
float[] toFloatArray(double[] arr) {
  if (arr == null) return null;
  int n = arr.length;
  float[] ret = new float[n];
  for (int i = 0; i < n; i++) {
    ret[i] = (float)arr[i];
  }
  return ret;
}
```
(J'étais en train de souligner la nécessité de libérer la mémoire allouée après chaque appel à cette fonction, mais alors vu que nous parlons de java et a supprimé mon commentaire... c'est pas grave -_-)
J'ai révisé mon commentaire, voir ci-dessus :/
N'ai pas vraiment essayé, mais c'est la même réponse de Jon Skeet a donné, mais encapsulé inyo une fonction, donc je suppose que je vais obtenir null float[] trop
Ok oublier, le code est OK, j'ai eu un problème différent. Merci! 🙂
L'Utilisation Du Système.arrayCopy

OriginalL'auteur NPE
2

De référence pour l'avenir; cela peut aussi être fait un peu plus concise en utilisant la Goyave, comme ceci:
```
double[] values = new double[]{1,2,3};

float[] floatValues = Floats.toArray(Doubles.asList(values));
```
on dirait vraiment lent (peut-être il ne l'est pas, juste dire ce look lent). vous avez testé ce par hasard?
Nope, je n'ai pas testé le temps d'exécution. Ce n'est probablement pas aussi rapide que l'écriture d'une boucle, mais si vous ne faites pas cela très souvent et/ou pour les grandes listes-il encore de ne pas prendre une notable quantité de temps.
ok, donc je l'ai testé. c'est très exactement 9 fois plus lent sur ma machine. pastebin.com/Rh5eWY7q à mon humble avis ce ne doit pas être utilisé à jamais. c'est juste une ligne de moins, plus lent, plus complexe et nécessite un énorme dépendance.
ps résultats des tests ici imgur.com/SCRwTrT
Merci de prendre l'effort de test de performance. Je suis d'accord que c'est exagéré pour inclure la Goyave juste pour cela, mais si vous l'utilisez déjà, je pense que c'est plus clair que celui de la boucle. Pas tellement parce qu'il permet d'économiser deux lignes (pas un), mais parce qu'il enregistre la boucle elle-même. C'est subjectif bien sûr, mais dans mon esprit, une boucle est généralement une indication de la complexité, quelque chose qui mérite une attention particulière lors de la lecture du code. C'est pourquoi je préfère le bout de code que j'ai posté. Comme je l'ai expliqué, je vais généralement pas vraiment à la performance d'une telle fonction, et je ne suis pas d'accord c'est plus complexe qu'une boucle.

OriginalL'auteur Pieter-Paul Kramer

J'ai créé cette catégorie pour mon usage personnel, mais je pense qu'il peut vous aider avec votre problème.

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.lang.reflect.Array;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;
public class ArrayUtils {
private static final Logger log = LoggerFactory.getLogger(ArrayUtils.class);
private static final Map<Class, Class> primitiveMapping = new HashMap<Class, Class>();
private static final Map<Class, Method> primitiveParseMethodLookup = new HashMap<Class, Method>();
private static final Map<Class, Method> primitiveArrayGetMethodLookup = new HashMap<Class, Method>();
private static final Map<Class, Method> valueOfMethodLookup = new HashMap<Class, Method>();
static {
//Initialize primitive mappings
primitiveMapping.put(boolean.class, Boolean.class);
primitiveMapping.put(byte.class, Byte.class);
primitiveMapping.put(short.class, Short.class);
primitiveMapping.put(int.class, Integer.class);
primitiveMapping.put(float.class, Float.class);
primitiveMapping.put(long.class, Long.class);
primitiveMapping.put(double.class, Double.class);
//Initialize parse, valueOf and get method lookup
//We do that in advance because the lookup of the method takes the longest time
//Compared to the normal method call it's 20x higher
//So we use just the reflective method call which takes double the time of a normal method call
try {
primitiveParseMethodLookup.put(boolean.class, Boolean.class.getMethod("parseBoolean", new Class[]{String.class}));
primitiveParseMethodLookup.put(byte.class, Byte.class.getMethod("parseByte", new Class[]{String.class}));
primitiveParseMethodLookup.put(short.class, Short.class.getMethod("parseShort", new Class[]{String.class}));
primitiveParseMethodLookup.put(int.class, Integer.class.getMethod("parseInt", String.class));
primitiveParseMethodLookup.put(float.class, Float.class.getMethod("parseFloat", String.class));
primitiveParseMethodLookup.put(long.class, Long.class.getMethod("parseLong", String.class));
primitiveParseMethodLookup.put(double.class, Double.class.getMethod("parseDouble", String.class));
valueOfMethodLookup.put(Boolean.class, Boolean.class.getMethod("valueOf", new Class[]{String.class}));
valueOfMethodLookup.put(Byte.class, Byte.class.getMethod("valueOf", new Class[]{String.class}));
valueOfMethodLookup.put(Short.class, Short.class.getMethod("valueOf", new Class[]{String.class}));
valueOfMethodLookup.put(Integer.class, Integer.class.getMethod("valueOf", String.class));
valueOfMethodLookup.put(Float.class, Float.class.getMethod("valueOf", String.class));
valueOfMethodLookup.put(Long.class, Long.class.getMethod("valueOf", String.class));
valueOfMethodLookup.put(Double.class, Double.class.getMethod("valueOf", String.class));
primitiveArrayGetMethodLookup.put(boolean.class, Array.class.getMethod("getBoolean", new Class[]{Object.class, int.class}));
primitiveArrayGetMethodLookup.put(byte.class, Array.class.getMethod("getByte", new Class[]{Object.class, int.class}));
primitiveArrayGetMethodLookup.put(short.class, Array.class.getMethod("getShort", new Class[]{Object.class, int.class}));
primitiveArrayGetMethodLookup.put(int.class, Array.class.getMethod("getInt", Object.class, int.class));
primitiveArrayGetMethodLookup.put(float.class, Array.class.getMethod("getFloat", Object.class, int.class));
primitiveArrayGetMethodLookup.put(long.class, Array.class.getMethod("getLong", Object.class, int.class));
primitiveArrayGetMethodLookup.put(double.class, Array.class.getMethod("getDouble", Object.class, int.class));
} catch (NoSuchMethodException e) {
//******************************
//This can never happen
//******************************
}
}
public static boolean isArrayOfPrimitives(Object object) {
if (object.getClass().isArray()) {
return object.getClass().getComponentType().isPrimitive();
}
return false;
}
public static boolean isArrayOf(Object object, Class clazz) {
if (object.getClass().isArray()) {
return clazz.isAssignableFrom(object.getClass().getComponentType());
}
return false;
}
/**
* Convert any array of primitives(excluding char), strings or numbers into any other array
* of strings or numbers.
*
* @param array                       Array of primitives(excluding char), strings or numbers
* @param convertedArrayComponentType Converted array component type (String or Number)
* @param <T>                         To allow implicit casting
* @return Array of convertedArrayComponentType
*/
public static <T> T[] convertArray(Object array, Class<T> convertedArrayComponentType) {
//Collect data regarding arguments
final boolean arrayOfPrimitives = isArrayOfPrimitives(array);
final boolean arrayOfCharPrimitives = isArrayOf(array, char.class);
final boolean arrayOfCharacters = isArrayOf(array, Character.class);
final boolean arrayOfStrings = isArrayOf(array, String.class);
final boolean arrayOfNumbers = isArrayOf(array, Number.class);
//Check if array is an array of strings, primitives or wrapped primitives
if (!arrayOfPrimitives && !arrayOfNumbers && !arrayOfStrings || arrayOfCharPrimitives || arrayOfCharacters) {
throw new IllegalArgumentException(array + " must be an array of of strings, primitives or boxed primitives (byte, boolean, short, int, float, long, double)");
}
//Check if it's assignable from Number of String
if (!Number.class.isAssignableFrom(convertedArrayComponentType) && !String.class.isAssignableFrom(convertedArrayComponentType)) {
throw new IllegalArgumentException(convertedArrayComponentType + " must be a Number or a String");
}
try {
return (T[]) convertArrayInternal(array, convertedArrayComponentType);
} catch (InvocationTargetException e) {
//This can happen due to errors in conversion
throw (RuntimeException) e.getTargetException();
} catch (Exception e) {
//This should never happen
log.error("Something went really wrong in ArrayUtils.convertArray method.", e);
}
//To satisfy the compiler
return null;
}
/**
* Convert any array of primitives(excluding char), strings or numbers into an array
* of primitives(excluding char).
*
* @param array                       Array of primitives(excluding char), strings or numbers
* @param convertedArrayComponentType Converted array component type primitive(excluding char)
* @return Array of convertedArrayComponentType
*/
public static Object convertToPrimitiveArray(Object array, Class convertedArrayComponentType) {
//Collect data regarding arguments
final boolean arrayOfPrimitives = isArrayOfPrimitives(array);
final boolean arrayOfCharPrimitives = isArrayOf(array, char.class);
final boolean arrayOfCharacters = isArrayOf(array, Character.class);
final boolean arrayOfStrings = isArrayOf(array, String.class);
final boolean arrayOfNumbers = isArrayOf(array, Number.class);
//Check if array is an array of strings, primitives or wrapped primitives
if (!arrayOfPrimitives && !arrayOfNumbers && !arrayOfStrings || arrayOfCharPrimitives || arrayOfCharacters) {
throw new IllegalArgumentException(array + " must be an array of of strings, primitives or boxed primitives (byte, boolean, short, int, float, long, double)");
}
//Check if it's assignable from Number of String
if (!convertedArrayComponentType.isPrimitive() || convertedArrayComponentType.isAssignableFrom(char.class)) {
throw new IllegalArgumentException(convertedArrayComponentType + " must be a primitive(excluding char)");
}
try {
return convertArrayInternal(array, convertedArrayComponentType);
} catch (InvocationTargetException e) {
//This can happen due to errors in conversion
throw (RuntimeException) e.getTargetException();
} catch (Exception e) {
//This should never happen
log.error("Something went really wrong in ArrayUtils.convertArray method.", e);
}
//To satisfy the compiler
return null;
}
private static Object convertArrayInternal(Object array, Class convertedArrayComponentType) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
//Lookup the primitive parse method or the boxed primitive valueOf method
final Method convertMethod;
if (convertedArrayComponentType.isPrimitive()) {
convertMethod = primitiveParseMethodLookup.get(convertedArrayComponentType);
} else {
convertMethod = valueOfMethodLookup.get(convertedArrayComponentType);
}
//If the array is an array of primitives lookup the get method
final Method primitiveArrayGetMethod = primitiveArrayGetMethodLookup.get(array.getClass().getComponentType());
//Get length and create new array
final int arrayLength = Array.getLength(array);
final Object castedArray = Array.newInstance(convertedArrayComponentType, arrayLength);
for (int i = 0; i < arrayLength; i++) {
final Object value;
if (primitiveArrayGetMethod != null) {
value = primitiveArrayGetMethod.invoke(null, array, i);
} else {
value = Array.get(array, i);
}
final String stringValue = String.valueOf(value);
final Object castedValue = convertMethod.invoke(null, stringValue);
Array.set(castedArray, i, castedValue);
}
return castedArray;
}
}

Il peut être utilisé comme ceci:

double[][] testArray = {{1.0, 2.0, 3.0}, {4.0, 5.0, 6.0}, {7.0, 8.0, 9.0}};
double[] doubleArray = Arrays.copyOf(testArray[1], testArray[1].length);
float[] floatArray = (float[]) ArrayUtils.convertToPrimitiveArray(doubleArray, float.class);

OriginalL'auteur emd

Avec Kotlin vous pouvez essayer quelque chose comme ceci:

 val doubleArray = arrayOf(2.0, 3.0, 5.0)
val floatArray = doubleArray.map { it.toFloat() }.toFloatArray()

 val floatArray = arrayOf(2.0, 3.0, 5.0).map { it.toFloat() }.toFloatArray()

OriginalL'auteur Antonis Radz

-1

Une autre solution à l'aide de 'forEach' méthode en une seule ligne:

myarray = ['3','5','6'];
myarray.forEach(function (item){var ind = myarray.indexOf(item); myarray[ind] = parseFloat(item)});

OriginalL'auteur Jawensi

Vous devez vous connecter pour publier un commentaire.