The <code>size</code> operator matches:
<p/>
<ol>
<li>array with the specified number of elements.</li>
<li>string with given length.</li>
</ol>

@param size
@return the criteria
506140
public Criteria size(int size) {
        this.criteriaType = RelationalOperator.SIZE;
        this.right = ValueNode.toValueNode(size);
        return this;
    }
1349316
public static StringBuilder size(long size) {
        final StringBuilder buf = new StringBuilder(16);
        appendSize(buf, size);
        return buf;
    }
808788
public CloseableReference<byte[]> get(int size) {
    Preconditions.checkArgument(size > 0, "Size must be greater than zero");
    Preconditions.checkArgument(size <= mMaxByteArraySize, "Requested size is too big");
    mSemaphore.acquireUninterruptibly();
    try {
      byte[] byteArray = getByteArray(size);
      return CloseableReference.of(byteArray, mResourceReleaser);
    } catch (Throwable t) {
      mSemaphore.release();
      throw Throwables.propagate(t);
    }
  }
363944
public static int sizeOfInteger(int value) {
        int contentLength = 0;
        do {
            value >>>= 8;
            contentLength++;
        } while (value != 0);
        return DerUtils.sizeOf(ASN1_INTEGER_TAG_NUM, contentLength);
    }
1025239
public static long sizeToLong(String size) {
        size = size.trim();
        if (Checker.isNotEmpty(size)) {
            String num;
            if (size.contains(ValueConsts.SPACE)) {
                num = size.split(ValueConsts.SPACE)[0];
            } else {
                num = Utils.extractDigit(size);
            }
            double result;
            if (size.contains(SIZE_TB)) {
                result = stringToDouble(num) * ValueConsts.TB;
            } else if (size.contains(SIZE_GB)) {
                result = stringToDouble(num) * ValueConsts.GB;
            } else if (size.contains(SIZE_MB)) {
                result = stringToDouble(num) * ValueConsts.MB;
            } else if (size.contains(SIZE_KB)) {
                result = stringToDouble(num) * ValueConsts.KB;
            } else {
                result = stringToDouble(num);
            }
            return (long) result;
        }
        return -1;
    }
293525
public final NumberExpression<Integer> size() {
        if (size == null) {
            size = Expressions.numberOperation(Integer.class, Ops.COL_SIZE, mixin);
        }
        return size;
    }
1322847
public static Partition unit(int size) {
        Partition unit = new Partition();
        unit.cells.add(new TreeSet<Integer>());
        for (int i = 0; i < size; i++) {
            unit.cells.get(0).add(i);
        }
        return unit;
    }
1053775
public static AreaBD area(final AreaSizeBD size)
  {
    Objects.requireNonNull(size, "Size");
    return AreaBD.of(
      BigDecimal.ZERO,
      size.sizeX(),
      BigDecimal.ZERO,
      size.sizeY());
  }
243717
function parse(size) {
  var matches = size.match(regexp);

  if (!matches)
    return null;

  var multiplicator = matches[3] ? +matches[3].replace(/x$/, '') : 1;

  return {
    width: +matches[1] * multiplicator,
    height: +matches[2] * multiplicator
  };
}
1253161
@Deprecated public static int size (Object[] list)
    {
        if (list == null) {
            return 0;
        }
        int llength = list.length;
        for (int ii = 0; ii < llength; ii++) {
            if (list[ii] == null) {
                return ii;
            }
        }
        return llength;
    }
71273
public static <T> List<List<T>> split(final Collection<? extends T> c, final int size) {
        if (size < 1) {
            throw new IllegalArgumentException("The parameter 'size' can not be zero or less than zero");
        }

        if (N.isNullOrEmpty(c)) {
            return new ArrayList<>();
        }

        return split(c, 0, c.size(), size);
    }
918051
public void ensureCapacity(int size) {
    if (size > elements.length) {
      reallocate(Math.max(size, 2 * elements.length));
    }
  }
1214417
private static List<String> initialiseResult(int size) {
		final List<String> result = new ArrayList<>(size);
		for (int i = 0; i < size; i++) {
			result.add("");
		}
		return result;
	}
23329
static public int sizeOf(WsByteBuffer[] list) {
        if (null == list) {
            return 0;
        }
        int size = 0;
        for (int i = 0; i < list.length; i++) {
            if (null != list[i]) {
                size += list[i].remaining();
            }
        }
        return size;
    }
885691
public int size() {
        int count=0;
        for(Value val: map.values())
            count+=val.count();

        return count;
    }
183424
public Cell<C,T> minSize (float size) {
		minWidth = new FixedValue<C, T>(layout.toolkit, size);
		minHeight = new FixedValue<C, T>(layout.toolkit, size);
		return this;
	}
1110421
public static IntegerMinMax[] newArray(int size) {
    IntegerMinMax[] ret = new IntegerMinMax[size];
    for(int i = 0; i < size; i++) {
      ret[i] = new IntegerMinMax();
    }
    return ret;
  }