Introduction

The error cannot resolve DataType of java.lang.Float usually means the Android code is passing the wrong kind of object into TensorFlow Lite. TFLite expects a tensor with a concrete model dtype such as FLOAT32 or UINT8, but the app is often handing it boxed Java values like Float, Float[], or some other structure that does not map directly to the model input tensor.

Check what the model actually expects

Before fixing the Java code, inspect the model input tensor:

1Interpreter interpreter = new Interpreter(modelBuffer);
2Tensor inputTensor = interpreter.getInputTensor(0);
3
4Log.d("TFLITE", "shape=" + Arrays.toString(inputTensor.shape()));
5Log.d("TFLITE", "dtype=" + inputTensor.dataType());

If the model reports FLOAT32, your app must provide float data in a format TFLite understands. If it reports UINT8, sending floats is the wrong fix entirely.

Use primitive arrays or TensorBuffer, not boxed Float

A common source of this error is using java.lang.Float instead of primitive float. Boxed objects are not the same as a TFLite tensor buffer.

A safe approach with the support library looks like this:

1Interpreter interpreter = new Interpreter(modelBuffer);
2Tensor inputTensor = interpreter.getInputTensor(0);
3int[] inputShape = inputTensor.shape();
4DataType inputType = inputTensor.dataType();
5
6TensorBuffer inputBuffer = TensorBuffer.createFixedSize(inputShape, inputType);
7float[] inputData = new float[] {0.1f, 0.2f, 0.3f, 0.4f};
8inputBuffer.loadArray(inputData);
9
10Tensor outputTensor = interpreter.getOutputTensor(0);
11TensorBuffer outputBuffer = TensorBuffer.createFixedSize(outputTensor.shape(), outputTensor.dataType());
12
13interpreter.run(inputBuffer.getBuffer(), outputBuffer.getBuffer());

The important part is that the buffer type matches the tensor dtype reported by the model.

Feeding ByteBuffer manually

If you are not using TensorBuffer, build a direct ByteBuffer with native byte order:

1ByteBuffer input = ByteBuffer.allocateDirect(4 * 4);
2input.order(ByteOrder.nativeOrder());
3
4input.putFloat(0.1f);
5input.putFloat(0.2f);
6input.putFloat(0.3f);
7input.putFloat(0.4f);
8input.rewind();
9
10float[][] output = new float[1][2];
11interpreter.run(input, output);

For FLOAT32, each float uses four bytes. If the size is wrong, TFLite fails later with a shape or buffer-size error.

Why boxed types fail

The interpreter and support library need a deterministic tensor dtype. A bare Float object is a Java wrapper, not a tensor container. That is why code that tries to hand TFLite a Float, Float[], or List<Float> often hits the java.lang.Float datatype error.

Use one of these instead:

• primitive float[]
• 'ByteBuffer'
• 'TensorBuffer'
• correctly shaped multi-dimensional primitive arrays such as float[][][][]

These map cleanly to TFLite input expectations.

It is also worth checking your preprocessing pipeline. If the model expects normalized floats in the range from 0.0 to 1.0, but the app feeds raw pixel values, the code may run without crashing after the dtype fix and still produce bad predictions. Correct dtype and correct value scaling both matter. Output tensor handling should be checked the same way.

Common Pitfalls

The biggest mistake is fixing the Java side without checking the model dtype first. If the model expects UINT8, building a beautiful FLOAT32 input buffer still gives you the wrong result.

Another common issue is using the right dtype with the wrong shape. A FLOAT32 tensor shaped like [1, 224, 224, 3] cannot be filled with a flat four-value buffer and expected to work.

Be careful with byte order too. Direct buffers should use ByteOrder.nativeOrder() or the model may read nonsense values.

Finally, do not mix boxed and primitive numeric types casually in preprocessing code. Once you are talking to TFLite, stick to the exact primitive representation the tensor expects.

Summary

• This error usually means the app is passing boxed Float objects where TFLite expects a concrete tensor buffer.
• Check the model input tensor shape and dtype first.
• Use TensorBuffer, ByteBuffer, or primitive arrays that match the model.
• For FLOAT32, write four bytes per value and use native byte order.
• Fix dtype and shape together, not just one of them.