获取前几个关键句子

@param size 要几个
@return 关键句子的下标
12119
public int[] getTopSentence(int size)
    {
        Collection<Integer> values = top.values();
        size = Math.min(size, values.size());
        int[] indexArray = new int[size];
        Iterator<Integer> it = values.iterator();
        for (int i = 0; i < size; ++i)
        {
            indexArray[i] = it.next();
        }
        return indexArray;
    }
30839
private SegmentMeta findSegmentMeta(int size)
  {
    for (SegmentMeta segmentMeta : this._segmentMeta) {
      if (segmentMeta.size() == size) {
        return segmentMeta;
      }
    }
    
    throw new IllegalStateException(L.l("{0} is an invalid segment size", size));
  }
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;
	}
1120572
public static <E> Matcher<Iterable<E>> hasSize(final int size) {
        checkArgument(size >= 0, "Size cannot be negative");

        return new IsIterableWithSize(size);
    }
712936
protected ArrayList<T> createInitializedList(int size) {
		ArrayList<T> list = new ArrayList<T>(size);
		for (int i = 0; i < size; i++)
			list.add(null);
		return list;
	}
278423
public static String asIbi(long size) {
        if (size > GIBI) {
            return String.format("%.1f GiB", (size / GIBI));
        } else if (size > MIBI) {
            return String.format("%.1f MiB", (size / MIBI));
        } else if (size > KIBI) {
            return String.format("%.1f KiB", (size / KIBI));
        } else {
            return String.format("%d B", size);
        }
    }
1046417
public <T> CursorList<T> asCursorList(int size) {
		CursorList<T> result = CursorList.create(this, size);
		return result;
	}
908990
def size(self, size):
        
        clone = self._clone()
        clone._size = size
        return clone
656500
public static AreaL area(final AreaSizeL size)
  {
    Objects.requireNonNull(size, "Size");
    return AreaL.of(0L, size.sizeX(), 0L, size.sizeY());
  }
427404
def read(self, size):
        
        if isinstance(size, SV):
            size = size.value

        buff = self.__buff[self.__idx:self.__idx + size]
        self.__idx += size

        return buff
1318364
private static List<String> getSizeRange(String operation, String size)
	{
		return getSizeRange(operation, size, null);
	}
71408
public CollectionAssert hasSizeGreaterThanOrEqualTo(int size) {
		isNotNull();
		int actualSize = size(this.actual);
		if (!(actualSize >= size)) {
			failWithMessage("The size <%s> is not greater or equal to <%s>", actualSize,
					size);
		}
		return this;
	}
510008
public static byte[] getByteArray(int size)
    {
        byte[][] pool = (byte[][])__pools.get();
        boolean full=true;
        for (int i=pool.length;i-->0;)
        {
            if (pool[i]!=null && pool[i].length==size)
            {
                byte[]b = pool[i];
                pool[i]=null;
                return b;
            }
            else
                full=false;
        }

        if (full)
            for (int i=pool.length;i-->0;)
                pool[i]=null;
        
        return new byte[size];
    }
284802
function(size) {
		if (typeof(size) !== 'string') {
			return size;
		}
		
		var muls = {
				t: 1099511627776,
				g: 1073741824,
				m: 1048576,
				k: 1024
			},
			mul;

		size = /^([0-9]+)([mgk]?)$/.exec(size.toLowerCase().replace(/[^0-9mkg]/g, ''));
		mul = size[2];
		size = +size[1];
		
		if (muls.hasOwnProperty(mul)) {
			size *= muls[mul];
		}
		return size;
	}
1099681
public Cell<C,T> size (Value<C,T> size) {
		minWidth = size;
		minHeight = size;
		prefWidth = size;
		prefHeight = size;
		maxWidth = size;
		maxHeight = size;
		return this;
	}
591877
public static short[] ensureCapacity(short[] elements, int size) {
        if (size > elements.length) {
            short[] tmp = new short[size*2];
            System.arraycopy(elements, 0, tmp, 0, elements.length);
            elements = tmp;
        }
        return elements;
    }
111380
protected <K, V> Map<K, V> allocMap(int size) {
      return size == 0 ? Collections.emptyMap() : new HashMap<>(size * 4/3, 0.75f);
   }