Whenever you read from or write to the buffer, only it's position changes.

So you are wrong about reading from channel. Note that reading from channel means writing to the buffer. You can set the position to 0 and limit - to the maximum number of bytes to read before you call Channel.read(ByteBuffer). The read operation then updates the position to the number of bytes actually read. So, to start reading from buffer you have to call ByteBuffer.flip().

Your buffer is never filled. bytes.array() simply retrieves the backing byte array. If you write anything to this then the ByteBuffer fields - except the array itself of course - are unaffected. So the position stays at zero.

What you are doing in in.read(bytes.array()) is identical to byte[] tmp = bytes.array() followed by in.read(tmp). Changes to the tmp variable cannot be reflected in the bytes instance. The backing array is changed which may mean that the contents of the ByteBuffer is changed as well. But the offsets into the backing byte array - including the position and limit - aren't.

You should only fill the ByteBuffer using any of the put methods (that do not take an index) such as put(byte[]).

I'll provide a code fragment that may get you thinking on how to handle strings, encodings and character and byte buffers:

import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.charset.CharsetEncoder;
import java.nio.charset.CoderResult;
import java.nio.charset.StandardCharsets;

public class TestBuffer {

    private static final String testStr = "Stackoverflow is a great place to discuss tech stuff!";
    private static final boolean END_OF_INPUT = true;

    private ByteBuffer bytes = ByteBuffer.allocate(1000);

    public TestBuffer() {

        System.out.println("init   : " + bytes.toString());
    }

    public static void main(String a[]) {
        TestBuffer buf = new TestBuffer();
        buf.writeBuffer();
        buf.readBuffer();
    }

    // write testStr to buffer
    private void writeBuffer() {
        CharBuffer testBuffer = CharBuffer.wrap(testStr);
        CharsetEncoder utf8Encoder = StandardCharsets.UTF_8.newEncoder();
        CoderResult result = utf8Encoder.encode(testBuffer, bytes, END_OF_INPUT);
        if (result.isError()) {
            bytes.clear();
            throw new IllegalArgumentException("That didn't go right because " + result.toString());
        }
        if (result.isOverflow()) {
            bytes.clear();
            throw new IllegalArgumentException("Well, too little buffer space.");
        }
        System.out.println("written: " + bytes.toString());
        bytes.flip();
    }

    // read buffer data back to byte array and print
    private void readBuffer() {
        byte[] b = new byte[bytes.remaining()];
        bytes.get(b);
        System.out.println("data   : " + new String(b, StandardCharsets.UTF_8));
        System.out.println("read   : " + bytes.toString());
        bytes.clear();
    }
}

Note that buffers and streams are really two separate ways of handling sequential data. If you are trying to use both of them at the same time you may be trying to be too clever.

You could also solve this without CharBuffer and ByteBuffer using a byte[] buffer and a StringReader wrapped by a ReaderInputStream.

That Android piece of code completely abuses the ByteBuffer. It should just have created a byte[] and wrapped that, setting the limit to the capacity. Whatever you do, do not use it as an example on ByteBuffer handling. It made my eyes water in disgust. Code like that is a bug waiting to happen.

The ByteBuffer class offers absolute get operations which can access the value at any valid index. For instance, ByteBuffer#get(int) accepts an index and returns the byte at that index. It does this without mutating the position of the buffer, meaning your code won't have any side-effects. Here's an example which finds all indices of a single byte:

public static int[] allIndicesOf(ByteBuffer buf, byte b) {
  return IntStream.range(buf.position(), buf.limit())
      .filter(i -> buf.get(i) == b)
      .toArray();
}

This avoids copying the information into a byte[] and leaves the ByteBuffer in the same state as it was when given to the method. Also note that the buffer is only searched from its current position to its limit. If you want to search the entire buffer then use range(0, buf.capacity()).

Here's another example except this one allows you to search for a "sub-array" in the buffer:

public static int[] allIndicesOf(ByteBuffer buf, byte[] b) {
  if (b.length == 0) {
    return new int[0];
  }
  return IntStream.rangeClosed(buf.position(), buf.limit() - b.length)
      .filter(i -> IntStream.range(0, b.length).allMatch(j -> buf.get(i + j) == b[j]))
      .toArray();
}

The code works for getting the position. Is it possible if i just want to delete that ASCII char '10' when found in bytebuffer fro that byte buffer?

Here's an example of removing all occurrences of the specified byte:

public static void removeAll(ByteBuffer buf, byte b) {
  for (int i = buf.position(); i < buf.limit(); i++) {
    // find first occurrence
    if (buf.get(i) == b) {
      // copy every remaining byte which != 'b' over
      for (int j = i + 1; j < buf.limit(); j++) {
        if (buf.get(j) != b) {
          buf.put(i++, buf.get(j));
        }
      }
      // update limit of buffer (implicitly causes outer for loop to exit)
      buf.limit(i);
    }
  }
}

int offset = byteBuffer.position();

This is a method of the Buffer class, hence you probably overlooked it.

The ByteBuffer class internally stores several properties of the buffer. The most important one being the position (of a virtual "cursor") in the buffer. This position can be read with byteBuffer.position(), and written with byteBuffer.position(123);.

The JavaDoc of ByteBuffer.asIntBuffer now states:

The content of the new buffer will start at this buffer's current position.

This means that, for example, when you have a ByteBuffer with a capacity of 16 elements, and the position() of this ByteBuffer is 4, then the resulting IntBuffer will only represent the remaining 12 elements.

After calling byteBuffer.put(bytes), the position of the byte buffer is advanced (depending on the length of the byte array). The IntBuffer that you are creating then has a smaller capacity, accordingly.

To solve this, you can call byteBuffer.rewind() or byteBuffer.position(0) after you called byteBuffer.put(bytes). (Which one is more appropriate depends on the intended usage pattern)

Its best illustrated HERE in this article: They are mainly different depending on the mode,

• In Write Mode, Capacity and Limit are Same.
• But in Read mode Limit means the limit of how much data you can read from the data