**`java.nio.FloatBuffer`** is a class we can use to store a buffer of floats. We can use the **`clear()`** method of this class to clear a buffer. Clearing a buffer means:
* We set the buffer position to 0. **`Capacity`** is the number of elements a buffer contains. The **`limit`** of a buffer is its first index that should not be read or written. The `limit` of a buffer should be less than or equal to its `capacity`.
* We set the buffer limit to the buffer capacity.
* We discard the mark. **`Marking`** a position means recording a position that can be restored by the `FloatBuffer.reset()` method. This marked position is discarded by the `FloatBuffer.reset()` method.

# Declaration
The `FloatBuffer.clear()` method is declared as follows:
```java
buff.clear()
```
* `buff`: The `FloatBuffer` to be cleared.

# Return value
The `FloatBuffer.clear()` method returns the `FloatBuffer` `buff` after cleaning it.

# Code
Consider the code snippet below, which demonstrates the use of the `FloatBuffer.clear()` method.

import java.nio.*;
import java.util.*;
public class main {
   public static void main(String[] args) {
      int n1 = 4;

      FloatBuffer buff1 = FloatBuffer.allocate(n1);
      buff1.put(1.7F);
      buff1.put(4.9F);

      buff1.limit(3);
      buff1.mark();

      System.out.println("buff1: " + Arrays.toString(buff1.array()));
      System.out.println("position at(before clear): " + buff1.position());
      System.out.println("Limit at(before clear): " + buff1.limit());

      buff1.mark();

      System.out.println("clear()");
      buff1.clear();

      System.out.println("position at(after rewind): " + buff1.position());
      System.out.println("Limit at(before clear): " + buff1.limit());
        
   }
}

# Explanation
* A `FloatBuffer` `buff1` is declared in *line 7* with the capacity `n1 = 4`. 
* Two elements are added to `buff1` using the `put()` method in *lines 8-9*. After adding the first element, the position of `buff1` is incremented from *0* to *1*. After adding the second element, the position of `buff1` is incremented from *1* to *2*.
* The position of `buff1` before clear is *2*. After calling the `clear()` method in *line 21*, the position of `buff1` is set to *0*. 
* The limit of `buff1` is set to *3* using the `limit()` method in *line 11*. The limit of `buff1` before `clear()` is *3*. After calling the `clear()` method in *line 21*, the limit of `buff1` is set to its capacity, which is *4*.
* The position of `buff1` is marked to *2* using the `mark()` method in *line 12*. After calling the `clear()` method in *line 21*, the mark of `buff1` is discarded and the position is set to *0*.

What is the FloatBuffer clear() method in Java?

Clearing FloatBuffer in Java sets position to 0, adjusts limit to capacity, and discards mark.