Checks a list of &lt;String&gt; elements to see if every element
in the list is empty.

@param l
List of &lt;String&gt;
@return boolean
true when all elements are empty
498277
public static boolean isListElementsEmpty(final List<String> l) {
        for (final String s : l) {
            if (s != null && s.trim().length() > 0) {
                return false;
            }
        }
        return true;
    }
1179100
@Override
	public synchronized boolean contains(Object o) {
		if (start == end) return false; // empty
		if (end == -1) {
			// full
			for (int i = array.length - 1; i >= 0; --i)
				if (array[i].equals(o))
					return true;
			return false;
		}
		if (end < start) {
			for (int i = array.length - 1; i >= start; --i)
				if (array[i].equals(o))
					return true;
			for (int i = 0; i < end; ++i)
				if (array[i].equals(o))
					return true;
			return false;
		}
		for (int i = start; i < end; ++i)
			if (array[i].equals(o))
				return true;
		return false;
	}
875643
public final boolean contains(final int e) {
        for (int i = 0; i < size; ++i)
            if (list[i] == e) return true;
        return false;
    }
93146
public boolean contains(List<String> containWith) {
		return contain(checkNotNull(containWith).toArray(new String[containWith.size()]));
	}
1327506
public static boolean checkList(List<String> keyList, List<String> valueList) {
		// Assert.notEmpty(keyList, "参数keyList不能为空.");
		// Assert.notEmpty(valueList, "参数valueList不能为空.");
		if (keyList == null || keyList.isEmpty()) {
			throw new IllegalArgumentException("参数keyList不能为空.");
		}
		if (valueList == null || valueList.isEmpty()) {
			throw new IllegalArgumentException("参数valueList不能为空.");
		}
		if (keyList.size() != valueList.size()) {
			throw new IllegalArgumentException("参数keyList和valueList长度不一致.");
		}
		return true;
	}
596523
public boolean isEmpty() {
        for (int i = 0; i + 1 < array.length; i += 2) {
            int valueNumber = array[i];
            if (valueNumber < 0) {
                return true;
            }
            int myLockCount = array[i + 1];
            if (myLockCount > 0) {
                return false;
            }
        }
        return true;
    }
877536
public boolean isEmpty() {
        for (Node p = head; p != null; p = succ(p)) {
            if (!p.isMatched())
                return !p.isData;
        }
        return true;
    }
1277700
public static boolean isEmpty(@Nullable String str) {
        if (str == null || str.length() == 0) {
            return true;
        }
        return false;
    }
1264882
@Override
  public boolean hasNext() {
    while (!(iterators.isEmpty() || iterators.peek().hasNext())) {
      Assert.isFalse(iterators.removeFirst().hasNext(), new IllegalStateException("removing a non-empty Iterator"));
    }

    return (!iterators.isEmpty() && iterators.peek().hasNext());
  }
34926
private void checkL() throws DatatypeException, IOException {
        if (context.length() == 0) {
            appendToContext(current);
        }
        current = reader.read();
        appendToContext(current);
        skipSpaces();
        _checkL('L', true);
    }
1336895
public boolean isEmpty() {
        if(value == null) {
            return true;
        }
        
        if(value instanceof String) {
            return ((String)value).isEmpty();
        }
        
        return false;
    }
591095
@SuppressWarnings("unchecked")
	public static <T> boolean hasNull(T... array) {
		if (isNotEmpty(array)) {
			for (T element : array) {
				if (null == element) {
					return true;
				}
			}
		}
		return false;
	}
422500
public boolean isEmpty() {
		switch(size()) {
			case 0:
				return true;
			case 1:
				Element element = (Element) arrayList.get(0);
				switch (element.type()) {
					case Element.CHUNK:
						return ((Chunk) element).isEmpty();
					case Element.ANCHOR:
					case Element.PHRASE:
					case Element.PARAGRAPH:
						return ((Phrase) element).isEmpty();
					case Element.LIST:
						return ((List) element).isEmpty();
				}
			return false;
			default:
				return false;
		}
	}
752053
public boolean hasNext() {

        // for chained iterators
        if (chained) {
            if (it1 == null) {
                if (it2 == null) {
                    return false;
                }

                if (it2.hasNext()) {
                    return true;
                }

                it2 = null;

                return false;
            } else {
                if (it1.hasNext()) {
                    return true;
                }

                it1 = null;

                return hasNext();
            }
        }

        // for other interators
        if (elements == null) {
            return false;
        }

        for (; notNull && i < elements.length && elements[i] == null; i++) {}

        if (i < elements.length) {
            return true;
        } else {

            // release elements for garbage collection
            elements = null;

            return false;
        }
    }
1094682
public static boolean hasEntry(Object list) {
        if (list == null)
            return false;
        if (list instanceof List)
            return !((List<?>) list).isEmpty();
        return true;
    }
1317311
@Override
	public boolean isEmpty() {
		for(List<? extends Method<? extends E>> methods : methodsByClass.values()) {
			for(Method<? extends E> method : methods) {
				E singleton = method.getSingleton(target);
				if(singleton!=null) return false;
				Set<? extends E> set = method.getSet(target);
				if(set!=null && !set.isEmpty()) return false;
			}
		}
		return true;
	}
318821
public static boolean isNullOrEmpty(Object obj) {
        if (obj == null)
            return true;
        if (obj instanceof String) {
            return (((String) obj).isEmpty());
        }
        if (obj instanceof Map) {
            return ((Map) obj).isEmpty();
        }
        if (obj instanceof List) {
            return ((List) obj).isEmpty();
        }
        if (obj instanceof Set) {
            return ((Set) obj).isEmpty();
        }
        return false;
    }