code
stringlengths 11
173k
| docstring
stringlengths 2
593k
| func_name
stringlengths 2
189
| language
stringclasses 1
value | repo
stringclasses 844
values | path
stringlengths 11
294
| url
stringlengths 60
339
| license
stringclasses 4
values |
|---|---|---|---|---|---|---|---|
public boolean isRecord() {
return false;
} |
Returns {@code true} if and only if this class is a record class.
<p>The {@linkplain #getSuperclass() direct superclass} of a record class is {@code
java.lang.Record}. A record class is {@linkplain Modifier#FINAL final}. A record class has
(possibly zero) record components; {@link #getRecordComponents()} returns a non-null but
possibly empty value for a record.
<p>Note that class {@link Record} is not a record class and thus invoking this method on class
{@code Record} returns {@code false}.
@return true if and only if this class is a record class, otherwise false
@jls 8.10 Record Classes
@since 16
| Class::isRecord | java | google/j2objc | jre_emul/stub_classes/java/java/lang/Class.java | https://github.com/google/j2objc/blob/master/jre_emul/stub_classes/java/java/lang/Class.java | Apache-2.0 |
public boolean isInstance(Object obj) {
return false;
} |
Determines if the specified {@code Object} is assignment-compatible
with the object represented by this {@code Class}. This method is
the dynamic equivalent of the Java language {@code instanceof}
operator. The method returns {@code true} if the specified
{@code Object} argument is non-null and can be cast to the
reference type represented by this {@code Class} object without
raising a {@code ClassCastException.} It returns {@code false}
otherwise.
<p> Specifically, if this {@code Class} object represents a
declared class, this method returns {@code true} if the specified
{@code Object} argument is an instance of the represented class (or
of any of its subclasses); it returns {@code false} otherwise. If
this {@code Class} object represents an array class, this method
returns {@code true} if the specified {@code Object} argument
can be converted to an object of the array class by an identity
conversion or by a widening reference conversion; it returns
{@code false} otherwise. If this {@code Class} object
represents an interface, this method returns {@code true} if the
class or any superclass of the specified {@code Object} argument
implements this interface; it returns {@code false} otherwise. If
this {@code Class} object represents a primitive type, this method
returns {@code false}.
@param obj the object to check
@return true if {@code obj} is an instance of this class
@since JDK1.1
| Class::isInstance | java | google/j2objc | jre_emul/stub_classes/java/java/lang/Class.java | https://github.com/google/j2objc/blob/master/jre_emul/stub_classes/java/java/lang/Class.java | Apache-2.0 |
public boolean isInterface() {
return false;
} |
Determines if the specified {@code Class} object represents an
interface type.
@return {@code true} if this object represents an interface;
{@code false} otherwise.
| Class::isInterface | java | google/j2objc | jre_emul/stub_classes/java/java/lang/Class.java | https://github.com/google/j2objc/blob/master/jre_emul/stub_classes/java/java/lang/Class.java | Apache-2.0 |
public boolean isLocalClass() {
return false;
} |
Returns {@code true} if and only if the underlying class
is a local class.
@return {@code true} if and only if this class is a local class.
@since 1.5
| Class::isLocalClass | java | google/j2objc | jre_emul/stub_classes/java/java/lang/Class.java | https://github.com/google/j2objc/blob/master/jre_emul/stub_classes/java/java/lang/Class.java | Apache-2.0 |
public boolean isMemberClass() {
return false;
} |
Returns {@code true} if and only if the underlying class
is a member class.
@return {@code true} if and only if this class is a member class.
@since 1.5
| Class::isMemberClass | java | google/j2objc | jre_emul/stub_classes/java/java/lang/Class.java | https://github.com/google/j2objc/blob/master/jre_emul/stub_classes/java/java/lang/Class.java | Apache-2.0 |
public boolean isPrimitive() {
return false;
} |
Determines if the specified {@code Class} object represents a
primitive type.
<p> There are nine predefined {@code Class} objects to represent
the eight primitive types and void. These are created by the Java
Virtual Machine, and have the same names as the primitive types that
they represent, namely {@code boolean}, {@code byte},
{@code char}, {@code short}, {@code int},
{@code long}, {@code float}, and {@code double}.
<p> These objects may only be accessed via the following public static
final variables, and are the only {@code Class} objects for which
this method returns {@code true}.
@return true if and only if this class represents a primitive type
@see java.lang.Boolean#TYPE
@see java.lang.Character#TYPE
@see java.lang.Byte#TYPE
@see java.lang.Short#TYPE
@see java.lang.Integer#TYPE
@see java.lang.Long#TYPE
@see java.lang.Float#TYPE
@see java.lang.Double#TYPE
@see java.lang.Void#TYPE
@since JDK1.1
| Class::isPrimitive | java | google/j2objc | jre_emul/stub_classes/java/java/lang/Class.java | https://github.com/google/j2objc/blob/master/jre_emul/stub_classes/java/java/lang/Class.java | Apache-2.0 |
public boolean isSynthetic() {
return false;
} |
Returns {@code true} if this class is a synthetic class;
returns {@code false} otherwise.
@return {@code true} if and only if this class is a synthetic class as
defined by the Java Language Specification.
@jls 13.1 The Form of a Binary
@since 1.5
| Class::isSynthetic | java | google/j2objc | jre_emul/stub_classes/java/java/lang/Class.java | https://github.com/google/j2objc/blob/master/jre_emul/stub_classes/java/java/lang/Class.java | Apache-2.0 |
public T newInstance() throws InstantiationException, IllegalAccessException {
return null;
} |
Creates a new instance of the class represented by this {@code Class}
object. The class is instantiated as if by a {@code new}
expression with an empty argument list. The class is initialized if it
has not already been initialized.
<p>Note that this method propagates any exception thrown by the
nullary constructor, including a checked exception. Use of
this method effectively bypasses the compile-time exception
checking that would otherwise be performed by the compiler.
The {@link
java.lang.reflect.Constructor#newInstance(java.lang.Object...)
Constructor.newInstance} method avoids this problem by wrapping
any exception thrown by the constructor in a (checked) {@link
java.lang.reflect.InvocationTargetException}.
@return a newly allocated instance of the class represented by this
object.
@throws IllegalAccessException if the class or its nullary
constructor is not accessible.
@throws InstantiationException
if this {@code Class} represents an abstract class,
an interface, an array class, a primitive type, or void;
or if the class has no nullary constructor;
or if the instantiation fails for some other reason.
@throws ExceptionInInitializerError if the initialization
provoked by this method fails.
@throws SecurityException
If a security manager, <i>s</i>, is present and
the caller's class loader is not the same as or an
ancestor of the class loader for the current class and
invocation of {@link SecurityManager#checkPackageAccess
s.checkPackageAccess()} denies access to the package
of this class.
| Class::newInstance | java | google/j2objc | jre_emul/stub_classes/java/java/lang/Class.java | https://github.com/google/j2objc/blob/master/jre_emul/stub_classes/java/java/lang/Class.java | Apache-2.0 |
public String toString() {
return "";
} |
Converts the object to a string. The string representation is the
string "class" or "interface", followed by a space, and then by the
fully qualified name of the class in the format returned by
{@code getName}. If this {@code Class} object represents a
primitive type, this method returns the name of the primitive type. If
this {@code Class} object represents void this method returns
"void".
@return a string representation of this class object.
| Class::toString | java | google/j2objc | jre_emul/stub_classes/java/java/lang/Class.java | https://github.com/google/j2objc/blob/master/jre_emul/stub_classes/java/java/lang/Class.java | Apache-2.0 |
public <A extends Annotation> A[] getDeclaredAnnotationsByType(Class<A> annotationClass) {
return null;
} |
@since 1.8
| Class::getDeclaredAnnotationsByType | java | google/j2objc | jre_emul/stub_classes/java/java/lang/Class.java | https://github.com/google/j2objc/blob/master/jre_emul/stub_classes/java/java/lang/Class.java | Apache-2.0 |
public String getTypeName() {
return null;
} |
Return an informative string for the name of this type.
@return an informative string for the name of this type
@since 1.8
| Class::getTypeName | java | google/j2objc | jre_emul/stub_classes/java/java/lang/Class.java | https://github.com/google/j2objc/blob/master/jre_emul/stub_classes/java/java/lang/Class.java | Apache-2.0 |
public String toGenericString() {
return null;
} |
Returns a string describing this {@code Class}, including
information about modifiers and type parameters.
The string is formatted as a list of type modifiers, if any,
followed by the kind of type (empty string for primitive types
and {@code class}, {@code enum}, {@code interface}, or
<code>@</code>{@code interface}, as appropriate), followed
by the type's name, followed by an angle-bracketed
comma-separated list of the type's type parameters, if any.
A space is used to separate modifiers from one another and to
separate any modifiers from the kind of type. The modifiers
occur in canonical order. If there are no type parameters, the
type parameter list is elided.
<p>Note that since information about the runtime representation
of a type is being generated, modifiers not present on the
originating source code or illegal on the originating source
code may be present.
@return a string describing this {@code Class}, including
information about modifiers and type parameters
@since 1.8
| Class::toGenericString | java | google/j2objc | jre_emul/stub_classes/java/java/lang/Class.java | https://github.com/google/j2objc/blob/master/jre_emul/stub_classes/java/java/lang/Class.java | Apache-2.0 |
public String() {} |
Initializes a newly created {@code String} object so that it represents
an empty character sequence. Note that use of this constructor is
unnecessary since Strings are immutable.
| String::String | java | google/j2objc | jre_emul/stub_classes/java/java/lang/String.java | https://github.com/google/j2objc/blob/master/jre_emul/stub_classes/java/java/lang/String.java | Apache-2.0 |
public String(char value[]) {} |
Allocates a new {@code String} so that it represents the sequence of
characters currently contained in the character array argument. The
contents of the character array are copied; subsequent modification of
the character array does not affect the newly created string.
@param value
The initial value of the string
| String::String | java | google/j2objc | jre_emul/stub_classes/java/java/lang/String.java | https://github.com/google/j2objc/blob/master/jre_emul/stub_classes/java/java/lang/String.java | Apache-2.0 |
public String(char value[], int offset, int count) {} |
Allocates a new {@code String} that contains characters from a subarray
of the character array argument. The {@code offset} argument is the
index of the first character of the subarray and the {@code count}
argument specifies the length of the subarray. The contents of the
subarray are copied; subsequent modification of the character array does
not affect the newly created string.
@param value
Array that is the source of characters
@param offset
The initial offset
@param count
The length
@throws IndexOutOfBoundsException
If {@code offset} is negative, {@code count} is negative, or
{@code offset} is greater than {@code value.length - count}
| String::String | java | google/j2objc | jre_emul/stub_classes/java/java/lang/String.java | https://github.com/google/j2objc/blob/master/jre_emul/stub_classes/java/java/lang/String.java | Apache-2.0 |
public String(int[] codePoints, int offset, int count) {} |
Allocates a new {@code String} that contains characters from a subarray
of the <a href="Character.html#unicode">Unicode code point</a> array
argument. The {@code offset} argument is the index of the first code
point of the subarray and the {@code count} argument specifies the
length of the subarray. The contents of the subarray are converted to
{@code char}s; subsequent modification of the {@code int} array does not
affect the newly created string.
@param codePoints
Array that is the source of Unicode code points
@param offset
The initial offset
@param count
The length
@throws IllegalArgumentException
If any invalid Unicode code point is found in {@code
codePoints}
@throws IndexOutOfBoundsException
If {@code offset} is negative, {@code count} is negative, or
{@code offset} is greater than {@code codePoints.length - count}
@since 1.5
| String::String | java | google/j2objc | jre_emul/stub_classes/java/java/lang/String.java | https://github.com/google/j2objc/blob/master/jre_emul/stub_classes/java/java/lang/String.java | Apache-2.0 |
public String(byte bytes[], int offset, int length, String charsetName)
throws UnsupportedEncodingException {} |
Constructs a new {@code String} by decoding the specified subarray of
bytes using the specified charset. The length of the new {@code String}
is a function of the charset, and hence may not be equal to the length
of the subarray.
<p> The behavior of this constructor when the given bytes are not valid
in the given charset is unspecified. The {@link
java.nio.charset.CharsetDecoder} class should be used when more control
over the decoding process is required.
@param bytes
The bytes to be decoded into characters
@param offset
The index of the first byte to decode
@param length
The number of bytes to decode
@param charsetName
The name of a supported {@linkplain java.nio.charset.Charset
charset}
@throws UnsupportedEncodingException
If the named charset is not supported
@throws IndexOutOfBoundsException
If {@code offset} is negative, {@code length} is negative, or
{@code offset} is greater than {@code bytes.length - length}
@since 1.1
| String::String | java | google/j2objc | jre_emul/stub_classes/java/java/lang/String.java | https://github.com/google/j2objc/blob/master/jre_emul/stub_classes/java/java/lang/String.java | Apache-2.0 |
public String(byte bytes[], int offset, int length, Charset charset) {} |
Constructs a new {@code String} by decoding the specified subarray of
bytes using the specified {@linkplain java.nio.charset.Charset charset}.
The length of the new {@code String} is a function of the charset, and
hence may not be equal to the length of the subarray.
<p> This method always replaces malformed-input and unmappable-character
sequences with this charset's default replacement string. The {@link
java.nio.charset.CharsetDecoder} class should be used when more control
over the decoding process is required.
@param bytes
The bytes to be decoded into characters
@param offset
The index of the first byte to decode
@param length
The number of bytes to decode
@param charset
The {@linkplain java.nio.charset.Charset charset} to be used to
decode the {@code bytes}
@throws IndexOutOfBoundsException
If {@code offset} is negative, {@code length} is negative, or
{@code offset} is greater than {@code bytes.length - length}
@since 1.6
| String::String | java | google/j2objc | jre_emul/stub_classes/java/java/lang/String.java | https://github.com/google/j2objc/blob/master/jre_emul/stub_classes/java/java/lang/String.java | Apache-2.0 |
public String(byte bytes[], String charsetName)
throws UnsupportedEncodingException {} |
Constructs a new {@code String} by decoding the specified array of bytes
using the specified {@linkplain java.nio.charset.Charset charset}. The
length of the new {@code String} is a function of the charset, and hence
may not be equal to the length of the byte array.
<p> The behavior of this constructor when the given bytes are not valid
in the given charset is unspecified. The {@link
java.nio.charset.CharsetDecoder} class should be used when more control
over the decoding process is required.
@param bytes
The bytes to be decoded into characters
@param charsetName
The name of a supported {@linkplain java.nio.charset.Charset
charset}
@throws UnsupportedEncodingException
If the named charset is not supported
@since 1.1
| String::String | java | google/j2objc | jre_emul/stub_classes/java/java/lang/String.java | https://github.com/google/j2objc/blob/master/jre_emul/stub_classes/java/java/lang/String.java | Apache-2.0 |
public String(byte bytes[], Charset charset) {} |
Constructs a new {@code String} by decoding the specified array of
bytes using the specified {@linkplain java.nio.charset.Charset charset}.
The length of the new {@code String} is a function of the charset, and
hence may not be equal to the length of the byte array.
<p> This method always replaces malformed-input and unmappable-character
sequences with this charset's default replacement string. The {@link
java.nio.charset.CharsetDecoder} class should be used when more control
over the decoding process is required.
@param bytes
The bytes to be decoded into characters
@param charset
The {@linkplain java.nio.charset.Charset charset} to be used to
decode the {@code bytes}
@since 1.6
| String::String | java | google/j2objc | jre_emul/stub_classes/java/java/lang/String.java | https://github.com/google/j2objc/blob/master/jre_emul/stub_classes/java/java/lang/String.java | Apache-2.0 |
public String(byte bytes[], int offset, int length) {} |
Constructs a new {@code String} by decoding the specified subarray of
bytes using the platform's default charset. The length of the new
{@code String} is a function of the charset, and hence may not be equal
to the length of the subarray.
<p> The behavior of this constructor when the given bytes are not valid
in the default charset is unspecified. The {@link
java.nio.charset.CharsetDecoder} class should be used when more control
over the decoding process is required.
@param bytes
The bytes to be decoded into characters
@param offset
The index of the first byte to decode
@param length
The number of bytes to decode
@throws IndexOutOfBoundsException
If {@code offset} is negative, {@code length} is negative, or
{@code offset} is greater than {@code bytes.length - length}
@since 1.1
| String::String | java | google/j2objc | jre_emul/stub_classes/java/java/lang/String.java | https://github.com/google/j2objc/blob/master/jre_emul/stub_classes/java/java/lang/String.java | Apache-2.0 |
public String(byte[] bytes) {} |
Constructs a new {@code String} by decoding the specified array of bytes
using the platform's default charset. The length of the new {@code
String} is a function of the charset, and hence may not be equal to the
length of the byte array.
<p> The behavior of this constructor when the given bytes are not valid
in the default charset is unspecified. The {@link
java.nio.charset.CharsetDecoder} class should be used when more control
over the decoding process is required.
@param bytes
The bytes to be decoded into characters
@since 1.1
| String::String | java | google/j2objc | jre_emul/stub_classes/java/java/lang/String.java | https://github.com/google/j2objc/blob/master/jre_emul/stub_classes/java/java/lang/String.java | Apache-2.0 |
public String(StringBuffer buffer) {} |
Allocates a new string that contains the sequence of characters
currently contained in the string buffer argument. The contents of the
string buffer are copied; subsequent modification of the string buffer
does not affect the newly created string.
@param buffer
A {@code StringBuffer}
| String::String | java | google/j2objc | jre_emul/stub_classes/java/java/lang/String.java | https://github.com/google/j2objc/blob/master/jre_emul/stub_classes/java/java/lang/String.java | Apache-2.0 |
public String(StringBuilder builder) {} |
Allocates a new string that contains the sequence of characters
currently contained in the string builder argument. The contents of the
string builder are copied; subsequent modification of the string builder
does not affect the newly created string.
<p> This constructor is provided to ease migration to {@code
StringBuilder}. Obtaining a string from a string builder via the {@code
toString} method is likely to run faster and is generally preferred.
@param builder
A {@code StringBuilder}
@since 1.5
| String::String | java | google/j2objc | jre_emul/stub_classes/java/java/lang/String.java | https://github.com/google/j2objc/blob/master/jre_emul/stub_classes/java/java/lang/String.java | Apache-2.0 |
public int length() {
return 0;
} |
Returns the length of this string.
The length is equal to the number of <a href="Character.html#unicode">Unicode
code units</a> in the string.
@return the length of the sequence of characters represented by this
object.
| String::length | java | google/j2objc | jre_emul/stub_classes/java/java/lang/String.java | https://github.com/google/j2objc/blob/master/jre_emul/stub_classes/java/java/lang/String.java | Apache-2.0 |
public boolean isEmpty() {
return false;
} |
Returns {@code true} if, and only if, {@link #length()} is {@code 0}.
@return {@code true} if {@link #length()} is {@code 0}, otherwise
{@code false}
@since 1.6
| String::isEmpty | java | google/j2objc | jre_emul/stub_classes/java/java/lang/String.java | https://github.com/google/j2objc/blob/master/jre_emul/stub_classes/java/java/lang/String.java | Apache-2.0 |
public char charAt(int index) {
return 0;
} |
Returns the {@code char} value at the
specified index. An index ranges from {@code 0} to
{@code length() - 1}. The first {@code char} value of the sequence
is at index {@code 0}, the next at index {@code 1},
and so on, as for array indexing.
<p>If the {@code char} value specified by the index is a
<a href="Character.html#unicode">surrogate</a>, the surrogate
value is returned.
@param index the index of the {@code char} value.
@return the {@code char} value at the specified index of this string.
The first {@code char} value is at index {@code 0}.
@exception IndexOutOfBoundsException if the {@code index}
argument is negative or not less than the length of this
string.
| String::charAt | java | google/j2objc | jre_emul/stub_classes/java/java/lang/String.java | https://github.com/google/j2objc/blob/master/jre_emul/stub_classes/java/java/lang/String.java | Apache-2.0 |
public int codePointAt(int index) {
return 0;
} |
Returns the character (Unicode code point) at the specified
index. The index refers to {@code char} values
(Unicode code units) and ranges from {@code 0} to
{@link #length()}{@code - 1}.
<p> If the {@code char} value specified at the given index
is in the high-surrogate range, the following index is less
than the length of this {@code String}, and the
{@code char} value at the following index is in the
low-surrogate range, then the supplementary code point
corresponding to this surrogate pair is returned. Otherwise,
the {@code char} value at the given index is returned.
@param index the index to the {@code char} values
@return the code point value of the character at the
{@code index}
@exception IndexOutOfBoundsException if the {@code index}
argument is negative or not less than the length of this
string.
@since 1.5
| String::codePointAt | java | google/j2objc | jre_emul/stub_classes/java/java/lang/String.java | https://github.com/google/j2objc/blob/master/jre_emul/stub_classes/java/java/lang/String.java | Apache-2.0 |
public int codePointBefore(int index) {
return 0;
} |
Returns the character (Unicode code point) before the specified
index. The index refers to {@code char} values
(Unicode code units) and ranges from {@code 1} to {@link
CharSequence#length() length}.
<p> If the {@code char} value at {@code (index - 1)}
is in the low-surrogate range, {@code (index - 2)} is not
negative, and the {@code char} value at {@code (index -
2)} is in the high-surrogate range, then the
supplementary code point value of the surrogate pair is
returned. If the {@code char} value at {@code index -
1} is an unpaired low-surrogate or a high-surrogate, the
surrogate value is returned.
@param index the index following the code point that should be returned
@return the Unicode code point value before the given index.
@exception IndexOutOfBoundsException if the {@code index}
argument is less than 1 or greater than the length
of this string.
@since 1.5
| String::codePointBefore | java | google/j2objc | jre_emul/stub_classes/java/java/lang/String.java | https://github.com/google/j2objc/blob/master/jre_emul/stub_classes/java/java/lang/String.java | Apache-2.0 |
public int codePointCount(int beginIndex, int endIndex) {
return 0;
} |
Returns the number of Unicode code points in the specified text
range of this {@code String}. The text range begins at the
specified {@code beginIndex} and extends to the
{@code char} at index {@code endIndex - 1}. Thus the
length (in {@code char}s) of the text range is
{@code endIndex-beginIndex}. Unpaired surrogates within
the text range count as one code point each.
@param beginIndex the index to the first {@code char} of
the text range.
@param endIndex the index after the last {@code char} of
the text range.
@return the number of Unicode code points in the specified text
range
@exception IndexOutOfBoundsException if the
{@code beginIndex} is negative, or {@code endIndex}
is larger than the length of this {@code String}, or
{@code beginIndex} is larger than {@code endIndex}.
@since 1.5
| String::codePointCount | java | google/j2objc | jre_emul/stub_classes/java/java/lang/String.java | https://github.com/google/j2objc/blob/master/jre_emul/stub_classes/java/java/lang/String.java | Apache-2.0 |
public int offsetByCodePoints(int index, int codePointOffset) {
return 0;
} |
Returns the index within this {@code String} that is
offset from the given {@code index} by
{@code codePointOffset} code points. Unpaired surrogates
within the text range given by {@code index} and
{@code codePointOffset} count as one code point each.
@param index the index to be offset
@param codePointOffset the offset in code points
@return the index within this {@code String}
@exception IndexOutOfBoundsException if {@code index}
is negative or larger then the length of this
{@code String}, or if {@code codePointOffset} is positive
and the substring starting with {@code index} has fewer
than {@code codePointOffset} code points,
or if {@code codePointOffset} is negative and the substring
before {@code index} has fewer than the absolute value
of {@code codePointOffset} code points.
@since 1.5
| String::offsetByCodePoints | java | google/j2objc | jre_emul/stub_classes/java/java/lang/String.java | https://github.com/google/j2objc/blob/master/jre_emul/stub_classes/java/java/lang/String.java | Apache-2.0 |
public void getChars(int srcBegin, int srcEnd, char dst[], int dstBegin) {} |
Copies characters from this string into the destination character
array.
<p>
The first character to be copied is at index {@code srcBegin};
the last character to be copied is at index {@code srcEnd-1}
(thus the total number of characters to be copied is
{@code srcEnd-srcBegin}). The characters are copied into the
subarray of {@code dst} starting at index {@code dstBegin}
and ending at index:
<blockquote><pre>
dstBegin + (srcEnd-srcBegin) - 1
</pre></blockquote>
@param srcBegin index of the first character in the string
to copy.
@param srcEnd index after the last character in the string
to copy.
@param dst the destination array.
@param dstBegin the start offset in the destination array.
@exception IndexOutOfBoundsException If any of the following
is true:
<ul><li>{@code srcBegin} is negative.
<li>{@code srcBegin} is greater than {@code srcEnd}
<li>{@code srcEnd} is greater than the length of this
string
<li>{@code dstBegin} is negative
<li>{@code dstBegin+(srcEnd-srcBegin)} is larger than
{@code dst.length}</ul>
| String::getChars | java | google/j2objc | jre_emul/stub_classes/java/java/lang/String.java | https://github.com/google/j2objc/blob/master/jre_emul/stub_classes/java/java/lang/String.java | Apache-2.0 |
public byte[] getBytes(String charsetName)
throws UnsupportedEncodingException {
return null;
} |
Encodes this {@code String} into a sequence of bytes using the named
charset, storing the result into a new byte array.
<p> The behavior of this method when this string cannot be encoded in
the given charset is unspecified. The {@link
java.nio.charset.CharsetEncoder} class should be used when more control
over the encoding process is required.
@param charsetName
The name of a supported {@linkplain java.nio.charset.Charset
charset}
@return The resultant byte array
@throws UnsupportedEncodingException
If the named charset is not supported
@since 1.1
| String::getBytes | java | google/j2objc | jre_emul/stub_classes/java/java/lang/String.java | https://github.com/google/j2objc/blob/master/jre_emul/stub_classes/java/java/lang/String.java | Apache-2.0 |
public byte[] getBytes(Charset charset) {
return null;
} |
Encodes this {@code String} into a sequence of bytes using the given
{@linkplain java.nio.charset.Charset charset}, storing the result into a
new byte array.
<p> This method always replaces malformed-input and unmappable-character
sequences with this charset's default replacement byte array. The
{@link java.nio.charset.CharsetEncoder} class should be used when more
control over the encoding process is required.
@param charset
The {@linkplain java.nio.charset.Charset} to be used to encode
the {@code String}
@return The resultant byte array
@since 1.6
| String::getBytes | java | google/j2objc | jre_emul/stub_classes/java/java/lang/String.java | https://github.com/google/j2objc/blob/master/jre_emul/stub_classes/java/java/lang/String.java | Apache-2.0 |
public byte[] getBytes() {
return null;
} |
Encodes this {@code String} into a sequence of bytes using the
platform's default charset, storing the result into a new byte array.
<p> The behavior of this method when this string cannot be encoded in
the default charset is unspecified. The {@link
java.nio.charset.CharsetEncoder} class should be used when more control
over the encoding process is required.
@return The resultant byte array
@since 1.1
| String::getBytes | java | google/j2objc | jre_emul/stub_classes/java/java/lang/String.java | https://github.com/google/j2objc/blob/master/jre_emul/stub_classes/java/java/lang/String.java | Apache-2.0 |
public boolean equals(Object anObject) {
return false;
} |
Compares this string to the specified object. The result is {@code
true} if and only if the argument is not {@code null} and is a {@code
String} object that represents the same sequence of characters as this
object.
<p>For finer-grained String comparison, refer to
{@link java.text.Collator}.
@param anObject
The object to compare this {@code String} against
@return {@code true} if the given object represents a {@code String}
equivalent to this string, {@code false} otherwise
@see #compareTo(String)
@see #equalsIgnoreCase(String)
| String::equals | java | google/j2objc | jre_emul/stub_classes/java/java/lang/String.java | https://github.com/google/j2objc/blob/master/jre_emul/stub_classes/java/java/lang/String.java | Apache-2.0 |
public boolean contentEquals(StringBuffer sb) {
return false;
} |
Compares this string to the specified {@code StringBuffer}. The result
is {@code true} if and only if this {@code String} represents the same
sequence of characters as the specified {@code StringBuffer}. This method
synchronizes on the {@code StringBuffer}.
<p>For finer-grained String comparison, refer to
{@link java.text.Collator}.
@param sb
The {@code StringBuffer} to compare this {@code String} against
@return {@code true} if this {@code String} represents the same
sequence of characters as the specified {@code StringBuffer},
{@code false} otherwise
@since 1.4
| String::contentEquals | java | google/j2objc | jre_emul/stub_classes/java/java/lang/String.java | https://github.com/google/j2objc/blob/master/jre_emul/stub_classes/java/java/lang/String.java | Apache-2.0 |
public boolean contentEquals(CharSequence cs) {
return false;
} |
Compares this string to the specified {@code CharSequence}. The
result is {@code true} if and only if this {@code String} represents the
same sequence of char values as the specified sequence. Note that if the
{@code CharSequence} is a {@code StringBuffer} then the method
synchronizes on it.
<p>For finer-grained String comparison, refer to
{@link java.text.Collator}.
@param cs
The sequence to compare this {@code String} against
@return {@code true} if this {@code String} represents the same
sequence of char values as the specified sequence, {@code
false} otherwise
@since 1.5
| String::contentEquals | java | google/j2objc | jre_emul/stub_classes/java/java/lang/String.java | https://github.com/google/j2objc/blob/master/jre_emul/stub_classes/java/java/lang/String.java | Apache-2.0 |
public boolean equalsIgnoreCase(String anotherString) {
return false;
} |
Compares this {@code String} to another {@code String}, ignoring case
considerations. Two strings are considered equal ignoring case if they
are of the same length and corresponding characters in the two strings
are equal ignoring case.
<p> Two characters {@code c1} and {@code c2} are considered the same
ignoring case if at least one of the following is true:
<ul>
<li> The two characters are the same (as compared by the
{@code ==} operator)
<li> Calling {@code Character.toLowerCase(Character.toUpperCase(char))}
on each character produces the same result
</ul>
<p>Note that this method does <em>not</em> take locale into account, and
will result in unsatisfactory results for certain locales. The
{@link java.text.Collator} class provides locale-sensitive comparison.
@param anotherString
The {@code String} to compare this {@code String} against
@return {@code true} if the argument is not {@code null} and it
represents an equivalent {@code String} ignoring case; {@code
false} otherwise
@see #equals(Object)
| String::equalsIgnoreCase | java | google/j2objc | jre_emul/stub_classes/java/java/lang/String.java | https://github.com/google/j2objc/blob/master/jre_emul/stub_classes/java/java/lang/String.java | Apache-2.0 |
public int compareTo(String anotherString) {
return 0;
} |
Compares two strings lexicographically.
The comparison is based on the Unicode value of each character in
the strings. The character sequence represented by this
{@code String} object is compared lexicographically to the
character sequence represented by the argument string. The result is
a negative integer if this {@code String} object
lexicographically precedes the argument string. The result is a
positive integer if this {@code String} object lexicographically
follows the argument string. The result is zero if the strings
are equal; {@code compareTo} returns {@code 0} exactly when
the {@link #equals(Object)} method would return {@code true}.
<p>
This is the definition of lexicographic ordering. If two strings are
different, then either they have different characters at some index
that is a valid index for both strings, or their lengths are different,
or both. If they have different characters at one or more index
positions, let <i>k</i> be the smallest such index; then the string
whose character at position <i>k</i> has the smaller value, as
determined by using the {@code <} operator, lexicographically precedes the
other string. In this case, {@code compareTo} returns the
difference of the two character values at position {@code k} in
the two string -- that is, the value:
<blockquote><pre>
this.charAt(k)-anotherString.charAt(k)
</pre></blockquote>
If there is no index position at which they differ, then the shorter
string lexicographically precedes the longer string. In this case,
{@code compareTo} returns the difference of the lengths of the
strings -- that is, the value:
<blockquote><pre>
this.length()-anotherString.length()
</pre></blockquote>
<p>For finer-grained String comparison, refer to
{@link java.text.Collator}.
@param anotherString the {@code String} to be compared.
@return the value {@code 0} if the argument string is equal to
this string; a value less than {@code 0} if this string
is lexicographically less than the string argument; and a
value greater than {@code 0} if this string is
lexicographically greater than the string argument.
| String::compareTo | java | google/j2objc | jre_emul/stub_classes/java/java/lang/String.java | https://github.com/google/j2objc/blob/master/jre_emul/stub_classes/java/java/lang/String.java | Apache-2.0 |
public int compareToIgnoreCase(String str) {
return 0;
} |
Compares two strings lexicographically, ignoring case
differences. This method returns an integer whose sign is that of
calling {@code compareTo} with normalized versions of the strings
where case differences have been eliminated by calling
{@code Character.toLowerCase(Character.toUpperCase(character))} on
each character.
<p>
Note that this method does <em>not</em> take locale into account,
and will result in an unsatisfactory ordering for certain locales.
The {@link java.text.Collator} class provides locale-sensitive comparison.
@param str the {@code String} to be compared.
@return a negative integer, zero, or a positive integer as the
specified String is greater than, equal to, or less
than this String, ignoring case considerations.
@see java.text.Collator
@since 1.2
| CaseInsensitiveComparator::compareToIgnoreCase | java | google/j2objc | jre_emul/stub_classes/java/java/lang/String.java | https://github.com/google/j2objc/blob/master/jre_emul/stub_classes/java/java/lang/String.java | Apache-2.0 |
public boolean regionMatches(int toffset, String other, int ooffset, int len) {
return false;
} |
Tests if two string regions are equal.
<p>
A substring of this {@code String} object is compared to a substring
of the argument other. The result is true if these substrings
represent identical character sequences. The substring of this
{@code String} object to be compared begins at index {@code toffset}
and has length {@code len}. The substring of other to be compared
begins at index {@code ooffset} and has length {@code len}. The
result is {@code false} if and only if at least one of the following
is true:
<ul><li>{@code toffset} is negative.
<li>{@code ooffset} is negative.
<li>{@code toffset+len} is greater than the length of this
{@code String} object.
<li>{@code ooffset+len} is greater than the length of the other
argument.
<li>There is some nonnegative integer <i>k</i> less than {@code len}
such that:
{@code this.charAt(toffset + }<i>k</i>{@code ) != other.charAt(ooffset + }
<i>k</i>{@code )}
</ul>
<p>Note that this method does <em>not</em> take locale into account. The
{@link java.text.Collator} class provides locale-sensitive comparison.
@param toffset the starting offset of the subregion in this string.
@param other the string argument.
@param ooffset the starting offset of the subregion in the string
argument.
@param len the number of characters to compare.
@return {@code true} if the specified subregion of this string
exactly matches the specified subregion of the string argument;
{@code false} otherwise.
| CaseInsensitiveComparator::regionMatches | java | google/j2objc | jre_emul/stub_classes/java/java/lang/String.java | https://github.com/google/j2objc/blob/master/jre_emul/stub_classes/java/java/lang/String.java | Apache-2.0 |
public boolean regionMatches(boolean ignoreCase, int toffset,
String other, int ooffset, int len) {
return true;
} |
Tests if two string regions are equal.
<p>
A substring of this {@code String} object is compared to a substring
of the argument {@code other}. The result is {@code true} if these
substrings represent character sequences that are the same, ignoring
case if and only if {@code ignoreCase} is true. The substring of
this {@code String} object to be compared begins at index
{@code toffset} and has length {@code len}. The substring of
{@code other} to be compared begins at index {@code ooffset} and
has length {@code len}. The result is {@code false} if and only if
at least one of the following is true:
<ul><li>{@code toffset} is negative.
<li>{@code ooffset} is negative.
<li>{@code toffset+len} is greater than the length of this
{@code String} object.
<li>{@code ooffset+len} is greater than the length of the other
argument.
<li>{@code ignoreCase} is {@code false} and there is some nonnegative
integer <i>k</i> less than {@code len} such that:
<blockquote><pre>
this.charAt(toffset+k) != other.charAt(ooffset+k)
</pre></blockquote>
<li>{@code ignoreCase} is {@code true} and there is some nonnegative
integer <i>k</i> less than {@code len} such that:
<blockquote><pre>
Character.toLowerCase(Character.toUpperCase(this.charAt(toffset+k))) !=
Character.toLowerCase(Character.toUpperCase(other.charAt(ooffset+k)))
</pre></blockquote>
</ul>
<p>Note that this method does <em>not</em> take locale into account,
and will result in unsatisfactory results for certain locales when
{@code ignoreCase} is {@code true}. The {@link java.text.Collator} class
provides locale-sensitive comparison.
@param ignoreCase if {@code true}, ignore case when comparing
characters.
@param toffset the starting offset of the subregion in this
string.
@param other the string argument.
@param ooffset the starting offset of the subregion in the string
argument.
@param len the number of characters to compare.
@return {@code true} if the specified subregion of this string
matches the specified subregion of the string argument;
{@code false} otherwise. Whether the matching is exact
or case insensitive depends on the {@code ignoreCase}
argument.
| CaseInsensitiveComparator::regionMatches | java | google/j2objc | jre_emul/stub_classes/java/java/lang/String.java | https://github.com/google/j2objc/blob/master/jre_emul/stub_classes/java/java/lang/String.java | Apache-2.0 |
public boolean startsWith(String prefix, int toffset) {
return false;
} |
Tests if the substring of this string beginning at the
specified index starts with the specified prefix.
@param prefix the prefix.
@param toffset where to begin looking in this string.
@return {@code true} if the character sequence represented by the
argument is a prefix of the substring of this object starting
at index {@code toffset}; {@code false} otherwise.
The result is {@code false} if {@code toffset} is
negative or greater than the length of this
{@code String} object; otherwise the result is the same
as the result of the expression
<pre>
this.substring(toffset).startsWith(prefix)
</pre>
| CaseInsensitiveComparator::startsWith | java | google/j2objc | jre_emul/stub_classes/java/java/lang/String.java | https://github.com/google/j2objc/blob/master/jre_emul/stub_classes/java/java/lang/String.java | Apache-2.0 |
public boolean startsWith(String prefix) {
return false;
} |
Tests if this string starts with the specified prefix.
@param prefix the prefix.
@return {@code true} if the character sequence represented by the
argument is a prefix of the character sequence represented by
this string; {@code false} otherwise.
Note also that {@code true} will be returned if the
argument is an empty string or is equal to this
{@code String} object as determined by the
{@link #equals(Object)} method.
@since 1.0
| CaseInsensitiveComparator::startsWith | java | google/j2objc | jre_emul/stub_classes/java/java/lang/String.java | https://github.com/google/j2objc/blob/master/jre_emul/stub_classes/java/java/lang/String.java | Apache-2.0 |
public boolean endsWith(String suffix) {
return false;
} |
Tests if this string ends with the specified suffix.
@param suffix the suffix.
@return {@code true} if the character sequence represented by the
argument is a suffix of the character sequence represented by
this object; {@code false} otherwise. Note that the
result will be {@code true} if the argument is the
empty string or is equal to this {@code String} object
as determined by the {@link #equals(Object)} method.
| CaseInsensitiveComparator::endsWith | java | google/j2objc | jre_emul/stub_classes/java/java/lang/String.java | https://github.com/google/j2objc/blob/master/jre_emul/stub_classes/java/java/lang/String.java | Apache-2.0 |
public int hashCode() {
return -1;
} |
Returns a hash code for this string. The hash code for a
{@code String} object is computed as
<blockquote><pre>
s[0]*31^(n-1) + s[1]*31^(n-2) + ... + s[n-1]
</pre></blockquote>
using {@code int} arithmetic, where {@code s[i]} is the
<i>i</i>th character of the string, {@code n} is the length of
the string, and {@code ^} indicates exponentiation.
(The hash value of the empty string is zero.)
@return a hash code value for this object.
| CaseInsensitiveComparator::hashCode | java | google/j2objc | jre_emul/stub_classes/java/java/lang/String.java | https://github.com/google/j2objc/blob/master/jre_emul/stub_classes/java/java/lang/String.java | Apache-2.0 |
public int indexOf(int ch) {
return 0;
} |
Returns the index within this string of the first occurrence of
the specified character. If a character with value
{@code ch} occurs in the character sequence represented by
this {@code String} object, then the index (in Unicode
code units) of the first such occurrence is returned. For
values of {@code ch} in the range from 0 to 0xFFFF
(inclusive), this is the smallest value <i>k</i> such that:
<blockquote><pre>
this.charAt(<i>k</i>) == ch
</pre></blockquote>
is true. For other values of {@code ch}, it is the
smallest value <i>k</i> such that:
<blockquote><pre>
this.codePointAt(<i>k</i>) == ch
</pre></blockquote>
is true. In either case, if no such character occurs in this
string, then {@code -1} is returned.
@param ch a character (Unicode code point).
@return the index of the first occurrence of the character in the
character sequence represented by this object, or
{@code -1} if the character does not occur.
| CaseInsensitiveComparator::indexOf | java | google/j2objc | jre_emul/stub_classes/java/java/lang/String.java | https://github.com/google/j2objc/blob/master/jre_emul/stub_classes/java/java/lang/String.java | Apache-2.0 |
public int indexOf(int ch, int fromIndex) {
return 0;
} |
Returns the index within this string of the first occurrence of the
specified character, starting the search at the specified index.
<p>
If a character with value {@code ch} occurs in the
character sequence represented by this {@code String}
object at an index no smaller than {@code fromIndex}, then
the index of the first such occurrence is returned. For values
of {@code ch} in the range from 0 to 0xFFFF (inclusive),
this is the smallest value <i>k</i> such that:
<blockquote><pre>
(this.charAt(<i>k</i>) == ch) {@code &&} (<i>k</i> >= fromIndex)
</pre></blockquote>
is true. For other values of {@code ch}, it is the
smallest value <i>k</i> such that:
<blockquote><pre>
(this.codePointAt(<i>k</i>) == ch) {@code &&} (<i>k</i> >= fromIndex)
</pre></blockquote>
is true. In either case, if no such character occurs in this
string at or after position {@code fromIndex}, then
{@code -1} is returned.
<p>
There is no restriction on the value of {@code fromIndex}. If it
is negative, it has the same effect as if it were zero: this entire
string may be searched. If it is greater than the length of this
string, it has the same effect as if it were equal to the length of
this string: {@code -1} is returned.
<p>All indices are specified in {@code char} values
(Unicode code units).
@param ch a character (Unicode code point).
@param fromIndex the index to start the search from.
@return the index of the first occurrence of the character in the
character sequence represented by this object that is greater
than or equal to {@code fromIndex}, or {@code -1}
if the character does not occur.
| CaseInsensitiveComparator::indexOf | java | google/j2objc | jre_emul/stub_classes/java/java/lang/String.java | https://github.com/google/j2objc/blob/master/jre_emul/stub_classes/java/java/lang/String.java | Apache-2.0 |
public int lastIndexOf(int ch) {
return 0;
} |
Returns the index within this string of the last occurrence of
the specified character. For values of {@code ch} in the
range from 0 to 0xFFFF (inclusive), the index (in Unicode code
units) returned is the largest value <i>k</i> such that:
<blockquote><pre>
this.charAt(<i>k</i>) == ch
</pre></blockquote>
is true. For other values of {@code ch}, it is the
largest value <i>k</i> such that:
<blockquote><pre>
this.codePointAt(<i>k</i>) == ch
</pre></blockquote>
is true. In either case, if no such character occurs in this
string, then {@code -1} is returned. The
{@code String} is searched backwards starting at the last
character.
@param ch a character (Unicode code point).
@return the index of the last occurrence of the character in the
character sequence represented by this object, or
{@code -1} if the character does not occur.
| CaseInsensitiveComparator::lastIndexOf | java | google/j2objc | jre_emul/stub_classes/java/java/lang/String.java | https://github.com/google/j2objc/blob/master/jre_emul/stub_classes/java/java/lang/String.java | Apache-2.0 |
public int lastIndexOf(int ch, int fromIndex) {
return 0;
} |
Returns the index within this string of the last occurrence of
the specified character, searching backward starting at the
specified index. For values of {@code ch} in the range
from 0 to 0xFFFF (inclusive), the index returned is the largest
value <i>k</i> such that:
<blockquote><pre>
(this.charAt(<i>k</i>) == ch) {@code &&} (<i>k</i> <= fromIndex)
</pre></blockquote>
is true. For other values of {@code ch}, it is the
largest value <i>k</i> such that:
<blockquote><pre>
(this.codePointAt(<i>k</i>) == ch) {@code &&} (<i>k</i> <= fromIndex)
</pre></blockquote>
is true. In either case, if no such character occurs in this
string at or before position {@code fromIndex}, then
{@code -1} is returned.
<p>All indices are specified in {@code char} values
(Unicode code units).
@param ch a character (Unicode code point).
@param fromIndex the index to start the search from. There is no
restriction on the value of {@code fromIndex}. If it is
greater than or equal to the length of this string, it has
the same effect as if it were equal to one less than the
length of this string: this entire string may be searched.
If it is negative, it has the same effect as if it were -1:
-1 is returned.
@return the index of the last occurrence of the character in the
character sequence represented by this object that is less
than or equal to {@code fromIndex}, or {@code -1}
if the character does not occur before that point.
| CaseInsensitiveComparator::lastIndexOf | java | google/j2objc | jre_emul/stub_classes/java/java/lang/String.java | https://github.com/google/j2objc/blob/master/jre_emul/stub_classes/java/java/lang/String.java | Apache-2.0 |
public int indexOf(String str) {
return 0;
} |
Returns the index within this string of the first occurrence of the
specified substring.
<p>The returned index is the smallest value {@code k} for which:
<pre>{@code
this.startsWith(str, k)
}</pre>
If no such value of {@code k} exists, then {@code -1} is returned.
@param str the substring to search for.
@return the index of the first occurrence of the specified substring,
or {@code -1} if there is no such occurrence.
| CaseInsensitiveComparator::indexOf | java | google/j2objc | jre_emul/stub_classes/java/java/lang/String.java | https://github.com/google/j2objc/blob/master/jre_emul/stub_classes/java/java/lang/String.java | Apache-2.0 |
public int indexOf(String str, int fromIndex) {
return 0;
} |
Returns the index within this string of the first occurrence of the
specified substring, starting at the specified index.
<p>The returned index is the smallest value {@code k} for which:
<pre>{@code
k >= Math.min(fromIndex, this.length()) &&
this.startsWith(str, k)
}</pre>
If no such value of {@code k} exists, then {@code -1} is returned.
@param str the substring to search for.
@param fromIndex the index from which to start the search.
@return the index of the first occurrence of the specified substring,
starting at the specified index,
or {@code -1} if there is no such occurrence.
| CaseInsensitiveComparator::indexOf | java | google/j2objc | jre_emul/stub_classes/java/java/lang/String.java | https://github.com/google/j2objc/blob/master/jre_emul/stub_classes/java/java/lang/String.java | Apache-2.0 |
static int indexOf(byte[] src, byte srcCoder, int srcCount,
String tgtStr, int fromIndex) {
return 0;
} |
Code shared by String and AbstractStringBuilder to do searches. The
source is the character array being searched, and the target
is the string being searched for.
@param src the characters being searched.
@param srcCoder the coder of the source string.
@param srcCount length of the source string.
@param tgtStr the characters being searched for.
@param fromIndex the index to begin searching from.
| CaseInsensitiveComparator::indexOf | java | google/j2objc | jre_emul/stub_classes/java/java/lang/String.java | https://github.com/google/j2objc/blob/master/jre_emul/stub_classes/java/java/lang/String.java | Apache-2.0 |
public int lastIndexOf(String str) {
return 0;
} |
Returns the index within this string of the last occurrence of the
specified substring. The last occurrence of the empty string ""
is considered to occur at the index value {@code this.length()}.
<p>The returned index is the largest value {@code k} for which:
<pre>{@code
this.startsWith(str, k)
}</pre>
If no such value of {@code k} exists, then {@code -1} is returned.
@param str the substring to search for.
@return the index of the last occurrence of the specified substring,
or {@code -1} if there is no such occurrence.
| CaseInsensitiveComparator::lastIndexOf | java | google/j2objc | jre_emul/stub_classes/java/java/lang/String.java | https://github.com/google/j2objc/blob/master/jre_emul/stub_classes/java/java/lang/String.java | Apache-2.0 |
public int lastIndexOf(String str, int fromIndex) {
return 0;
} |
Returns the index within this string of the last occurrence of the
specified substring, searching backward starting at the specified index.
<p>The returned index is the largest value {@code k} for which:
<pre>{@code
k <= Math.min(fromIndex, this.length()) &&
this.startsWith(str, k)
}</pre>
If no such value of {@code k} exists, then {@code -1} is returned.
@param str the substring to search for.
@param fromIndex the index to start the search from.
@return the index of the last occurrence of the specified substring,
searching backward from the specified index,
or {@code -1} if there is no such occurrence.
| CaseInsensitiveComparator::lastIndexOf | java | google/j2objc | jre_emul/stub_classes/java/java/lang/String.java | https://github.com/google/j2objc/blob/master/jre_emul/stub_classes/java/java/lang/String.java | Apache-2.0 |
public String substring(int beginIndex) {
return null;
} |
Returns a string that is a substring of this string. The
substring begins with the character at the specified index and
extends to the end of this string. <p>
Examples:
<blockquote><pre>
"unhappy".substring(2) returns "happy"
"Harbison".substring(3) returns "bison"
"emptiness".substring(9) returns "" (an empty string)
</pre></blockquote>
@param beginIndex the beginning index, inclusive.
@return the specified substring.
@exception IndexOutOfBoundsException if
{@code beginIndex} is negative or larger than the
length of this {@code String} object.
| CaseInsensitiveComparator::substring | java | google/j2objc | jre_emul/stub_classes/java/java/lang/String.java | https://github.com/google/j2objc/blob/master/jre_emul/stub_classes/java/java/lang/String.java | Apache-2.0 |
public String substring(int beginIndex, int endIndex) {
return null;
} |
Returns a string that is a substring of this string. The
substring begins at the specified {@code beginIndex} and
extends to the character at index {@code endIndex - 1}.
Thus the length of the substring is {@code endIndex-beginIndex}.
<p>
Examples:
<blockquote><pre>
"hamburger".substring(4, 8) returns "urge"
"smiles".substring(1, 5) returns "mile"
</pre></blockquote>
@param beginIndex the beginning index, inclusive.
@param endIndex the ending index, exclusive.
@return the specified substring.
@exception IndexOutOfBoundsException if the
{@code beginIndex} is negative, or
{@code endIndex} is larger than the length of
this {@code String} object, or
{@code beginIndex} is larger than
{@code endIndex}.
| CaseInsensitiveComparator::substring | java | google/j2objc | jre_emul/stub_classes/java/java/lang/String.java | https://github.com/google/j2objc/blob/master/jre_emul/stub_classes/java/java/lang/String.java | Apache-2.0 |
public CharSequence subSequence(int beginIndex, int endIndex) {
return null;
} |
Returns a character sequence that is a subsequence of this sequence.
<p> An invocation of this method of the form
<blockquote><pre>
str.subSequence(begin, end)</pre></blockquote>
behaves in exactly the same way as the invocation
<blockquote><pre>
str.substring(begin, end)</pre></blockquote>
@apiNote
This method is defined so that the {@code String} class can implement
the {@link CharSequence} interface.
@param beginIndex the begin index, inclusive.
@param endIndex the end index, exclusive.
@return the specified subsequence.
@throws IndexOutOfBoundsException
if {@code beginIndex} or {@code endIndex} is negative,
if {@code endIndex} is greater than {@code length()},
or if {@code beginIndex} is greater than {@code endIndex}
@since 1.4
@spec JSR-51
| CaseInsensitiveComparator::subSequence | java | google/j2objc | jre_emul/stub_classes/java/java/lang/String.java | https://github.com/google/j2objc/blob/master/jre_emul/stub_classes/java/java/lang/String.java | Apache-2.0 |
public String replace(char oldChar, char newChar) {
return null;
} |
Returns a string resulting from replacing all occurrences of
{@code oldChar} in this string with {@code newChar}.
<p>
If the character {@code oldChar} does not occur in the
character sequence represented by this {@code String} object,
then a reference to this {@code String} object is returned.
Otherwise, a {@code String} object is returned that
represents a character sequence identical to the character sequence
represented by this {@code String} object, except that every
occurrence of {@code oldChar} is replaced by an occurrence
of {@code newChar}.
<p>
Examples:
<blockquote><pre>
"mesquite in your cellar".replace('e', 'o')
returns "mosquito in your collar"
"the war of baronets".replace('r', 'y')
returns "the way of bayonets"
"sparring with a purple porpoise".replace('p', 't')
returns "starring with a turtle tortoise"
"JonL".replace('q', 'x') returns "JonL" (no change)
</pre></blockquote>
@param oldChar the old character.
@param newChar the new character.
@return a string derived from this string by replacing every
occurrence of {@code oldChar} with {@code newChar}.
| CaseInsensitiveComparator::replace | java | google/j2objc | jre_emul/stub_classes/java/java/lang/String.java | https://github.com/google/j2objc/blob/master/jre_emul/stub_classes/java/java/lang/String.java | Apache-2.0 |
public boolean matches(String regex) {
return false;
} |
Tells whether or not this string matches the given <a
href="../util/regex/Pattern.html#sum">regular expression</a>.
<p> An invocation of this method of the form
<i>str</i>{@code .matches(}<i>regex</i>{@code )} yields exactly the
same result as the expression
<blockquote>
{@link java.util.regex.Pattern}.{@link java.util.regex.Pattern#matches(String,CharSequence)
matches(<i>regex</i>, <i>str</i>)}
</blockquote>
@param regex
the regular expression to which this string is to be matched
@return {@code true} if, and only if, this string matches the
given regular expression
@throws PatternSyntaxException
if the regular expression's syntax is invalid
@see java.util.regex.Pattern
@since 1.4
@spec JSR-51
| CaseInsensitiveComparator::matches | java | google/j2objc | jre_emul/stub_classes/java/java/lang/String.java | https://github.com/google/j2objc/blob/master/jre_emul/stub_classes/java/java/lang/String.java | Apache-2.0 |
public boolean contains(CharSequence s) {
return false;
} |
Returns true if and only if this string contains the specified
sequence of char values.
@param s the sequence to search for
@return true if this string contains {@code s}, false otherwise
@since 1.5
| CaseInsensitiveComparator::contains | java | google/j2objc | jre_emul/stub_classes/java/java/lang/String.java | https://github.com/google/j2objc/blob/master/jre_emul/stub_classes/java/java/lang/String.java | Apache-2.0 |
public String replaceFirst(String regex, String replacement) {
return null;
} |
Replaces the first substring of this string that matches the given <a
href="../util/regex/Pattern.html#sum">regular expression</a> with the
given replacement.
<p> An invocation of this method of the form
<i>str</i>{@code .replaceFirst(}<i>regex</i>{@code ,} <i>repl</i>{@code )}
yields exactly the same result as the expression
<blockquote>
<code>
{@link java.util.regex.Pattern}.{@link
java.util.regex.Pattern#compile compile}(<i>regex</i>).{@link
java.util.regex.Pattern#matcher(java.lang.CharSequence) matcher}(<i>str</i>).{@link
java.util.regex.Matcher#replaceFirst replaceFirst}(<i>repl</i>)
</code>
</blockquote>
<p>
Note that backslashes ({@code \}) and dollar signs ({@code $}) in the
replacement string may cause the results to be different than if it were
being treated as a literal replacement string; see
{@link java.util.regex.Matcher#replaceFirst}.
Use {@link java.util.regex.Matcher#quoteReplacement} to suppress the special
meaning of these characters, if desired.
@param regex
the regular expression to which this string is to be matched
@param replacement
the string to be substituted for the first match
@return The resulting {@code String}
@throws PatternSyntaxException
if the regular expression's syntax is invalid
@see java.util.regex.Pattern
@since 1.4
@spec JSR-51
| CaseInsensitiveComparator::replaceFirst | java | google/j2objc | jre_emul/stub_classes/java/java/lang/String.java | https://github.com/google/j2objc/blob/master/jre_emul/stub_classes/java/java/lang/String.java | Apache-2.0 |
public String replaceAll(String regex, String replacement) {
return null;
} |
Replaces each substring of this string that matches the given <a
href="../util/regex/Pattern.html#sum">regular expression</a> with the
given replacement.
<p> An invocation of this method of the form
<i>str</i>{@code .replaceAll(}<i>regex</i>{@code ,} <i>repl</i>{@code )}
yields exactly the same result as the expression
<blockquote>
<code>
{@link java.util.regex.Pattern}.{@link
java.util.regex.Pattern#compile compile}(<i>regex</i>).{@link
java.util.regex.Pattern#matcher(java.lang.CharSequence) matcher}(<i>str</i>).{@link
java.util.regex.Matcher#replaceAll replaceAll}(<i>repl</i>)
</code>
</blockquote>
<p>
Note that backslashes ({@code \}) and dollar signs ({@code $}) in the
replacement string may cause the results to be different than if it were
being treated as a literal replacement string; see
{@link java.util.regex.Matcher#replaceAll Matcher.replaceAll}.
Use {@link java.util.regex.Matcher#quoteReplacement} to suppress the special
meaning of these characters, if desired.
@param regex
the regular expression to which this string is to be matched
@param replacement
the string to be substituted for each match
@return The resulting {@code String}
@throws PatternSyntaxException
if the regular expression's syntax is invalid
@see java.util.regex.Pattern
@since 1.4
@spec JSR-51
| CaseInsensitiveComparator::replaceAll | java | google/j2objc | jre_emul/stub_classes/java/java/lang/String.java | https://github.com/google/j2objc/blob/master/jre_emul/stub_classes/java/java/lang/String.java | Apache-2.0 |
public String replace(CharSequence target, CharSequence replacement) {
return null;
} |
Replaces each substring of this string that matches the literal target
sequence with the specified literal replacement sequence. The
replacement proceeds from the beginning of the string to the end, for
example, replacing "aa" with "b" in the string "aaa" will result in
"ba" rather than "ab".
@param target The sequence of char values to be replaced
@param replacement The replacement sequence of char values
@return The resulting string
@since 1.5
| CaseInsensitiveComparator::replace | java | google/j2objc | jre_emul/stub_classes/java/java/lang/String.java | https://github.com/google/j2objc/blob/master/jre_emul/stub_classes/java/java/lang/String.java | Apache-2.0 |
public String[] split(String regex, int limit) {
return null;
} |
Splits this string around matches of the given
<a href="../util/regex/Pattern.html#sum">regular expression</a>.
<p> The array returned by this method contains each substring of this
string that is terminated by another substring that matches the given
expression or is terminated by the end of the string. The substrings in
the array are in the order in which they occur in this string. If the
expression does not match any part of the input then the resulting array
has just one element, namely this string.
<p> When there is a positive-width match at the beginning of this
string then an empty leading substring is included at the beginning
of the resulting array. A zero-width match at the beginning however
never produces such empty leading substring.
<p> The {@code limit} parameter controls the number of times the
pattern is applied and therefore affects the length of the resulting
array.
<ul>
<li><p>
If the <i>limit</i> is positive then the pattern will be applied
at most <i>limit</i> - 1 times, the array's length will be
no greater than <i>limit</i>, and the array's last entry will contain
all input beyond the last matched delimiter.</p></li>
<li><p>
If the <i>limit</i> is zero then the pattern will be applied as
many times as possible, the array can have any length, and trailing
empty strings will be discarded.</p></li>
<li><p>
If the <i>limit</i> is negative then the pattern will be applied
as many times as possible and the array can have any length.</p></li>
</ul>
<p> The string {@code "boo:and:foo"}, for example, yields the
following results with these parameters:
<blockquote><table class="plain">
<caption style="display:none">Split example showing regex, limit, and result</caption>
<thead>
<tr>
<th scope="col">Regex</th>
<th scope="col">Limit</th>
<th scope="col">Result</th>
</tr>
</thead>
<tbody>
<tr><th scope="row" rowspan="3" style="font-weight:normal">:</th>
<th scope="row" style="font-weight:normal; text-align:right; padding-right:1em">2</th>
<td>{@code { "boo", "and:foo" }}</td></tr>
<tr><!-- : -->
<th scope="row" style="font-weight:normal; text-align:right; padding-right:1em">5</th>
<td>{@code { "boo", "and", "foo" }}</td></tr>
<tr><!-- : -->
<th scope="row" style="font-weight:normal; text-align:right; padding-right:1em">-2</th>
<td>{@code { "boo", "and", "foo" }}</td></tr>
<tr><th scope="row" rowspan="3" style="font-weight:normal">o</th>
<th scope="row" style="font-weight:normal; text-align:right; padding-right:1em">5</th>
<td>{@code { "b", "", ":and:f", "", "" }}</td></tr>
<tr><!-- o -->
<th scope="row" style="font-weight:normal; text-align:right; padding-right:1em">-2</th>
<td>{@code { "b", "", ":and:f", "", "" }}</td></tr>
<tr><!-- o -->
<th scope="row" style="font-weight:normal; text-align:right; padding-right:1em">0</th>
<td>{@code { "b", "", ":and:f" }}</td></tr>
</tbody>
</table></blockquote>
<p> An invocation of this method of the form
<i>str.</i>{@code split(}<i>regex</i>{@code ,} <i>n</i>{@code )}
yields the same result as the expression
<blockquote>
<code>
{@link java.util.regex.Pattern}.{@link
java.util.regex.Pattern#compile compile}(<i>regex</i>).{@link
java.util.regex.Pattern#split(java.lang.CharSequence,int) split}(<i>str</i>, <i>n</i>)
</code>
</blockquote>
@param regex
the delimiting regular expression
@param limit
the result threshold, as described above
@return the array of strings computed by splitting this string
around matches of the given regular expression
@throws PatternSyntaxException
if the regular expression's syntax is invalid
@see java.util.regex.Pattern
@since 1.4
@spec JSR-51
| CaseInsensitiveComparator::split | java | google/j2objc | jre_emul/stub_classes/java/java/lang/String.java | https://github.com/google/j2objc/blob/master/jre_emul/stub_classes/java/java/lang/String.java | Apache-2.0 |
public String[] split(String regex) {
return null;
} |
Splits this string around matches of the given <a
href="../util/regex/Pattern.html#sum">regular expression</a>.
<p> This method works as if by invoking the two-argument {@link
#split(String, int) split} method with the given expression and a limit
argument of zero. Trailing empty strings are therefore not included in
the resulting array.
<p> The string {@code "boo:and:foo"}, for example, yields the following
results with these expressions:
<blockquote><table class="plain">
<caption style="display:none">Split examples showing regex and result</caption>
<thead>
<tr>
<th scope="col">Regex</th>
<th scope="col">Result</th>
</tr>
</thead>
<tbody>
<tr><th scope="row" style="text-weight:normal">:</th>
<td>{@code { "boo", "and", "foo" }}</td></tr>
<tr><th scope="row" style="text-weight:normal">o</th>
<td>{@code { "b", "", ":and:f" }}</td></tr>
</tbody>
</table></blockquote>
@param regex
the delimiting regular expression
@return the array of strings computed by splitting this string
around matches of the given regular expression
@throws PatternSyntaxException
if the regular expression's syntax is invalid
@see java.util.regex.Pattern
@since 1.4
@spec JSR-51
| CaseInsensitiveComparator::split | java | google/j2objc | jre_emul/stub_classes/java/java/lang/String.java | https://github.com/google/j2objc/blob/master/jre_emul/stub_classes/java/java/lang/String.java | Apache-2.0 |
public static String join(CharSequence delimiter, CharSequence... elements) {
return null;
} |
Returns a new String composed of copies of the
{@code CharSequence elements} joined together with a copy of
the specified {@code delimiter}.
<blockquote>For example,
<pre>{@code
String message = String.join("-", "Java", "is", "cool");
// message returned is: "Java-is-cool"
}</pre></blockquote>
Note that if an element is null, then {@code "null"} is added.
@param delimiter the delimiter that separates each element
@param elements the elements to join together.
@return a new {@code String} that is composed of the {@code elements}
separated by the {@code delimiter}
@throws NullPointerException If {@code delimiter} or {@code elements}
is {@code null}
@see java.util.StringJoiner
@since 1.8
| CaseInsensitiveComparator::join | java | google/j2objc | jre_emul/stub_classes/java/java/lang/String.java | https://github.com/google/j2objc/blob/master/jre_emul/stub_classes/java/java/lang/String.java | Apache-2.0 |
public static String join(CharSequence delimiter,
Iterable<? extends CharSequence> elements) {
return null;
} |
Returns a new {@code String} composed of copies of the
{@code CharSequence elements} joined together with a copy of the
specified {@code delimiter}.
<blockquote>For example,
<pre>{@code
List<String> strings = List.of("Java", "is", "cool");
String message = String.join(" ", strings);
//message returned is: "Java is cool"
Set<String> strings =
new LinkedHashSet<>(List.of("Java", "is", "very", "cool"));
String message = String.join("-", strings);
//message returned is: "Java-is-very-cool"
}</pre></blockquote>
Note that if an individual element is {@code null}, then {@code "null"} is added.
@param delimiter a sequence of characters that is used to separate each
of the {@code elements} in the resulting {@code String}
@param elements an {@code Iterable} that will have its {@code elements}
joined together.
@return a new {@code String} that is composed from the {@code elements}
argument
@throws NullPointerException If {@code delimiter} or {@code elements}
is {@code null}
@see #join(CharSequence,CharSequence...)
@see java.util.StringJoiner
@since 1.8
| CaseInsensitiveComparator::join | java | google/j2objc | jre_emul/stub_classes/java/java/lang/String.java | https://github.com/google/j2objc/blob/master/jre_emul/stub_classes/java/java/lang/String.java | Apache-2.0 |
public String toLowerCase(java.util.Locale locale) {
return null;
} |
Converts all of the characters in this {@code String} to lower
case using the rules of the given {@code Locale}. Case mapping is based
on the Unicode Standard version specified by the {@link java.lang.Character Character}
class. Since case mappings are not always 1:1 char mappings, the resulting
{@code String} may be a different length than the original {@code String}.
<p>
Examples of lowercase mappings are in the following table:
<table class="plain">
<caption style="display:none">Lowercase mapping examples showing language code of locale, upper case, lower case, and description</caption>
<thead>
<tr>
<th scope="col">Language Code of Locale</th>
<th scope="col">Upper Case</th>
<th scope="col">Lower Case</th>
<th scope="col">Description</th>
</tr>
</thead>
<tbody>
<tr>
<td>tr (Turkish)</td>
<th scope="row" style="font-weight:normal; text-align:left">\u0130</th>
<td>\u0069</td>
<td>capital letter I with dot above -> small letter i</td>
</tr>
<tr>
<td>tr (Turkish)</td>
<th scope="row" style="font-weight:normal; text-align:left">\u0049</th>
<td>\u0131</td>
<td>capital letter I -> small letter dotless i </td>
</tr>
<tr>
<td>(all)</td>
<th scope="row" style="font-weight:normal; text-align:left">French Fries</th>
<td>french fries</td>
<td>lowercased all chars in String</td>
</tr>
<tr>
<td>(all)</td>
<th scope="row" style="font-weight:normal; text-align:left">
ΙΧΘΥΣ</th>
<td>ιχθυσ</td>
<td>lowercased all chars in String</td>
</tr>
</tbody>
</table>
@param locale use the case transformation rules for this locale
@return the {@code String}, converted to lowercase.
@see java.lang.String#toLowerCase()
@see java.lang.String#toUpperCase()
@see java.lang.String#toUpperCase(Locale)
@since 1.1
| CaseInsensitiveComparator::toLowerCase | java | google/j2objc | jre_emul/stub_classes/java/java/lang/String.java | https://github.com/google/j2objc/blob/master/jre_emul/stub_classes/java/java/lang/String.java | Apache-2.0 |
public String toLowerCase() {
return null;
} |
Converts all of the characters in this {@code String} to lower
case using the rules of the default locale. This is equivalent to calling
{@code toLowerCase(Locale.getDefault())}.
<p>
<b>Note:</b> This method is locale sensitive, and may produce unexpected
results if used for strings that are intended to be interpreted locale
independently.
Examples are programming language identifiers, protocol keys, and HTML
tags.
For instance, {@code "TITLE".toLowerCase()} in a Turkish locale
returns {@code "t\u005Cu0131tle"}, where '\u005Cu0131' is the
LATIN SMALL LETTER DOTLESS I character.
To obtain correct results for locale insensitive strings, use
{@code toLowerCase(Locale.ROOT)}.
@return the {@code String}, converted to lowercase.
@see java.lang.String#toLowerCase(Locale)
| CaseInsensitiveComparator::toLowerCase | java | google/j2objc | jre_emul/stub_classes/java/java/lang/String.java | https://github.com/google/j2objc/blob/master/jre_emul/stub_classes/java/java/lang/String.java | Apache-2.0 |
public String toUpperCase(java.util.Locale locale) {
return null;
} |
Converts all of the characters in this {@code String} to upper
case using the rules of the given {@code Locale}. Case mapping is based
on the Unicode Standard version specified by the {@link java.lang.Character Character}
class. Since case mappings are not always 1:1 char mappings, the resulting
{@code String} may be a different length than the original {@code String}.
<p>
Examples of locale-sensitive and 1:M case mappings are in the following table.
<table class="plain">
<caption style="display:none">Examples of locale-sensitive and 1:M case mappings. Shows Language code of locale, lower case, upper case, and description.</caption>
<thead>
<tr>
<th scope="col">Language Code of Locale</th>
<th scope="col">Lower Case</th>
<th scope="col">Upper Case</th>
<th scope="col">Description</th>
</tr>
</thead>
<tbody>
<tr>
<td>tr (Turkish)</td>
<th scope="row" style="font-weight:normal; text-align:left">\u0069</th>
<td>\u0130</td>
<td>small letter i -> capital letter I with dot above</td>
</tr>
<tr>
<td>tr (Turkish)</td>
<th scope="row" style="font-weight:normal; text-align:left">\u0131</th>
<td>\u0049</td>
<td>small letter dotless i -> capital letter I</td>
</tr>
<tr>
<td>(all)</td>
<th scope="row" style="font-weight:normal; text-align:left">\u00df</th>
<td>\u0053 \u0053</td>
<td>small letter sharp s -> two letters: SS</td>
</tr>
<tr>
<td>(all)</td>
<th scope="row" style="font-weight:normal; text-align:left">Fahrvergnügen</th>
<td>FAHRVERGNÜGEN</td>
<td></td>
</tr>
</tbody>
</table>
@param locale use the case transformation rules for this locale
@return the {@code String}, converted to uppercase.
@see java.lang.String#toUpperCase()
@see java.lang.String#toLowerCase()
@see java.lang.String#toLowerCase(Locale)
@since 1.1
| CaseInsensitiveComparator::toUpperCase | java | google/j2objc | jre_emul/stub_classes/java/java/lang/String.java | https://github.com/google/j2objc/blob/master/jre_emul/stub_classes/java/java/lang/String.java | Apache-2.0 |
public String toUpperCase() {
return null;
} |
Converts all of the characters in this {@code String} to upper
case using the rules of the default locale. This method is equivalent to
{@code toUpperCase(Locale.getDefault())}.
<p>
<b>Note:</b> This method is locale sensitive, and may produce unexpected
results if used for strings that are intended to be interpreted locale
independently.
Examples are programming language identifiers, protocol keys, and HTML
tags.
For instance, {@code "title".toUpperCase()} in a Turkish locale
returns {@code "T\u005Cu0130TLE"}, where '\u005Cu0130' is the
LATIN CAPITAL LETTER I WITH DOT ABOVE character.
To obtain correct results for locale insensitive strings, use
{@code toUpperCase(Locale.ROOT)}.
@return the {@code String}, converted to uppercase.
@see java.lang.String#toUpperCase(Locale)
| CaseInsensitiveComparator::toUpperCase | java | google/j2objc | jre_emul/stub_classes/java/java/lang/String.java | https://github.com/google/j2objc/blob/master/jre_emul/stub_classes/java/java/lang/String.java | Apache-2.0 |
public String trim() {
return null;
} |
Returns a string whose value is this string, with all leading
and trailing space removed, where space is defined
as any character whose codepoint is less than or equal to
{@code 'U+0020'} (the space character).
<p>
If this {@code String} object represents an empty character
sequence, or the first and last characters of character sequence
represented by this {@code String} object both have codes
that are not space (as defined above), then a
reference to this {@code String} object is returned.
<p>
Otherwise, if all characters in this string are space (as
defined above), then a {@code String} object representing an
empty string is returned.
<p>
Otherwise, let <i>k</i> be the index of the first character in the
string whose code is not a space (as defined above) and let
<i>m</i> be the index of the last character in the string whose code
is not a space (as defined above). A {@code String}
object is returned, representing the substring of this string that
begins with the character at index <i>k</i> and ends with the
character at index <i>m</i>-that is, the result of
{@code this.substring(k, m + 1)}.
<p>
This method may be used to trim space (as defined above) from
the beginning and end of a string.
@return a string whose value is this string, with all leading
and trailing space removed, or this string if it
has no leading or trailing space.
| CaseInsensitiveComparator::trim | java | google/j2objc | jre_emul/stub_classes/java/java/lang/String.java | https://github.com/google/j2objc/blob/master/jre_emul/stub_classes/java/java/lang/String.java | Apache-2.0 |
public String strip() {
return null;
} |
Returns a string whose value is this string, with all leading
and trailing {@link Character#isWhitespace(int) white space}
removed.
<p>
If this {@code String} object represents an empty string,
or if all code points in this string are
{@link Character#isWhitespace(int) white space}, then an empty string
is returned.
<p>
Otherwise, returns a substring of this string beginning with the first
code point that is not a {@link Character#isWhitespace(int) white space}
up to and including the last code point that is not a
{@link Character#isWhitespace(int) white space}.
<p>
This method may be used to strip
{@link Character#isWhitespace(int) white space} from
the beginning and end of a string.
@return a string whose value is this string, with all leading
and trailing white space removed
@see Character#isWhitespace(int)
@since 11
| CaseInsensitiveComparator::strip | java | google/j2objc | jre_emul/stub_classes/java/java/lang/String.java | https://github.com/google/j2objc/blob/master/jre_emul/stub_classes/java/java/lang/String.java | Apache-2.0 |
public String stripLeading() {
return null;
} |
Returns a string whose value is this string, with all leading
{@link Character#isWhitespace(int) white space} removed.
<p>
If this {@code String} object represents an empty string,
or if all code points in this string are
{@link Character#isWhitespace(int) white space}, then an empty string
is returned.
<p>
Otherwise, returns a substring of this string beginning with the first
code point that is not a {@link Character#isWhitespace(int) white space}
up to to and including the last code point of this string.
<p>
This method may be used to trim
{@link Character#isWhitespace(int) white space} from
the beginning of a string.
@return a string whose value is this string, with all leading white
space removed
@see Character#isWhitespace(int)
@since 11
| CaseInsensitiveComparator::stripLeading | java | google/j2objc | jre_emul/stub_classes/java/java/lang/String.java | https://github.com/google/j2objc/blob/master/jre_emul/stub_classes/java/java/lang/String.java | Apache-2.0 |
public String stripTrailing() {
return null;
} |
Returns a string whose value is this string, with all trailing
{@link Character#isWhitespace(int) white space} removed.
<p>
If this {@code String} object represents an empty string,
or if all characters in this string are
{@link Character#isWhitespace(int) white space}, then an empty string
is returned.
<p>
Otherwise, returns a substring of this string beginning with the first
code point of this string up to and including the last code point
that is not a {@link Character#isWhitespace(int) white space}.
<p>
This method may be used to trim
{@link Character#isWhitespace(int) white space} from
the end of a string.
@return a string whose value is this string, with all trailing white
space removed
@see Character#isWhitespace(int)
@since 11
| CaseInsensitiveComparator::stripTrailing | java | google/j2objc | jre_emul/stub_classes/java/java/lang/String.java | https://github.com/google/j2objc/blob/master/jre_emul/stub_classes/java/java/lang/String.java | Apache-2.0 |
public boolean isBlank() {
return false;
} |
Returns {@code true} if the string is empty or contains only
{@link Character#isWhitespace(int) white space} codepoints,
otherwise {@code false}.
@return {@code true} if the string is empty or contains only
{@link Character#isWhitespace(int) white space} codepoints,
otherwise {@code false}
@see Character#isWhitespace(int)
@since 11
| CaseInsensitiveComparator::isBlank | java | google/j2objc | jre_emul/stub_classes/java/java/lang/String.java | https://github.com/google/j2objc/blob/master/jre_emul/stub_classes/java/java/lang/String.java | Apache-2.0 |
public String toString() {
return null;
} |
This object (which is already a string!) is itself returned.
@return the string itself.
| CaseInsensitiveComparator::toString | java | google/j2objc | jre_emul/stub_classes/java/java/lang/String.java | https://github.com/google/j2objc/blob/master/jre_emul/stub_classes/java/java/lang/String.java | Apache-2.0 |
public char[] toCharArray() {
return null;
} |
Converts this string to a new character array.
@return a newly allocated character array whose length is the length
of this string and whose contents are initialized to contain
the character sequence represented by this string.
| CaseInsensitiveComparator::toCharArray | java | google/j2objc | jre_emul/stub_classes/java/java/lang/String.java | https://github.com/google/j2objc/blob/master/jre_emul/stub_classes/java/java/lang/String.java | Apache-2.0 |
public static String format(String format, Object... args) {
return null;
} |
Returns a formatted string using the specified format string and
arguments.
<p> The locale always used is the one returned by {@link
java.util.Locale#getDefault(java.util.Locale.Category)
Locale.getDefault(Locale.Category)} with
{@link java.util.Locale.Category#FORMAT FORMAT} category specified.
@param format
A <a href="../util/Formatter.html#syntax">format string</a>
@param args
Arguments referenced by the format specifiers in the format
string. If there are more arguments than format specifiers, the
extra arguments are ignored. The number of arguments is
variable and may be zero. The maximum number of arguments is
limited by the maximum dimension of a Java array as defined by
<cite>The Java™ Virtual Machine Specification</cite>.
The behaviour on a
{@code null} argument depends on the <a
href="../util/Formatter.html#syntax">conversion</a>.
@throws java.util.IllegalFormatException
If a format string contains an illegal syntax, a format
specifier that is incompatible with the given arguments,
insufficient arguments given the format string, or other
illegal conditions. For specification of all possible
formatting errors, see the <a
href="../util/Formatter.html#detail">Details</a> section of the
formatter class specification.
@return A formatted string
@see java.util.Formatter
@since 1.5
| CaseInsensitiveComparator::format | java | google/j2objc | jre_emul/stub_classes/java/java/lang/String.java | https://github.com/google/j2objc/blob/master/jre_emul/stub_classes/java/java/lang/String.java | Apache-2.0 |
public static String format(java.util.Locale l, String format, Object... args) {
return null;
} |
Returns a formatted string using the specified locale, format string,
and arguments.
@param l
The {@linkplain java.util.Locale locale} to apply during
formatting. If {@code l} is {@code null} then no localization
is applied.
@param format
A <a href="../util/Formatter.html#syntax">format string</a>
@param args
Arguments referenced by the format specifiers in the format
string. If there are more arguments than format specifiers, the
extra arguments are ignored. The number of arguments is
variable and may be zero. The maximum number of arguments is
limited by the maximum dimension of a Java array as defined by
<cite>The Java™ Virtual Machine Specification</cite>.
The behaviour on a
{@code null} argument depends on the
<a href="../util/Formatter.html#syntax">conversion</a>.
@throws java.util.IllegalFormatException
If a format string contains an illegal syntax, a format
specifier that is incompatible with the given arguments,
insufficient arguments given the format string, or other
illegal conditions. For specification of all possible
formatting errors, see the <a
href="../util/Formatter.html#detail">Details</a> section of the
formatter class specification
@return A formatted string
@see java.util.Formatter
@since 1.5
| CaseInsensitiveComparator::format | java | google/j2objc | jre_emul/stub_classes/java/java/lang/String.java | https://github.com/google/j2objc/blob/master/jre_emul/stub_classes/java/java/lang/String.java | Apache-2.0 |
public static String valueOf(Object obj) {
return null;
} |
Returns the string representation of the {@code Object} argument.
@param obj an {@code Object}.
@return if the argument is {@code null}, then a string equal to
{@code "null"}; otherwise, the value of
{@code obj.toString()} is returned.
@see java.lang.Object#toString()
| CaseInsensitiveComparator::valueOf | java | google/j2objc | jre_emul/stub_classes/java/java/lang/String.java | https://github.com/google/j2objc/blob/master/jre_emul/stub_classes/java/java/lang/String.java | Apache-2.0 |
public static String valueOf(char data[]) {
return null;
} |
Returns the string representation of the {@code char} array
argument. The contents of the character array are copied; subsequent
modification of the character array does not affect the returned
string.
@param data the character array.
@return a {@code String} that contains the characters of the
character array.
| CaseInsensitiveComparator::valueOf | java | google/j2objc | jre_emul/stub_classes/java/java/lang/String.java | https://github.com/google/j2objc/blob/master/jre_emul/stub_classes/java/java/lang/String.java | Apache-2.0 |
public static String valueOf(char data[], int offset, int count) {
return null;
} |
Returns the string representation of a specific subarray of the
{@code char} array argument.
<p>
The {@code offset} argument is the index of the first
character of the subarray. The {@code count} argument
specifies the length of the subarray. The contents of the subarray
are copied; subsequent modification of the character array does not
affect the returned string.
@param data the character array.
@param offset initial offset of the subarray.
@param count length of the subarray.
@return a {@code String} that contains the characters of the
specified subarray of the character array.
@exception IndexOutOfBoundsException if {@code offset} is
negative, or {@code count} is negative, or
{@code offset+count} is larger than
{@code data.length}.
| CaseInsensitiveComparator::valueOf | java | google/j2objc | jre_emul/stub_classes/java/java/lang/String.java | https://github.com/google/j2objc/blob/master/jre_emul/stub_classes/java/java/lang/String.java | Apache-2.0 |
public static String copyValueOf(char data[], int offset, int count) {
return null;
} |
Equivalent to {@link #valueOf(char[], int, int)}.
@param data the character array.
@param offset initial offset of the subarray.
@param count length of the subarray.
@return a {@code String} that contains the characters of the
specified subarray of the character array.
@exception IndexOutOfBoundsException if {@code offset} is
negative, or {@code count} is negative, or
{@code offset+count} is larger than
{@code data.length}.
| CaseInsensitiveComparator::copyValueOf | java | google/j2objc | jre_emul/stub_classes/java/java/lang/String.java | https://github.com/google/j2objc/blob/master/jre_emul/stub_classes/java/java/lang/String.java | Apache-2.0 |
public static String copyValueOf(char data[]) {
return null;
} |
Equivalent to {@link #valueOf(char[])}.
@param data the character array.
@return a {@code String} that contains the characters of the
character array.
| CaseInsensitiveComparator::copyValueOf | java | google/j2objc | jre_emul/stub_classes/java/java/lang/String.java | https://github.com/google/j2objc/blob/master/jre_emul/stub_classes/java/java/lang/String.java | Apache-2.0 |
public static String valueOf(boolean b) {
return null;
} |
Returns the string representation of the {@code boolean} argument.
@param b a {@code boolean}.
@return if the argument is {@code true}, a string equal to
{@code "true"} is returned; otherwise, a string equal to
{@code "false"} is returned.
| CaseInsensitiveComparator::valueOf | java | google/j2objc | jre_emul/stub_classes/java/java/lang/String.java | https://github.com/google/j2objc/blob/master/jre_emul/stub_classes/java/java/lang/String.java | Apache-2.0 |
public static String valueOf(char c) {
return null;
} |
Returns the string representation of the {@code char}
argument.
@param c a {@code char}.
@return a string of length {@code 1} containing
as its single character the argument {@code c}.
| CaseInsensitiveComparator::valueOf | java | google/j2objc | jre_emul/stub_classes/java/java/lang/String.java | https://github.com/google/j2objc/blob/master/jre_emul/stub_classes/java/java/lang/String.java | Apache-2.0 |
public static String valueOf(int i) {
return null;
} |
Returns the string representation of the {@code int} argument.
<p>
The representation is exactly the one returned by the
{@code Integer.toString} method of one argument.
@param i an {@code int}.
@return a string representation of the {@code int} argument.
@see java.lang.Integer#toString(int, int)
| CaseInsensitiveComparator::valueOf | java | google/j2objc | jre_emul/stub_classes/java/java/lang/String.java | https://github.com/google/j2objc/blob/master/jre_emul/stub_classes/java/java/lang/String.java | Apache-2.0 |
public static String valueOf(long l) {
return null;
} |
Returns the string representation of the {@code long} argument.
<p>
The representation is exactly the one returned by the
{@code Long.toString} method of one argument.
@param l a {@code long}.
@return a string representation of the {@code long} argument.
@see java.lang.Long#toString(long)
| CaseInsensitiveComparator::valueOf | java | google/j2objc | jre_emul/stub_classes/java/java/lang/String.java | https://github.com/google/j2objc/blob/master/jre_emul/stub_classes/java/java/lang/String.java | Apache-2.0 |
public static String valueOf(float f) {
return null;
} |
Returns the string representation of the {@code float} argument.
<p>
The representation is exactly the one returned by the
{@code Float.toString} method of one argument.
@param f a {@code float}.
@return a string representation of the {@code float} argument.
@see java.lang.Float#toString(float)
| CaseInsensitiveComparator::valueOf | java | google/j2objc | jre_emul/stub_classes/java/java/lang/String.java | https://github.com/google/j2objc/blob/master/jre_emul/stub_classes/java/java/lang/String.java | Apache-2.0 |
public static String valueOf(double d) {
return null;
} |
Returns the string representation of the {@code double} argument.
<p>
The representation is exactly the one returned by the
{@code Double.toString} method of one argument.
@param d a {@code double}.
@return a string representation of the {@code double} argument.
@see java.lang.Double#toString(double)
| CaseInsensitiveComparator::valueOf | java | google/j2objc | jre_emul/stub_classes/java/java/lang/String.java | https://github.com/google/j2objc/blob/master/jre_emul/stub_classes/java/java/lang/String.java | Apache-2.0 |
public String intern() {
return null;
} |
Returns a canonical representation for the string object.
<p>
A pool of strings, initially empty, is maintained privately by the
class {@code String}.
<p>
When the intern method is invoked, if the pool already contains a
string equal to this {@code String} object as determined by
the {@link #equals(Object)} method, then the string from the pool is
returned. Otherwise, this {@code String} object is added to the
pool and a reference to this {@code String} object is returned.
<p>
It follows that for any two strings {@code s} and {@code t},
{@code s.intern() == t.intern()} is {@code true}
if and only if {@code s.equals(t)} is {@code true}.
<p>
All literal strings and string-valued constant expressions are
interned. String literals are defined in section 3.10.5 of the
<cite>The Java™ Language Specification</cite>.
@return a string that has the same contents as this string, but is
guaranteed to be from a pool of unique strings.
@jls 3.10.5 String Literals
| CaseInsensitiveComparator::intern | java | google/j2objc | jre_emul/stub_classes/java/java/lang/String.java | https://github.com/google/j2objc/blob/master/jre_emul/stub_classes/java/java/lang/String.java | Apache-2.0 |
public String repeat(int count) {
return null;
} |
Returns a string whose value is the concatenation of this
string repeated {@code count} times.
<p>
If this string is empty or count is zero then the empty
string is returned.
@param count number of times to repeat
@return A string composed of this string repeated
{@code count} times or the empty string if this
string is empty or count is zero
@throws IllegalArgumentException if the {@code count} is
negative.
@since 11
| CaseInsensitiveComparator::repeat | java | google/j2objc | jre_emul/stub_classes/java/java/lang/String.java | https://github.com/google/j2objc/blob/master/jre_emul/stub_classes/java/java/lang/String.java | Apache-2.0 |
public Object() {} |
Constructs a new instance of {@code Object}.
| Object::Object | java | google/j2objc | jre_emul/stub_classes/java/java/lang/Object.java | https://github.com/google/j2objc/blob/master/jre_emul/stub_classes/java/java/lang/Object.java | Apache-2.0 |
public final Class<?> getClass() {
return null;
} |
Returns the unique instance of {@link Class} that represents this
object's class. Note that {@code getClass()} is a special case in that it
actually returns {@code Class<? extends Foo>} where {@code Foo} is the
erasure of the type of the expression {@code getClass()} was called upon.
<p>
As an example, the following code actually compiles, although one might
think it shouldn't:
<p>
<pre>{@code
List<Integer> l = new ArrayList<Integer>();
Class<? extends List> c = l.getClass();}</pre>
@return this object's {@code Class} instance.
| Object::getClass | java | google/j2objc | jre_emul/stub_classes/java/java/lang/Object.java | https://github.com/google/j2objc/blob/master/jre_emul/stub_classes/java/java/lang/Object.java | Apache-2.0 |
public int hashCode() {
return 0;
} |
Returns an integer hash code for this object. By contract, any two
objects for which {@link #equals} returns {@code true} must return
the same hash code value. This means that subclasses of {@code Object}
usually override both methods or neither method.
<p>Note that hash values must not change over time unless information used in equals
comparisons also changes.
<p>See <a href="{@docRoot}reference/java/lang/Object.html#writing_hashCode">Writing a correct
{@code hashCode} method</a>
if you intend implementing your own {@code hashCode} method.
@return this object's hash code.
@see #equals
| Object::hashCode | java | google/j2objc | jre_emul/stub_classes/java/java/lang/Object.java | https://github.com/google/j2objc/blob/master/jre_emul/stub_classes/java/java/lang/Object.java | Apache-2.0 |
public boolean equals(Object obj) {
return false;
} |
Compares this instance with the specified object and indicates if they
are equal. In order to be equal, {@code o} must represent the same object
as this instance using a class-specific comparison. The general contract
is that this comparison should be reflexive, symmetric, and transitive.
Also, no object reference other than null is equal to null.
<p>The default implementation returns {@code true} only if {@code this ==
o}. See <a href="{@docRoot}reference/java/lang/Object.html#writing_equals">Writing a correct
{@code equals} method</a>
if you intend implementing your own {@code equals} method.
<p>The general contract for the {@code equals} and {@link
#hashCode()} methods is that if {@code equals} returns {@code true} for
any two objects, then {@code hashCode()} must return the same value for
these objects. This means that subclasses of {@code Object} usually
override either both methods or neither of them.
@param obj
the object to compare this instance with.
@return {@code true} if the specified object is equal to this {@code
Object}; {@code false} otherwise.
@see #hashCode
| Object::equals | java | google/j2objc | jre_emul/stub_classes/java/java/lang/Object.java | https://github.com/google/j2objc/blob/master/jre_emul/stub_classes/java/java/lang/Object.java | Apache-2.0 |
protected Object clone() throws CloneNotSupportedException {
return null;
} |
Creates and returns a copy of this {@code Object}. The default
implementation returns a so-called "shallow" copy: It creates a new
instance of the same class and then copies the field values (including
object references) from this instance to the new instance. A "deep" copy,
in contrast, would also recursively clone nested objects. A subclass that
needs to implement this kind of cloning should call {@code super.clone()}
to create the new instance and then create deep copies of the nested,
mutable objects.
@return a copy of this object.
@throws CloneNotSupportedException
if this object's class does not implement the {@code
Cloneable} interface.
| Object::clone | java | google/j2objc | jre_emul/stub_classes/java/java/lang/Object.java | https://github.com/google/j2objc/blob/master/jre_emul/stub_classes/java/java/lang/Object.java | Apache-2.0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.