得到分词结果 List，不进行断句
@param src 字符串
@return ArrayList&lt;String&gt; 词数组，每个元素为一个词
1514
public ArrayList<String> tag2List(String src) {
		if(src==null||src.length()==0)
			return null;
		ArrayList<String> res =null;
		try {
			Instance inst = new Instance(src);
			String[] preds = _tag(inst);
			res  = FormatCWS.toList(inst, preds);
		} catch (Exception e) {
			e.printStackTrace();
		}
		return res;
	}
1320203
public static <T> List<T> flip(final List<T> src, List<T> dest, final int start, final int length)
	{
		if (dest == null)
			dest = new ArrayList<T>();
		else if (!dest.isEmpty())
			dest.clear();

		final int last = start + length - 1;
		for (int i = last; i >= start; i--)
		{
			dest.add(src.get(i));
		}

		return dest;
	}
653104
private RemoteIterator<LocatedFileStatus> methodBasedListPathWithLocation(
      final String src) throws IOException {
    if (namenodeProtocolProxy.isMethodSupported(
        "getLocatedPartialListing", String.class, byte[].class)) {
      return iteratorListing(src);
    } else {
      return arrayListing(src);
    }
  }
904936
public static List<String> getList(BufferedReader br) throws ParserException {
		final List<String> list = new ArrayList<String>();
		processReader(br, new ReaderProcessor() {
			@Override
			public void process(String line) {
				list.add(line);
			}
		});
		return list;
	}
64163
public static List<String> getList(final String val, final boolean emptyOk) throws Throwable {
    List<String> l = new LinkedList<String>();

    if ((val == null) || (val.length() == 0)) {
      return l;
    }

    StringTokenizer st = new StringTokenizer(val, ",", false);
    while (st.hasMoreTokens()) {
      String token = st.nextToken().trim();

      if ((token == null) || (token.length() == 0)) {
        if (!emptyOk) {
          // No empty strings

          throw new Exception("List has an empty element.");
        }
        l.add("");
      } else {
        // Got non-empty element
        l.add(token);
      }
    }

    return l;
  }
378035
public static List<File> listFiles(File srcPath) throws IOException
   {
      List<File> result = new ArrayList<File>();

      if (!srcPath.isDirectory())
      {
         throw new IOException(srcPath.getAbsolutePath() + " is a directory");
      }

      for (File subFile : srcPath.listFiles())
      {
         result.add(subFile);
         if (subFile.isDirectory())
         {
            result.addAll(listFiles(subFile));
         }
      }

      return result;
   }
1117003
public static String[] splitWithCommaOrSemicolon(String src) {
        if (isEmpty(src)) {
            return StringUtils.EMPTY_STRING_ARRAY;
        }
        String[] ss = split(src.replace(',', ';'), ";");
        List<String> list = new ArrayList<String>();
        for (String s : ss) {
            if (!isBlank(s)) {
                list.add(s.trim());
            }
        }
        return list.toArray(new String[list.size()]);
    }
1177117
public FileStatus[] listPaths(String src) throws IOException {
    checkOpen();
    metrics.incLsCalls();
    try {
      if (namenodeProtocolProxy == null) {
        return versionBasedListPath(src);
      }
      return methodBasedListPath(src);
    } catch(RemoteException re) {
      throw re.unwrapRemoteException(AccessControlException.class);
    }
  }
327083
private static byte[] print(final RsJson.Source src) throws IOException {
        final ByteArrayOutputStream baos = new ByteArrayOutputStream();
        try (JsonWriter writer = Json.createWriter(baos)) {
            writer.write(src.toJson());
        }
        return baos.toByteArray();
    }
444077
public List<Page> extractText(InputStream src) throws IOException {
        List<Page> pages = Lists.newArrayList();

        PdfReader reader = new PdfReader(src);
        RenderListener listener = new InternalListener();
        PdfContentStreamProcessor processor = new PdfContentStreamProcessor(listener);

        for (int i = 1; i <= reader.getNumberOfPages(); i++) {
            pages.add(currentPage = new Page());
            PdfDictionary pageDic = reader.getPageN(i);
            PdfDictionary resourcesDic = pageDic.getAsDict(PdfName.RESOURCES);
            processor.processContent(ContentByteUtils.getContentBytesForPage(reader, i), resourcesDic);
        }
        reader.close();

        return pages;
    }
628450
public List<T> list(String str)
    {
        Map<String,T> map = new LinkedHashMap<String,T>();

        if(str == null || str.length() == 0) // Select all resources by default
            str = "%";
        String[] tokens = str.split(",");
        for(String token : tokens)
        {
            token = token.trim();
            if(token.length() > 0)
            {
                Pattern pattern = Pattern.compile(token.replace("?", ".?").replace("%", ".*?"));
                for(NamedResource resource : names.values())
                {
                   if(pattern.matcher(resource.getName()).matches())
                        map.put(resource.getName(), (T)resource);
                }
            }
        }

        List<T> ret = new ArrayList<T>();
        ret.addAll(map.values());
        return ret;
    }
1360982
public String[] getHardLinkedFiles(String src) throws IOException {
    checkOpen();
    try {
      return namenode.getHardLinkedFiles(src);
    } catch (RemoteException re) {
      throw re.unwrapRemoteException(AccessControlException.class,
          NSQuotaExceededException.class, DSQuotaExceededException.class);
    }
  }
123402
public FileStatus[] getListing(String src) throws IOException {
    getListingCheck(src);
    FileStatus[] stats =  dir.getListing(src);
    if (auditLog.isInfoEnabled()) {
      logAuditEvent(getCurrentUGI(),
        Server.getRemoteIp(),
        "listStatus", src, null, null);
    }
    return stats;
  }
799456
public final java.util.List<String> expressionList() throws RecognitionException {
		java.util.List<String> exprs = null;


		ParserRuleReturnScope f =null;
		ParserRuleReturnScope s =null;

		 exprs = new java.util.ArrayList<String>();
		try {
			// src/main/resources/org/drools/compiler/lang/DRL6Expressions.g:725:3: (f= expression ( COMMA s= expression )* )
			// src/main/resources/org/drools/compiler/lang/DRL6Expressions.g:725:7: f= expression ( COMMA s= expression )*
			{
			pushFollow(FOLLOW_expression_in_expressionList4553);
			f=expression();
			state._fsp--;
			if (state.failed) return exprs;
			if ( state.backtracking==0 ) { exprs.add( (f!=null?input.toString(f.start,f.stop):null) ); }
			// src/main/resources/org/drools/compiler/lang/DRL6Expressions.g:726:7: ( COMMA s= expression )*
			loop96:
			while (true) {
				int alt96=2;
				int LA96_0 = input.LA(1);
				if ( (LA96_0==COMMA) ) {
					alt96=1;
				}

				switch (alt96) {
				case 1 :
					// src/main/resources/org/drools/compiler/lang/DRL6Expressions.g:726:8: COMMA s= expression
					{
					match(input,COMMA,FOLLOW_COMMA_in_expressionList4564); if (state.failed) return exprs;
					pushFollow(FOLLOW_expression_in_expressionList4568);
					s=expression();
					state._fsp--;
					if (state.failed) return exprs;
					if ( state.backtracking==0 ) { exprs.add( (s!=null?input.toString(s.start,s.stop):null) ); }
					}
					break;

				default :
					break loop96;
				}
			}

			}

		}

		catch (RecognitionException re) {
		    throw re;
		}

		finally {
			// do for sure before leaving
		}
		return exprs;
	}
734188
public static String restrictHTML (String src, String[] regexes)
    {
        if (StringUtil.isBlank(src)) {
            return src;
        }

        ArrayList<String> list = new ArrayList<String>();
        list.add(src);
        for (String regexe : regexes) {
            Pattern p = Pattern.compile(regexe, Pattern.CASE_INSENSITIVE);
            for (int jj=0; jj < list.size(); jj += 2) {
                String piece = list.get(jj);
                Matcher m = p.matcher(piece);
                if (m.find()) {
                    list.set(jj, piece.substring(0, m.start()));
                    list.add(jj + 1, piece.substring(m.start(), m.end()));
                    list.add(jj + 2, piece.substring(m.end()));
                }
            }
        }

        // now, the even elements of list contain untrusted text, the
        // odd elements contain stuff that matched a regex
        StringBuilder buf = new StringBuilder();
        for (int jj=0, nn = list.size(); jj < nn; jj++) {
            String s = list.get(jj);
            if (jj % 2 == 0) {
                s = s.replace("<", "&lt;");
                s = s.replace(">", "&gt;");
            }
            buf.append(s);
        }
        return buf.toString();
    }
1344331
public static byte[] copyOf(byte[] src, int length) {
        byte[] dest = new byte[length];
        System.arraycopy(src, 0, dest, 0, Math.min(src.length, length));
        return dest;
    }
583500
public static Object deepBox(Object src) {
        Class<?> resultType = arrayBoxingType(src.getClass());
        return deepBox(resultType, src);
    }