DoubleBuffer array() method in Java With Examples

The java.nio.DoubleBuffer has array() method. The double array with support for this buffer is returned using the DoubleBuffer Class. Changes made to the contents of this buffer will also change the contents of the returned array. Before calling this function, invoke the hasArray() method to make sure this buffer has an available backing array.

As it precisely establishes limits for the operations that follow, the flip() function is essential for converting from writing mode to reading mode. A buffer's capacity to access the underlying storage directly while there is a backing array present can be helpful, too, but it also needs to be handled carefully, mainly if the array size is different from the number of valid elements in the buffer.

Syntax:

Return Value: The array backing up this buffer is returned by this function.

Exception: If this buffer has an array behind it but is read-only, this function throws the ReadOnlyBufferException.

Example 1:

The method illustrates how changes in one reflect in the other, indicating synchronization between the buffer and its underlying array. However, as these may not have been explicitly filled with valid values, consideration must be taken when accessing array elements beyond the current limit specified by the buffer. Next, the limit is set to the current position (which indicates how many items have been added), and the position is reset to zero using the flip() method, which prepares the buffer for reading.

Implementation:

FileName: DoubleArrayExample1.java

 
import java.nio.DoubleBuffer;
import java.io.*;
import java.util.*;
public class DoubleArrayExample1 
{
    public static void main(String[] args) 
    {
        // Create a DoubleBuffer with the 
        // specified amount of space.
        DoubleBuffer db = DoubleBuffer.allocate(6);
        // Put some values in the DoubleBuffer
        db.put(11.1);
        db.put(22.2);
        db.put(33.3);
        db.put(44.4);
        // Flip the buffer and set the position to zero 
        // and the limit to the current position.
        db.flip();
        // Get to the array that supports the buffer.
        double[] arr = db.array();
        // display the elements of the array
        System.out.println("The elements in the array: ");
        for (double val : arr) 
        {
            System.out.println(val);
        }
    }
}   

Output:

 
The elements in the array: 
11.1
22.2
33.3
44.4
0.0
0.0

Example 2:

The code shows how to work with DoubleBuffer objects in Java, which are buffers that can handle double-precision floating-point values.The backing arrays of these buffers are accessed and printed using array() to display the internal storage. Moreover, the code generates a read-only view of doublebuff by calling the asReadOnlyBuffer() method to prevent modifications. Accessing the backing array of this read-only buffer results in a ReadOnlyBufferException, indicating that the read-only buffer enforces immutability. Finally, the code handles exceptions for IllegalArgumentException and ReadOnlyBufferException to illustrate error scenarios related to buffer operations.

Implementation:

FileName: DoubleBufferExample2.java

 
import java.io.*;
import java.nio.*; 
import java.util.*; 
public class DoubleBufferExample2
{ 
	public static void main(String[] args) 
	{ 
		// creating and declaring the 
		// capacity of the doublebuffer
		int cap1 = 10; 
		// creating and declaring the 
		// capacity of the doublebuffer1 
		int cap2 = 5; 
		// creating the doublebuffer
		try { 
			// Allocating size capacity and constructing
			// an object of Doublebuffer db 
			DoubleBuffer doublebuff = DoubleBuffer.allocate(cap1); 
			// adding the value to the db
			doublebuff.put(9.56F); 
			doublebuff.put(2, 7.61F); 
			doublebuff.put(3, 4.61F); 
			doublebuff.rewind(); 
			// display the DoubleBuffer 
			System.out.println("The DoubleBuffer is given by : " + Arrays.toString(doublebuff.array())); 
			// creating object of Doublebuffer db1 
			// and allocating size capacity 
			DoubleBuffer doublebuff1 = DoubleBuffer.allocate(cap2); 
			// putting the value in db1 
			doublebuff1.put(1, 2.36F); 
			doublebuff1.put(2, 5.39F); 
			doublebuff1.rewind(); 
			// print the DoubleBuffer 
			System.out.println("\n The DoubleBuffer doublebuff1 is given by : " + Arrays.toString(doublebuff1.array())); 
			// Creating a read-only copy of DoubleBuffer 
			// using asReadOnlyBuffer() method 
			DoubleBuffer readOnly = doublebuff.asReadOnlyBuffer(); 
			// print the DoubleBuffer 
			System.out.print("\n The ReadOnlyBuffer DoubleBuffer is given by : "); 
			while (readOnly.hasRemaining()) 
				System.out.print(readOnly.get() + ", "); 
			// try to change readOnlyDb 
			System.out.println("\n\n Trying to get the array" + " from ReadOnly for editing"); 
			Arrays.toString(readOnly.array()); 
		} 
		catch (IllegalArgumentException ex) 
		{ 
			System.out.println("IllegalArgumentException is catched"); 
		} 
		catch (ReadOnlyBufferException e) 
		{ 
			System.out.println("The Exception thrown is: " + e); 
		} 
	} 
}   

Output:

 
The DoubleBuffer is given by : [9.5600004196167, 0.0, 7.610000133514404, 4.610000133514404, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
The DoubleBuffer doublebuff1 is given by : [0.0, 2.359999895095825, 5.389999866485596, 0.0, 0.0]
The ReadOnlyBuffer DoubleBuffer is given by : 9.5600004196167, 0.0, 7.610000133514404, 4.610000133514404, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, Trying to get the array from ReadOnly for editing
The Exception thrown is: java.nio.ReadOnlyBufferException

Next TopicDoublebuffer-clear-methods-in-java-with-examples

← prev next →