}
            }
            return query;
        }

        protected Pair<String, String> splitField(final String defaultField, final String field) {
            final int indexOf = field.indexOf(':');
            if (indexOf < 0) {
                return new Pair<>(field, null);
            }
            final String indexField = indexOf == 0 ? defaultField : field.substring(0, indexOf);

            final Pair<String, Float> pair = new Pair<>();
            final String[] values = s.split(":");
            if (values.length == 1) {
                pair.setFirst(values[0].trim());
                pair.setSecond(1.0f);
            } else if (values.length > 1) {
                pair.setFirst(values[0]);
                pair.setSecond(Float.parseFloat(values[1]));
            } else {

                    final String[] pair = s.split("=");
                    if (pair.length == 1) {
                        return new Pair<>(StringUtil.EMPTY, pair[0].trim());
                    }
                    if (pair.length == 2) {
                        return new Pair<>(pair[0].trim(), pair[1].trim());
                    }
                    return null;

    @Override
    protected String getActionRole() {
        return ROLE;
    }

    private List<Pair<String, String>> loadJspFileNameItems() {
        final List<Pair<String, String>> jspItems = new ArrayList<>();
        for (final Pair<String, String> p : systemHelper.getDesignJspFileNames()) {
            jspItems.add(new Pair<>(":" + p.getFirst(), "/" + p.getSecond()));
        }

  }

  @CollectionFeature.Require(SERIALIZABLE)
  public void testInverseSerialization() {
    BiMapPair<K, V> pair = new BiMapPair<>(getMap());
    BiMapPair<K, V> copy = SerializableTester.reserialize(pair);
    assertEquals(pair.forward, copy.forward);
    assertEquals(pair.backward, copy.backward);
    assertSame(copy.backward, copy.forward.inverse());
    assertSame(copy.forward, copy.backward.inverse());
  }

      omitEmptyValues = true;
      return this;
    }

    /**
     * Adds a name/value pair to the formatted output in {@code name=value} format. If {@code value}
     * is {@code null}, the string {@code "null"} is used, unless {@link #omitNullValues()} is
     * called, in which case this name/value pair will not be added.
     */
    @CanIgnoreReturnValue

    return super.asMap();
  }

  /**
   * Stores a key-value pair in the multimap.
   *
   * @param key key to store in the multimap
   * @param value value to store in the multimap
   * @return {@code true} if the method increased the size of the multimap, or {@code false} if the
   *     multimap already contained the key-value pair
   */
  @CanIgnoreReturnValue
  @Override

    return super.asMap();
  }

  /**
   * Stores a key-value pair in the multimap.
   *
   * @param key key to store in the multimap
   * @param value value to store in the multimap
   * @return {@code true} if the method increased the size of the multimap, or {@code false} if the
   *     multimap already contained the key-value pair
   */
  @CanIgnoreReturnValue
  @Override

All `go/types` data structures that expose sequences using a pair of
methods such as `Len() int` and `At(int) T` now also methods that
return iterators, allowing you to simplify code such as this:

```go
params := fn.Type.(*types.Signature).Params()
for i := 0; i < params.Len(); i++ {
   use(params.At(i))
}
```

to this:

```go
for param := range fn.Signature().Params().Variables() {
   use(param)
}
```

                            .collect(Collectors.groupingBy(Pair::getFirst, Collectors.mapping(Pair::getSecond, Collectors.toList())));
                    appendJson("search-field", searchFieldMap, buf).append(',');
                    final Map<String, List<String>> requestHeaderMap = entity.getRequestHeaderList().stream()
                            .collect(Collectors.groupingBy(Pair::getFirst, Collectors.mapping(Pair::getSecond, Collectors.toList())));