FloatBuffer put() methods in Java with Examples

The FloatBuffer put() has mainly 2 methods that take two different parameters.

put(float f)
put(int index, float f)

i. put(float f)

The java.nio.FloatBuffer class has put(float f) function. The newly generated float buffer is written with the specified float at the current location, and the position is then incremented using the FloatBuffer Class.

Syntax:

Parameters:

The float value f, which needs to be entered into a float buffer, is the parameter for this procedure.

Return Value: The float value is inserted into the buffer that this procedure returns.

Exception: The following exceptions are thrown by this method:

BufferOverflowException- if the position of this buffer is not now less than its limit.

ReadOnlyBufferException- if this buffer can be read-on.

Example 1:

The code shows how to create and work with a FloatBuffer in Java. Three float values can be stored in the FloatBuffer that is allocated, due to its capacity of three. It adds three float values to the buffer by using the put function. In order to prepare the buffer for reading, the rewind method is invoked to reset its position to the beginning. The backing array of the buffer is then converted to a string representation, and the contents of the FloatBuffer are displayed using Arrays.toString. To manage possible failures during buffer operations, the code incorporates exception handling for BufferOverflowException and ReadOnlyBufferException.

Implementation:

FileName: putFloatExample1.java

 
import java.io.*;
import java.nio.*; 
import java.util.*; 
public class putFloatExample1 
{ 
	public static void main(String[] args) 
	{ 
		// Declaring the FloatBuffer's capacity 
		int capacity = 3; 
		// Creating the FloatBuffer 
		try { 
			// Allocating size capacity and 
			// constructing an object of floatbuffer 
			FloatBuffer floatbuff = FloatBuffer.allocate(capacity); 
			// using the put() method to insert 
			// the value in the floatbuffer 
			floatbuff.put(9.46F); 
			floatbuff.put(8.41F); 
			floatbuff.put(2.76F); 
			floatbuff.rewind(); 
			// display the FloatBuffer 
			System.out.println("The Original FloatBuffer is given by : " + Arrays.toString(floatbuff.array())); 
		} 
		catch (BufferOverflowException ex) 
		{ 
			System.out.println("The Exception thrown is given by : " + ex); 
		} 
		catch (ReadOnlyBufferException ex) 
		{ 
			System.out.println("The Exception thrown is given by : " + ex); 
		} 
	} 
}   

Output:

 
The Original FloatBuffer is given by : [9.46, 8.41, 2.76]

ii. put(int index, float f)

The java.nio.FloatBuffer class has put(int index, float f) function. The given float is written into the buffer at the specified index using the FloatBuffer Class.

Syntax:

Parameters: The following arguments are passed as parameters to this method:

index: The index where the float will continue to be written

f: The value of the float to be written

Return Value: The buffer is returned by this method.

Exception: The exception that this method throws is as follows:

IndexOutOfBoundsException- If the index is less than the buffer's limit, whether it is negative.

ReadOnlyBufferException- If this buffer can only be read.

Example 1:

The code explains a Java program that shows how to store floating-point values at particular indices using a FloatBuffer. The put() function is used in the main method to insert float values at the provided indices, which are 9.35F at index 0, 8.27F at index 2, and 7.21F at index 1. The put() method also initializes a FloatBuffer with a capacity of 3. The buffer's position is reset to zero by calling the rewind() method after the values have been inserted. Lastly, an array representing the contents of the FloatBuffer is printed. To handle possible failures during buffer operations, the program has exception handling for IndexOutOfBoundsException and ReadOnlyBufferException.

Implementation:

FileName: putIndexExample1.java

 
import java.io.*;
import java.nio.*; 
import java.util.*; 
public class putIndexExample1 
{ 
	public static void main(String[] args) 
	{ 
	    // Declaring the FloatBuffer's capacity 
		int cap = 3; 
		// Creating the FloatBuffer 
		try { 
            // Allocating size capacity and constructing 
            // an object of floatbuffer 
			FloatBuffer floatbuff = FloatBuffer.allocate(cap); 
			// using put() to insert the value at index 0 into a floatbuffer 
			floatbuff.put(0, 9.35F); 
			// using put() to insert the value at index 2 into a floatbuffer 
			floatbuff.put(2, 8.27F); 
			// using put() to insert the value at index 1 into a floatbuffer 
			floatbuff.put(1, 7.21F); 
		    // turning the floatbuffer back 
			floatbuff.rewind(); 
			// display the FloatBuffer 
			System.out.println("The Original FloatBuffer is given by: "
							+ Arrays.toString(floatbuff.array())); 
		} 
		catch (IndexOutOfBoundsException ex) 
		{ 
			System.out.println("The Exception thrown is given by : " + ex); 
		} 
		catch (ReadOnlyBufferException ex) 
		{ 
			System.out.println("The Exception thrown is given by : " + ex); 
		} 
	} 
}   

Output:

 
The Original FloatBuffer is given by: [9.35, 7.21, 8.27]

Example 2:

The code illustrates a Java program that shows how to store floating-point numbers at specified indices using a FloatBuffer and how to handle errors when incorrect indices are used. The put() method is used in the main method to insert two float values, 9.25F at index 0 and 8.37F at index 2, after initializing a FloatBuffer with a capacity of three. An IndexOutOfBoundsException is then raised when it tries to insert the value 7.34F at an illegal negative index (-1). An appropriate message is printed after this exception is detected.

Implementation:

FileName: putIndexFloatExample2.java

 
import java.io.*;
import java.nio.*; 
import java.util.*; 
public class putIndexFloatExample2 
{ 
	public static void main(String[] args) 
	{ 
		// Declaring the FloatBuffer's capacity 
		int cap = 3; 
		// Creating the FloatBuffer 
		try { 
			// Allocating size capacity and constructing 
			// an object of floatbuffer 
			FloatBuffer fb = FloatBuffer.allocate(cap); 
			//The value is being put in the floatbuffer 
			// at index 0 using put(). 
			fb.put(0, 9.25F); 
			//The value is being put in the floatbuffer 
			// at index 2 using put(). 
			fb.put(2, 8.37F); 
			//The value is being put in the floatbuffer 
			// at index -1 using put().  
			System.out.println("Trying to put the value" + " when the index is negative"); 
			fb.put(-1, 7.34F); 
		} 
		catch (IndexOutOfBoundsException ex) 
		{ 
			System.out.println("The Exception thrown is given by : " + ex); 
		} 
		catch (ReadOnlyBufferException ex) 
		{ 
			System.out.println("The Exception thrown is given by : " + ex); 
		} 
	} 
}   

Output:

 
Trying to put the value when the index is negative
The Exception thrown is given by : java.lang.IndexOutOfBoundsException: Index -1 out of bounds for length 3

Next TopicHorizontal-flip-matrix-problem-in-java

← prev next →