Set<V> createCollection() {
    return Platform.newLinkedHashSetWithExpectedSize(valueSetCapacity);
  }

  /**
   * {@inheritDoc}
   *
   * <p>Creates a decorated insertion-ordered set that also keeps track of the order in which
   * key-value pairs are added to the multimap.
   *
   * @param key key to associate with values in the collection
   * @return a new decorated set containing a collection of values for one key

* **Machine Learning**: it normally requires lots of "matrix" and "vector" multiplications. Think of a huge spreadsheet with numbers and multiplying all of them together at the same time.

* **Maschinelles Lernen**: Normalerweise sind viele „Matrix“- und „Vektor“-Multiplikationen erforderlich. Stellen Sie sich eine riesige Tabelle mit Zahlen vor, in der Sie alle Zahlen gleichzeitig multiplizieren.

            return null;
        }

        @Override
        public boolean hasChildNodes() {
            return false;
        }

        @Override
        public Node cloneNode(boolean deep) {
            return null;
        }

        @Override
        public void normalize() {
        }

        @Override
        public boolean isSupported(String feature, String version) {

* 여러분
* 여러분의

* 예:
* 등

* `foo`로서의 `int`
* `bar`로서의 `str`
* `baz`로서의 `list`

* 튜토리얼 - 사용자 가이드
* 고급 사용자 가이드
* SQLModel 문서
* API 문서
* 자동 문서

* Data Science
* Deep Learning
* Machine Learning
* Dependency Injection
* HTTP Basic authentication
* HTTP Digest
* ISO format
* JSON Schema 표준
* JSON schema
* schema definition
* Password Flow
* Mobile

   * elements.length) are all {@code null}.
   */
  @VisibleForTesting transient @Nullable Object @Nullable [] elements;

  /**
   * Keeps track of metadata like the number of hash table bits and modifications of this data
   * structure (to make it possible to throw ConcurrentModificationException in the iterator). Note

     * is the only one in use, but if we encounter nested concatenations, we start a deque of
     * meta-iterators rather than letting the nesting get arbitrarily deep.  This keeps each
     * operation O(1).
     */

    private @Nullable Iterator<? extends Iterator<? extends T>> topMetaIterator;

    // Only becomes nonnull if we encounter nested concatenations.

     * is the only one in use, but if we encounter nested concatenations, we start a deque of
     * meta-iterators rather than letting the nesting get arbitrarily deep.  This keeps each
     * operation O(1).
     */

    private @Nullable Iterator<? extends Iterator<? extends T>> topMetaIterator;

    // Only becomes nonnull if we encounter nested concatenations.

        assertFalse(deepDir.exists(), "Deep directory should not exist initially");

        deepDir.mkdirs();
        deepDir.close();
        Thread.sleep(200);

        CIFSContext checkContext = createFreshContext();
        SmbFile checkDeepDir = new SmbFile(baseUrl + "shared/level1_" + timestamp + "/level2/level3/", checkContext);
        assertTrue(checkDeepDir.exists(), "Deep directory should exist after creation");

			Prefixes:    []string{"dir/day_id=2017-10-10/"},
		},
		// ListObjectsResult-37 list with prefix match 2 levels deep
		37: {
			IsTruncated: false,
			Objects: []ObjectInfo{
				{Name: "foo/201910/1112"},
				{Name: "foo/201910/1122"},
			},
		},
		// ListObjectsResult-38 list with prefix match 1 level deep
		38: {
			IsTruncated: false,
			Objects: []ObjectInfo{
				{Name: "foo/201910/1112"},