3

我无法理解CharBuffer equals()方法功能的具体细节。

我不明白这个“独立于他们的起始位置考虑”的短语：

两个 char 缓冲区相等当且仅当,

它们具有相同的元素类型，

它们具有相同数量的剩余元素，并且

剩余元素的两个序列，独立于它们的起始位置考虑，是逐点相等的。

我研究了这些很好的例子——更多的例子，但我不明白这个想法。

任何人都可以用不同的语言和最少的有见地的示例代码来解释吗？

特别是我觉得这很奇怪：

CharBuffer cb1 = CharBuffer.allocate(10);
cb1.put('a');
cb1.put('b');
//cb1.rewind();
System.out.println(cb1);


CharBuffer cb2 = CharBuffer.allocate(10);
cb2.put(4,'a');
cb2.put(5,'b');
//cb2.rewind();
System.out.println(cb2);

// false, uncommenting rewind() - also false
// but shall be true - "considered independently of starting positions" ?
System.out.println(cb1.equals(cb2));
4

3 回答 3

3

剩余元素的两个序列，独立于它们的起始位置考虑，是逐点相等的。

  1. 只看剩下的元素，
  2. 不考虑他们从哪里开始，
  3. 一个缓冲区的每个元素必须等于另一个缓冲区中的相应元素。

在您的示例中，重要的是逐点相等的部分：

      0 1 2 3 4 5 6 7 8 9
cb1 = a b 0 0 0 0 0 0 0 0
cb1 = 0 0 0 0 a b 0 0 0 0

如您所见，在逐点比较 char 缓冲区的元素时，它们不匹配。

于 2019-01-03T13:22:09.513 回答
2

比较CharBuffer它们的剩余内容是什么。这意味着equals()检查从当前缓冲区位置开始，而不是从缓冲区开始。根据Buffer.position()：

缓冲区的位置是要读取或写入的下一个元素的索引。缓冲区的位置永远不会是负数，也永远不会大于其限制。

一些方法put(char)会改变缓冲区位置：

CharBuffer cb1 = CharBuffer.allocate(10);
cb1.put('a'); // increments position
cb1.put('b'); // increments position

CharBuffer cb2 = CharBuffer.allocate(8);

System.out.println(cb1.equals(cb2)); // true, 00000000 equals 00000000

在您的示例中，cb1.rewind()第一个缓冲区之后是ab00000000，而第二个缓冲区是0000ab0000. cb2.rewind()不需要调用，因为put(char, int)不会更改缓冲区位置：

CharBuffer cb1 = CharBuffer.allocate(10);
cb1.put((char) 0);
cb1.put((char) 0);
cb1.put((char) 0);
cb1.put((char) 0);
cb1.put('a');
cb1.put('b');
// put(char) increments position so we need to rewind
cb1.rewind(); 

CharBuffer cb2 = CharBuffer.allocate(10);
cb2.put(4, 'a');
cb2.put(5, 'b');

System.out.println(cb1.equals(cb2)); // true, 0000ab0000 equals 0000ab0000
于 2019-01-03T13:19:33.933 回答
0

这是一个返回true两个不同大小的缓冲区的示例：

CharBuffer cb1 = CharBuffer.allocate(8);
cb1.put('x'); // moves the current position to 1
cb1.put('x'); // moves the current position to 2
cb1.put(2,'a');
cb1.put(3,'b');
System.out.print(cb1);System.out.println ('|');
CharBuffer cb2 = CharBuffer.allocate(10);
cb2.get (); // moves the current position to 1
cb2.get (); // moves the current position to 2
cb2.get (); // moves the current position to 3
cb2.get (); // moves the current position to 4
cb2.put(4,'a');
cb2.put(5,'b');
System.out.print(cb2);System.out.println ('|');
System.out.println(cb1.equals(cb2));

equals将 2 到 7 位置cb1的元素与 4 到 9 位置的元素进行比较cb2，发现它们成对相等（都包含以下chars - 'a','b',0,0,0,0 ）。

可以看到两个缓冲区的起始位置不同（2 vs. 4），但剩余元素的顺序是一样的。

     0   1   2   3  4   5  6 7 8 9

cb1 'x' 'x' 'a' 'b' 0   0  0 0
             ^
cb2  0   0   0   0 'a' 'b' 0 0 0 0
                    ^

当您从起始位置开始比较序列时，您会得到两个相同的序列。

在您的示例中，您将序列 0,0,0,0,0,0,0,0（剩余元素的序列从位置 2 开始）与序列 0,0,0,0,'a', 'b',0,0,0,0（剩余元素的序列从位置 0 开始）。显然，它们彼此不相等。

于 2019-01-03T13:31:08.850 回答