Java Code Examples for java.util.ArrayList#subList()

/**
 * Using a named query, find all the objects matching the criteria within.
 * Warning: This can be very expensive if the returned list is large. Use
 * only for small tables with static data
 * @param qryName Named query to use to find a list of objects.
 * @param qryParams Map of named bind parameters whose keys are Strings. The
 * map can also be null.
 * @param col the collection to use as an inclause
 * @param colLabel the label the collection will have
 * @return List of objects returned by named query, or null if nothing
 * found.
 */
protected List listObjectsByNamedQuery(String qryName, Map qryParams,
                                    Collection col, String colLabel) {

    if (col.isEmpty()) {
        return Collections.EMPTY_LIST;
    }

    ArrayList<Long> tmpList = new ArrayList<Long>();
    List<Long> toRet = new ArrayList<Long>();
    tmpList.addAll(col);

    for (int i = 0; i < col.size();) {
        int initial = i;
        int fin = i + 500 < col.size() ? i + 500 : col.size();
        List<Long> sublist = tmpList.subList(i, fin);

        qryParams.put(colLabel, sublist);
        toRet.addAll(listObjectsByNamedQuery(qryName, qryParams, false));
        i = fin;
    }
    return toRet;
}
 

@Override
public ReadonlyList<T> cut(int idxFromIncluded) {
  if (idxFromIncluded >= getSize()) return ReadonlyList.EMPTY;
  final int itemNumber = idxFromIncluded >> mySize2Power;
  final int insideIdx = idxFromIncluded ^ (itemNumber << mySize2Power);

  final ArrayList<T> start = myList.get(itemNumber);
  final NotRegularReadonlyList<T> result =
    new NotRegularReadonlyList<T>(new ArrayList<ArrayList<T>>(myList.subList(itemNumber + 1, myList.size())),
                                  mySize2Power, start.subList(insideIdx, start.size()));
  myList.set(itemNumber, new ArrayList<T>(start.subList(0, insideIdx)));
  for (int i = myList.size() - 1; i > itemNumber; -- i) {
    myList.remove(i);
  }
  mySize = myList.isEmpty() ? 0 : (((myList.size() - 1) * myPack + myList.get(myList.size() - 1).size()));
  return result;
}
 

private List<ScoreElement> getSimilar(float[] raster, float[] hist, ReadableQueryConfig rqc) {
  int limit = Config.sharedConfig().getRetriever().getMaxResultsPerModule();

  QueryConfig qc = new QueryConfig(rqc).setDistanceIfEmpty(Distance.chisquared);

  List<Map<String, PrimitiveTypeProvider>> rows = this.selector.getNearestNeighbourRows(limit * 5,
      hist, "hist", qc);

  ArrayList<ScoreElement> scores = new ArrayList<>(rows.size());
  for (Map<String, PrimitiveTypeProvider> map : rows) {
    String id = map.get("id").getString();
    double score = register(raster, map.get("raster").getFloatArray());
    scores.add(new SegmentScoreElement(id, score));
  }

  scores.sort(ScoreElement.SCORE_COMPARATOR.reversed());
  if (scores.size() > limit) {
    return scores.subList(0, limit);
  } else {
    return scores;
  }
}
 

List<PreferenceItem> searchFor(final String keyword, boolean fuzzy) {
    if (TextUtils.isEmpty(keyword)) {
        return new ArrayList<>();
    }
    ArrayList<PreferenceItem> results = new ArrayList<>();

    for (PreferenceItem item : allEntries) {
        if ((fuzzy && item.matchesFuzzy(keyword))
                || (!fuzzy && item.matches(keyword))) {
            results.add(item);
        }
    }

    Collections.sort(results, new Comparator<PreferenceItem>() {
        @Override
        public int compare(PreferenceItem i1, PreferenceItem i2) {
            return floatCompare(i2.getScore(keyword), i1.getScore(keyword));
        }
    });

    if (results.size() > MAX_RESULTS) {
        return results.subList(0, MAX_RESULTS);
    } else {
        return results;
    }
}
 

/**
 * Sets the name of the optional two tabs.
 * The contents of the tabs are filtered based on the name of the tab.
 * @param tabs ArrayList of Strings
 */
public void setTabs(ArrayList<String>tabs) {
    if (tabs == null || tabs.size() <= 0) return;

    if (platformSupportsTabs) {
        ArrayList<String> toAdd;
        if (tabs.size() > MAX_TABS) {
            toAdd = new ArrayList<>(tabs.subList(0, MAX_TABS));
        } else {
            toAdd = tabs;
        }
        this.tabs = toAdd.toArray(new String[0]);
    } else {
        Logger.d("Please upgrade com.android.support:design library to v28.0.0 to enable Tabs for App Inbox, dropping Tabs");
    }
}
 

private LinkedHashMap<MetaData, List<Integer>> getCurPageMap() {
	int startIndex = (curPageNum - 1) * rowNumPerPage;
	int endIndex = curPageNum * rowNumPerPage;
	if (curPageNum == amountPage) {
		endIndex = size;
	}
	Iterator<Entry<MetaData, ArrayList<Integer>>> it = mapGroupId.entrySet().iterator();
	int index = 0;
	LinkedHashMap<MetaData, List<Integer>> mapSub = new LinkedHashMap<MetaData, List<Integer>>();
	while (it.hasNext()) {
		Entry<MetaData, ArrayList<Integer>> entry = (Entry<MetaData, ArrayList<Integer>>) it.next();
		ArrayList<Integer> lstGroupId = entry.getValue();
		if (index <= startIndex && index + lstGroupId.size() >= startIndex) {
			List<Integer> subList = null;
			if (index + lstGroupId.size() - 1 >= endIndex) {
				subList = lstGroupId.subList(startIndex - index, endIndex - index);
				mapSub.put(entry.getKey(), subList);
				break;
			} else {
				subList = lstGroupId.subList(startIndex - index, lstGroupId.size());
				index += lstGroupId.size();
				startIndex += lstGroupId.size();
				mapSub.put(entry.getKey(), subList);
			}
		} else {
			index += lstGroupId.size();
		}
	}
	return mapSub;
}
 

public Polygon2D convexHull(Collection<? extends Point2D> points) {
    int nbPoints = points.size();
    //TODO: manage small values of n
    
    // Find point with lowest y-coord
    Point2D lowestPoint = null;
    double lowestY = Double.MAX_VALUE;
    for(Point2D point : points){
        double y = point.y();
        if(y<lowestY){
            lowestPoint = point;
            lowestY = y;
        }
    }
    
    // build the comparator, using the lowest point
    Comparator<Point2D> comparator = 
        new CompareByPseudoAngle(lowestPoint);
    
    // create a sorted set
    ArrayList<Point2D> sorted = new ArrayList<Point2D>(nbPoints);
    sorted.addAll(points);
    Collections.sort(sorted, comparator);
    
    // main loop
    // i-> current vertex of point cloud
    // m-> current hull vertex
    int m = 2;
    for(int i=3; i<nbPoints; i++){
        while(Point2D.ccw(sorted.get(m), sorted.get(m-1), 
                sorted.get(i))>=0)
            m--;
        m++;
        Collections.swap(sorted, m, i);
    }

    // Format result to return a polygon
    List<Point2D> hull = sorted.subList(0, Math.min(m+1, nbPoints));
    return new SimplePolygon2D(hull);
}
 

public ClassName toClassName() {
	if (enclosingClasses.isEmpty()) {
		return ClassName.get(fullyQualifiedPackageName, className);
	} else {
		// XXX this is just stupid, JavaPoet has a private constructor just
		// for this...
		ArrayList<String> names = new ArrayList<>(enclosingClasses);
		names.add(className);
		List<String> subList = names.subList(1, names.size());
		return ClassName.get(fullyQualifiedPackageName, names.get(0),
				subList.toArray(new String[subList.size()]));
	}
}
 

/** Return the sublist, starting at {@code toFind}, or empty list if not found. */
List<String> seek(List<String> immList, String toFind) {
  ArrayList<String> list = new ArrayList<>(immList.size());
  list.addAll(immList);
  int i;
  for (i = 0; i < list.size(); i++) {
    if (list.get(i).equals(toFind)) {
      break;
    }
  }
  return list.subList(i, list.size());
}
 

protected ConfigNodePath subPath(int toRemove) {
    int periodCount = 0;
    ArrayList<Token> tokensCopy = new ArrayList<Token>(tokens);
    for (int i = 0; i < tokensCopy.size(); i++) {
        if (Tokens.isUnquotedText(tokensCopy.get(i)) &&
                tokensCopy.get(i).tokenText().equals("."))
            periodCount++;

        if (periodCount == toRemove) {
            return new ConfigNodePath(path.subPath(toRemove), tokensCopy.subList(i + 1, tokensCopy.size()));
        }
    }
    throw new ConfigException.BugOrBroken("Tried to remove too many elements from a Path node");
}
 

/**
 * 批处理的执行<br>
 * 在内部线程里调用
 */
@SuppressWarnings({ "rawtypes" })
private void executeCreate(final Map<Class, ArrayList<Object>> tempMap)
		throws Exception {
	for (Class clz : tempMap.keySet()) {

		ArrayList<Object> objList = tempMap.get(clz);
		
		String sql = MapperFactory.getSql(clz, Mapper.CREATE);
		
		List<BeanElement> eles = MapperFactory.getElementList(clz);
		
		/*
		 * 分段批处理，每段不超过MAX_BATCH
		 */
		int size = objList.size();
		int times = size / MAX_BATCH + 1;

		for (int i = 0; i < times; i++) {

			int segment = 0;
			if (i + 1 == times) {
				segment = size % MAX_BATCH;
				if (segment == 0){
					break;
				}
			}else{
				segment = MAX_BATCH;
			}
			
			int fromIndex = i * MAX_BATCH;
			List<Object> subList = objList.subList(fromIndex, fromIndex + segment);
			batchCreate(subList, sql, eles);
			
		}

	}
}
 

private String join(ArrayList<String> items, int start, int end, String s) {
    List<String> strings = items.subList(start, end + 1);
    StringBuilder result = new StringBuilder();
    for (int i = 0; i < strings.size(); i++) {
        result.append(strings.get(i)).append(i == strings.size() - 1 ? "" : s);
    }
    return result.toString();
}
 

private LinkedHashMap<MetaData, List<Integer>> getCurPageMap() {
	int startIndex = (curPageNum - 1) * rowNumPerPage;
	int endIndex = curPageNum * rowNumPerPage;
	if (curPageNum == amountPage) {
		endIndex = size;
	}
	Iterator<Entry<MetaData, ArrayList<Integer>>> it = mapGroupId.entrySet().iterator();
	int index = 0;
	LinkedHashMap<MetaData, List<Integer>> mapSub = new LinkedHashMap<MetaData, List<Integer>>();
	while (it.hasNext()) {
		Entry<MetaData, ArrayList<Integer>> entry = (Entry<MetaData, ArrayList<Integer>>) it.next();
		ArrayList<Integer> lstGroupId = entry.getValue();
		if (index <= startIndex && index + lstGroupId.size() >= startIndex) {
			List<Integer> subList = null;
			if (index + lstGroupId.size() - 1 >= endIndex) {
				subList = lstGroupId.subList(startIndex - index, endIndex - index);
				mapSub.put(entry.getKey(), subList);
				break;
			} else {
				subList = lstGroupId.subList(startIndex - index, lstGroupId.size());
				index += lstGroupId.size();
				startIndex += lstGroupId.size();
				mapSub.put(entry.getKey(), subList);
			}
		} else {
			index += lstGroupId.size();
		}
	}
	return mapSub;
}
 

@Override
public List<Term> generate(Record record) throws Exception {
    ArrayList<Term> objects = new ArrayList<>();
    ArrayList<String> objectStrings = new ArrayList<>();
    FunctionUtils.functionObjectToList(this.functionExecutor.execute(record), objectStrings);

    String dataTypeSource = null;
    if (this.functionExecutor instanceof ReferenceExtractor) {
        dataTypeSource = record.getDataType(((ReferenceExtractor) this.functionExecutor).reference);
    }

    if (objectStrings.size() > 0) {
        //add language tag if present
        String finalDataTypeSource = dataTypeSource;
        objectStrings.forEach(objectString -> {
            if (languageExecutor != null) {
                try {
                    ArrayList<String> languages = new ArrayList<>();
                    FunctionUtils.functionObjectToList(this.languageExecutor.execute(record), languages);

                    if (!languages.isEmpty()) {
                        String language = languages.get(0);

                        if (! isValidrrLanguage(language)) {
                            throw new RuntimeException(String.format("Language tag \"%s\" does not conform to BCP 47 standards", language));
                        }

                        objects.add(new Literal(objectString, language));
                    }
                } catch (Exception e) {
                    // TODO print error message
                    e.printStackTrace();
                }
            } else if (datatype != null) {
                //add datatype if present; language and datatype can't be combined because the language tag implies langString as datatype
                objects.add(new Literal(objectString, datatype));
            } else if (finalDataTypeSource != null) {
                if (this.functionExecutor instanceof ReferenceExtractor) {
                    objectString = Utils.transformDatatypeString(objectString, finalDataTypeSource);
                }
                objects.add(new Literal(objectString, new NamedNode(finalDataTypeSource)));
            } else {
                objects.add(new Literal(objectString));
            }
        });
    }

    if (maxNumberOfTerms != 0) {
        return objects.subList(0, maxNumberOfTerms);

    } else {
        return objects;
    }
}
 

public Words(ArrayList<String> words, int start, int end){
    this.words = new ArrayList<>(words.subList(start, end));
    this.used = new boolean[end - start];
    for(int i=0;i<this.used.length;i++) this.used[i] = false;
}
 

private void setAppShortcuts(ArrayList<RemoteItem> remoteItems, ArrayList<String> appShortcuts) {
    if (android.os.Build.VERSION.SDK_INT < android.os.Build.VERSION_CODES.N_MR1) {
        return;
    }

    if (appShortcuts.size() > 4) {
        appShortcuts = new ArrayList<>(appShortcuts.subList(0, 4));
    }

    SharedPreferences sharedPreferences = PreferenceManager.getDefaultSharedPreferences(context);
    SharedPreferences.Editor editor = sharedPreferences.edit();
    Set<String> savedAppShortcutIds = sharedPreferences.getStringSet(getString(R.string.shared_preferences_app_shortcuts), new HashSet<String>());
    Set<String> updatedAppShortcutIDds = new HashSet<>(savedAppShortcutIds);

    // Remove app shortcuts first
    ArrayList<String> appShortcutIds= new ArrayList<>();
    for (String s : appShortcuts) {
        appShortcutIds.add(AppShortcutsHelper.getUniqueIdFromString(s));
    }
    List<String> removedIds = new ArrayList<>(savedAppShortcutIds);
    removedIds.removeAll(appShortcutIds);
    if (!removedIds.isEmpty()) {
        AppShortcutsHelper.removeAppShortcutIds(context, removedIds);
    }

    updatedAppShortcutIDds.removeAll(removedIds);

    // add new app shortcuts
    for (String appShortcut : appShortcuts) {
        String id = AppShortcutsHelper.getUniqueIdFromString(appShortcut);
        if (updatedAppShortcutIDds.contains(id)) {
            continue;
        }

        RemoteItem remoteItem = null;
        for (RemoteItem item : remoteItems) {
            if (item.getName().equals(appShortcut)) {
                remoteItem = item;
                break;
            }
        }
        if (remoteItem == null) {
            continue;
        }

        AppShortcutsHelper.addRemoteToAppShortcuts(context, remoteItem, id);
        updatedAppShortcutIDds.add(id);
    }

    editor.putStringSet(getString(R.string.shared_preferences_app_shortcuts), updatedAppShortcutIDds);
    editor.apply();
}
 

private static List<SDEndorser> topNbyHeight(int required, List<SDEndorser> endorsers) {
    ArrayList<SDEndorser> ret = new ArrayList<>(endorsers);
    ret.sort(Comparator.comparingLong(SDEndorser::getLedgerHeight));
    return ret.subList(Math.max(ret.size() - required, 0), ret.size());
}
 

public List<T> getVisiblePoints(Viewport viewport) {
  //生成一个拷贝,利用不可变的思想保证这里不存在并发问题
  ArrayList<T> backUpList = new ArrayList<>(getValues());
  //防止多次调用
  int listSize = backUpList.size();

  int from = Math.round(viewport.left * listSize);
  int to = Math.round(viewport.right * listSize);

  if (Float.compare(viewport.width(), 1f) == 0
      && defaultVisibleEntryCount > 0
      && defaultVisibleEntryCount < listSize) {
    from = to - defaultVisibleEntryCount;
    viewport.left = from / (float) listSize;
  } else {
    if (maxVisibleEntryCount > 0 && to - from > maxVisibleEntryCount) {
      from = to - maxVisibleEntryCount;
      viewport.left = from / (float) listSize;
    }
    if (minVisibleEntryCount > 0
        && minVisibleEntryCount < listSize
        && to - from < minVisibleEntryCount) {
      if (to >= minVisibleEntryCount) {
        from = to - minVisibleEntryCount;
        //防止越界
        if (from < 0) {
          from = 0;
        }
        viewport.left = from / (float) listSize;
      } else {
        to = from + minVisibleEntryCount;
        //防止越界
        if (to >= listSize) {
          to = listSize - 1;
        }
        viewport.right = to / (float) listSize;
      }
    }
  }

  return backUpList.subList(from, to);
}
 

public static com.concurnas.compiler.ast.Type convertGenType(java.lang.reflect.Type type, Map<String, GenericType> nameToGenericMap, boolean dontSetupInterfaceGenerics){
	if(type instanceof TypeVariable){//generic
		return nameToGenericMap.get(((TypeVariable<?>)type).getName());
	}
	com.concurnas.compiler.ast.Type ret;
	
	if(type instanceof ParameterizedType)
	{
		ParameterizedType asParType = (ParameterizedType)type;
		Class<?> classDef = (java.lang.Class<?>)asParType.getRawType();
		ArrayList<Type> QualifiedgenTypes = extracQualifiedGenTypes(asParType, nameToGenericMap, false);
		
		ret = new NamedType(0,0, new ClassDefJava(dontSetupInterfaceGenerics, classDef), (ArrayList<Type>)QualifiedgenTypes);
	}
	/*else if(type instanceof Class<?> && !((Class<?>) type).isPrimitive()){
		ret = new NamedType(new ClassDefJava((Class<?>)type));
	}*/
	//TODO: wildcard type should really be covered here
	else if(type instanceof GenericArrayType){
		GenericArrayType asGenAt = (GenericArrayType)type;
		
		ret = convertGenType(asGenAt.getGenericComponentType(), nameToGenericMap, dontSetupInterfaceGenerics);
		ret = (Type) ret.copy();
		ret.setArrayLevels(ret.getArrayLevels() + 1);
		
		//HERE IS THE PROBLEOMO
	}
	else{//not generic
		ret= CompiledClassUtils.ConvertCompiledClassToType((java.lang.Class<?>)type, dontSetupInterfaceGenerics);
	}
	
	if(ret instanceof NamedType){
		NamedType asNamed=  ((NamedType)ret);
		ClassDef set = asNamed.getSetClassDef();
		
		if(set instanceof ClassDefJava){
			Class<?> clsHeld =  ((ClassDefJava)set).getClassHeld() ;
			if(refCls.isAssignableFrom(clsHeld)){
				asNamed.setIsRef(true);
			}
			else if(localArrCls.isAssignableFrom(clsHeld) ){
				ret = (Type)asNamed.getGenTypes().get(0).copy();
				ret.setArrayLevels(ret.getArrayLevels()+1);
			}
			else if(lambdaClass.equals(set.getSuperclass())){//convert to FuncType if possible
				ArrayList<Type> gens = asNamed.getGenericTypeElements();
				if(gens != null && !gens.isEmpty()){
					
					for(Type gt : gens){
						if(gt instanceof NamedType){
							NamedType asNamedg = (NamedType)gt;
							if(asNamedg.isWildCardAny){
								return new ModuleType(asNamedg.getLine(), asNamedg.getColumn(), "Constructor, Method or Class references cannot return or take as an input wildcards parameters");
							}
						}
					}
				}
				
				boolean retVoid = set.toString().endsWith("v");
				
				FuncType ft = retVoid?new FuncType(gens, ScopeAndTypeChecker.const_void):new FuncType(new ArrayList<Type>(gens.subList(0, gens.size()-1)), gens.get(gens.size()-1));
				//no ? allowed
				
				String owwnerelambda;
				if(set.equals(classRefClass)){
					ft.isClassRefType=true;
					ft.inputs = null;
					
					owwnerelambda = ft.retType.getBytecodeType();
					owwnerelambda = FuncType.classRefIfacePrefix + owwnerelambda.substring(1, owwnerelambda.length()-1) + FuncType.classRefIfacePostfix;
					
				}
				else{
					owwnerelambda = asNamed.getBytecodeType();//lambdaDetails.getA();//"com/concurnas/bootstrap/lang/Lambda$ClassRef";
					owwnerelambda = owwnerelambda.substring(1, owwnerelambda.length()-1);
				}
				
				ClassFunctionLocation cflloc = new ClassFunctionLocation(owwnerelambda, asNamed, false);
				cflloc.setLambdaOwner(owwnerelambda);
				TypeAndLocation lambdaTal = new TypeAndLocation(asNamed, cflloc);//doesnt resolve to anything, dummy value
				
				ft.setLambdaDetails(lambdaTal);
				ret = ft;
			}
		}
	}
	
	ret.setNullStatus(NullStatus.UNKNOWN);
	
	return ret;
	//TODO: need to deal with wildcard case and generic array case
}
 

public Words(ArrayList<String> words, boolean[] used, int start, int end){
    this.words = new ArrayList<>(words.subList(start, end));
    this.used = arrayCopy(used, start, end - start);
}