Collection<? extends V> values = entry.getValue();
      ImmutableList<V> list =
          (valueComparator == null)
              ? ImmutableList.copyOf(values)
              : ImmutableList.sortedCopyOf(valueComparator, values);
      if (!list.isEmpty()) {
        builder.put(key, list);
        size += list.size();
      }
    }

    return new ImmutableListMultimap<>(builder.buildOrThrow(), size);

  @Override
  public String[] createArray(int length) {
    return new String[length];
  }

  /** Returns the original element list, unchanged. */
  @Override
  public List<String> order(List<String> insertionOrder) {
    return insertionOrder;
  }

    
    public List<SmbFile> batchExists(List<String> paths) {
        // Group paths by parent directory
        Map<String, List<String>> pathsByParent = paths.stream()
            .collect(Collectors.groupingBy(this::getParentPath));
        
        List<SmbFile> results = new ArrayList<>();
        
        for (Map.Entry<String, List<String>> entry : pathsByParent.entrySet()) {

  public Entry<K, V>[] createArray(int length) {
    return (Entry<K, V>[]) new Entry<?, ?>[length];
  }

  /** Returns the original element list, unchanged. */
  @Override
  public List<Entry<K, V>> order(List<Entry<K, V>> insertionOrder) {
    return insertionOrder;
  }

        } catch (org.apache.maven.api.services.PrompterException e) {
            throw new IOException("Unable to prompt", e);
        }
    }

    @Override
    public List<String> readMultipleLines() throws IOException {
        List<String> lines = new ArrayList<>();
        for (String line = readLine(); line != null && !line.isEmpty(); line = readLine()) {
            lines.add(line);
        }
        return lines;

        final List<SortBuilder<?>> list = new ArrayList<>();
        if (defaultSortBuilders != null) {
            stream(defaultSortBuilders).of(stream -> stream.forEach(builder -> list.add(builder)));
        }
        list.add(createFieldSortBuilder(fieldName, SortOrder.DESC.toString().equalsIgnoreCase(order) ? SortOrder.DESC : SortOrder.ASC));
        defaultSortBuilders = list.toArray(new SortBuilder[list.size()]);
    }

package org.codelibs.fess.app.web.api.admin.documents;

import java.util.List;
import java.util.Map;

/**
 * Request body for bulk document operations containing a list of documents.
 */
public class BulkBody {

    /**
     * Creates a new instance of BulkBody.
     */
    public BulkBody() {
        // Default constructor
    }

    /**
     * List of documents to be processed in bulk operations.
     */

     */
    protected static class InputStreamThread extends Thread {

        /** Buffered reader for input stream. */
        private BufferedReader br;

        /** List to store captured output lines. */
        private final List<String> list = new LinkedList<>();

        /** Maximum number of lines to buffer. */
        private final int maxLineBuffer;

        /**
         * Constructor for InputStreamThread.

        mockResponse(this.mockConnection, code, message, headers, errorStream);
    }

    /**
     * Helper method to mock the response of a specific HttpURLConnection instance.
     */
    private void mockResponse(HttpURLConnection conn, int code, String message, Map<String, List<String>> headers, InputStream stream)

    "foo",
    "bar"
  ]
}
```

#### Usando `list`

Você também pode utilizar o tipo `list` diretamente em vez de `List[str]`:

{* ../../docs_src/query_params_str_validations/tutorial013.py hl[7] *}

/// note | Observação

Tenha em mente que neste caso, o FastAPI não irá validar os conteúdos da lista.