* distinct elements, and add the last element over again many times over. We don't want a
         * situation where we re-sort the entire buffer every time the last element is re-added.
         *
         * <p>The solution is to ensure there are O(n) spaces left over in the buffer after
         * sortAndDedup -- that is, at least c*n for some constant c > 0. Ensuring the buffer size

import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.net.Socket;
import javax.net.SocketFactory;
import jnr.unixsocket.UnixSocketChannel;

/** Impersonate TCP-style SocketFactory over UNIX domain sockets. */
public final class UnixDomainSocketFactory extends SocketFactory {
  private final File path;

  public UnixDomainSocketFactory(File path) {
    this.path = path;
  }

    27.0, depends on
    listenablefuture-9999.0-empty-to-avoid-conflict-with-guava. The 9999.0-...
    version number is enough for some build systems (notably, Gradle) to select
    that empty artifact over the "real" listenablefuture-1.0 -- avoiding a
    conflict with the copy of ListenableFuture in guava itself. If users are
    using an older version of Guava or a build system other than Gradle, they

- **Size of Serialized Data:**
Java serialization tends to produce larger serialized objects because it includes class metadata and other overhead.

- **Flexibility and Control:**
Java serialization offers limited control over the serialization process, such as excluding certain fields, customizing naming conventions, and handling complex data structures more gracefully.

- **Security:**

- Never change punctuation inside inline code, code blocks, URLs, or file paths.

### Ellipsis

- Keep ellipsis style consistent within each document, prefer `...` over  `……`.
- Never change ellipsis in code, URLs, or CLI examples.

### Preferred translations / glossary

Use the following preferred translations when they apply in documentation prose:

- request (HTTP): 请求

            assertThat(bloomFilter.mightContain(key)).isTrue();

            // If this check ever fails, that means we need to either bump the
            // number of expected insertions or don't run the test for so long.
            // Don't forget, the bloom filter slowly saturates over time and the
            // expected false positive probability goes up!

    App->>Client: Send Item 2
    App->>App: Produce Item 3
    Client->>Client: Process Item 2
    App->>Client: Send Item 3
    Client->>Client: Process Item 3
    Note over App: Keeps producing...
    Note over Client: Keeps consuming...
```

它甚至可以是一个无限流，你可以一直持续发送数据。

## JSON Lines { #json-lines }

在这些场景中，常见的做法是发送 “JSON Lines”，这是一种每行发送一个 JSON 对象的格式。

a client certificate.

The following curl example shows how to authenticate to a MinIO server with client certificate and obtain STS access credentials.

```curl

Guava has mostly not used the CONTRIBUTORS file, instead relying on Git
history. You can see a summary of contributions at
https://github.com/google/guava/graphs/contributors. However, Git history
over-counts some people's contributions because they were responsible for
mirroring out changes from our internal repo.

This files serves mainly to credit people who have not received proper credit
in the Git history.

Doug Lea, author of some concurrency libraries

   * Returns a view of this range map as an unmodifiable {@code Map<Range<K>, V>}. Modifications to
   * this range map are guaranteed to read through to the returned {@code Map}.
   *
   * <p>The returned {@code Map} iterates over entries in ascending order of the bounds of the
   * {@code Range} entries.
   *
   * <p>It is guaranteed that no empty ranges will be in the returned {@code Map}.
   */
  Map<Range<K>, V> asMapOfRanges();