public static String[] split(String separators, String list, boolean include) { StringTokenizer tokens = new StringTokenizer( list, separators, include ); String[] result = new String[tokens.countTokens()]; int i = 0; while ( tokens.hasMoreTokens() ) { result[i++] = tokens.nextToken(); } return result; }
/** Basic string tokenization, skipping over white spaces */ public static ArrayList<String> tokenize(String line) { ArrayList<String> tokens = new ArrayList<>(); StringTokenizer tokenizer = new StringTokenizer(line); while (tokenizer.hasMoreElements()) { tokens.add(tokenizer.nextToken()); } return tokens; }
StringTokenizer tokens = new StringTokenizer(CurrentString, ":"); String first = tokens.nextToken();// this will contain "Fruit" String second = tokens.nextToken();// this will contain " they taste good" // in the case above I assumed the string has always that syntax (foo: bar) // but you may want to check if there are tokens or not using the hasMoreTokens method
public void setListeners(String listeners) { StringTokenizer st= new StringTokenizer(listeners, " ,"); while(st.hasMoreTokens()) { m_listeners.add(st.nextToken()); } }
protected void loadMapping(InputStream inputStream) throws IOException { InputStreamReader isr = new InputStreamReader(inputStream); BufferedReader br = new BufferedReader(isr); String line; while ((line = br.readLine()) != null) { StringTokenizer st = new StringTokenizer(line); if (st.countTokens() != 2) { throw new IOException("Wrong file format"); } mapping.put(st.nextToken(), st.nextToken()); } br.close(); isr.close(); inputStream.close(); } }
BufferedReader hin = new BufferedReader(new InputStreamReader( new ByteArrayInputStream(buf, 0, rlen))); Map<String, String> pre = new HashMap<String, String>(); InputStream bin = new FileInputStream(f.getFD()); BufferedReader in = new BufferedReader(new InputStreamReader( bin)); st = new StringTokenizer(contentTypeHeader, ",; "); if (st.hasMoreTokens()) { contentType = st.nextToken(); if (!st.hasMoreTokens()) { Response.error( outputStream, int read = in.read(pbuf); while (read >= 0 && !postLine.endsWith("\r\n")) { postLine += String.valueOf(pbuf, 0, read);
cellhead = new BufferedReader(new FileReader(cellhd)); cellhead.mark(128); if ((line = cellhead.readLine()) == null) { throw new IOException( "The cellhead file seems to be corrupted: " + cellhd.getAbsolutePath()); + cellhd.getAbsolutePath()); cellhead = new BufferedReader(new FileReader(cellhd)); } else { new FileReader(readerGrassEnv.getCELLMISC_FORMAT())); while ((line = cellmiscformat.readLine()) != null) { StringTokenizer tokk = new StringTokenizer(line, ":"); if (tokk.countTokens() == 2) { String key = tokk.nextToken().trim(); String value = tokk.nextToken().trim(); readerFileHeaderMap.put(key, value);
@Override @Nullable public String[] getParameterNames(Method method) { if (method.getParameterCount() == 0) { return new String[0]; } AspectJAnnotation<?> annotation = findAspectJAnnotationOnMethod(method); if (annotation == null) { return null; } StringTokenizer nameTokens = new StringTokenizer(annotation.getArgumentNames(), ","); if (nameTokens.countTokens() > 0) { String[] names = new String[nameTokens.countTokens()]; for (int i = 0; i < names.length; i++) { names[i] = nameTokens.nextToken(); } return names; } else { return null; } }
/** * Set a string representing the property name/value pairs. * * Form: propname1=propvalue1,propname2=propvalue2 * * @param props */ public void setProperties(String props) { Map hashTable = new HashMap(); StringTokenizer pairs = new StringTokenizer(props, ","); while (pairs.hasMoreTokens()) { StringTokenizer entry = new StringTokenizer(pairs.nextToken(), "="); hashTable.put(entry.nextElement().toString().trim(), entry.nextElement().toString().trim()); } synchronized(this) { properties = hashTable; } }
public String[] getDropStrings( String str, String sep ) { StringTokenizer strtok = new StringTokenizer( str, sep ); String[] retval = new String[ strtok.countTokens() ]; int i = 0; while ( strtok.hasMoreElements() ) { retval[ i ] = strtok.nextToken(); i++; } return retval; }
int stringTokenizer = new StringTokenizer(" " +testString + " ", ".").countTokens()-1; System.out.println("stringTokenizer = " + stringTokenizer);
Rule(StringTokenizer st) { if (st.countTokens() < 6) { throw new IllegalArgumentException("Attempting to create a Rule from an incomplete tokenizer"); } iName = st.nextToken().intern(); iFromYear = parseYear(st.nextToken(), 0); iToYear = parseYear(st.nextToken(), iFromYear); if (iToYear < iFromYear) { throw new IllegalArgumentException(); } iType = parseOptional(st.nextToken()); iDateTimeOfYear = new DateTimeOfYear(st); iSaveMillis = parseTime(st.nextToken()); iLetterS = parseOptional(st.nextToken()); }
public static String deblank(String str) { StringTokenizer s = new StringTokenizer(str, " ", false); StringBuilder strRet = new StringBuilder(); while (s.hasMoreElements()) strRet.append(s.nextElement()); return strRet.toString(); }
/** * Returns the next token in the string as an {@code Object}. This method is * implemented in order to satisfy the {@code Enumeration} interface. * * @return next token in the string as an {@code Object} * @throws NoSuchElementException * if no tokens remain. */ public Object nextElement() { return nextToken(); }
/** * Returns {@code true} if unprocessed tokens remain. This method is * implemented in order to satisfy the {@code Enumeration} interface. * * @return {@code true} if unprocessed tokens remain. */ public boolean hasMoreElements() { return hasMoreTokens(); }
private static Profiles parseExpression(String expression) { Assert.hasText(expression, () -> "Invalid profile expression [" + expression + "]: must contain text"); StringTokenizer tokens = new StringTokenizer(expression, "()&|!", true); return parseTokens(expression, tokens); }
public void setMethodSelectors(String methodSelectors) { StringTokenizer st= new StringTokenizer(methodSelectors, " ,"); while(st.hasMoreTokens()) { m_methodselectors.add(st.nextToken()); } }
private double[] parseDoubleArray(String value, String key) { try { StringTokenizer tokenizer = new StringTokenizer(value); double[] result = new double[tokenizer.countTokens()]; for (int i = 0; i < result.length; i++) { result[i] = new Double(tokenizer.nextToken()).doubleValue(); } return result; } catch (NumberFormatException e) { throw createNumberFormatException("sequence of numbers", value, key); } }
public static void reset() { String s = "UK 123"; StringTokenizer st = new StringTokenizer(s); property = st.nextToken(); } }
@Benchmark public int stringTokenizer() { // Using StringTokenizer return new StringTokenizer(" " + testString + " ", ".").countTokens() - 1; }