1、在没有IDE自动补齐的情况下，怎样得到数组的长度？怎样得到字符串的长度？
int[] arr = new int[3];
System.out.println(arr.length);//length for array
String str = "abc";
System.out.println(str.length());//length() for string
为什么数组有length属性而String只有length()方法呢？
2、为什么Arrays有length属性？
首先，数组是一个对象容器，保存的是一系列单一类型的值；然后数组被创建，但是长度不能被改变；数组的长度可以当成是 final 实例；因此长度可以被当成是数组的一个属性；
创建数组有两种方式：1）数组创建表达式；2）数组初始化创建。在创建的时候，数组的长度就被指定；
在数组被创建的时候，就指定了数组元素的类型，数组的维度，至少一个维度的长度；
int[][] arr = new int[3][];
数组初始化创建一个数组，并为它的所有元素提供了初始值。写成逗号分隔的表达式列表，用大括号{和}括起来。
nt[] arr = {1,2,3};
3、为什么没有定义一个Array类类似String类那样？
因为一个数组就是一个对象
Object obj = new int[10];
一个数组可以存储所有从Object类继承的对象，如果定义了一个Array类，它仍然需要一个数组来保存数据，因此，定义一个Array是多余的，可以通过代码得到数组的类型：
int[] arr = new int[3];
System.out.println(arr.getClass());
输出：class [I
class [I 说明了数组运行时的类型，同时也告诉我们数组元素的类型是int
4、为什么String类有length()方法？
String类的后台数据结构是char数组，String类里面需要定义一个length字段，因为并不是所有应用程序都需要。
阅读(...) 评论()String类所有方法(JAVA)
String类所有方法[转]
char&charAt(int&index)&
&&&&&&&&&&返回指定索引处的&char&值。&
int&codePointAt(int&index)&
&&&&&&&&&&返回指定索引处的字符（Unicode&代码点）。&
int&codePointBefore(int&index)&
&&&&&&&&&&返回指定索引之前的字符（Unicode&代码点）。&
int&codePointCount(int&beginIndex,&int&endIndex)&
&&&&&&&&&&返回此&String&的指定文本范围中的&Unicode&代码点数。&
int&compareTo(String&anotherString)&
&&&&&&&&&&按字典顺序比较两个字符串。&
int&compareToIgnoreCase(String&str)&
&&&&&&&&&&不考虑大小写，按字典顺序比较两个字符串。&
String&concat(String&str)&
&&&&&&&&&&将指定字符串联到此字符串的结尾。&
boolean&contains(CharSequence&s)&
&&&&&&&&&&当且仅当此字符串包含&char&值的指定序列时，才返回&true。&
boolean&contentEquals(CharSequence&cs)&
&&&&&&&&&&当且仅当此&String&表示与指定序列相同的&char&值时，才返回&true。&
boolean&contentEquals(StringBuffer&sb)&
&&&&&&&&&&当且仅当此&String&表示与指定的&StringBuffer&相同的字符序列时，才返回&true。&
static&String&copyValueOf(char[]&data)&
&&&&&&&&&&返回指定数组中表示该字符序列的字符串。&
static&String&copyValueOf(char[]&data,&int&offset,&int&count)&
&&&&&&&&&&返回指定数组中表示该字符序列的字符串。&
boolean&endsWith(String&suffix)&
&&&&&&&&&&测试此字符串是否以指定的后缀结束。&
boolean&equals(Object&anObject)&
&&&&&&&&&&比较此字符串与指定的对象。&
boolean&equalsIgnoreCase(String&anotherString)&
&&&&&&&&&&将此&String&与另一个&String&进行比较，不考虑大小写。&
static&String&format(Locale&l,&String&format,&Object...&args)&
&&&&&&&&&&使用指定的语言环境、格式字符串和参数返回一个格式化字符串。&
static&String&format(String&format,&Object...&args)&
&&&&&&&&&&使用指定的格式字符串和参数返回一个格式化字符串。&
byte[]&getBytes()&
&&&&&&&&&&使用平台默认的字符集将此&String&解码为字节序列，并将结果存储到一个新的字节数组中。&
void&getBytes(int&srcBegin,&int&srcEnd,&byte[]&dst,&int&dstBegin)&
&&&&&&&&&&已过时。&该方法无法将字符正确转换为字节。从&JDK&1.1&起，完成该转换的首选方法是通过&getBytes()&构造方法，该方法使用平台的默认字符集。&
byte[]&getBytes(String&charsetName)&
&&&&&&&&&&使用指定的字符集将此&String&解码为字节序列，并将结果存储到一个新的字节数组中。&
void&getChars(int&srcBegin,&int&srcEnd,&char[]&dst,&int&dstBegin)&
&&&&&&&&&&将字符从此字符串复制到目标字符数组。&
int&hashCode()&
&&&&&&&&&&返回此字符串的哈希代码。&
int&indexOf(int&ch)&
&&&&&&&&&&返回指定字符在此字符串中第一次出现处的索引。&
int&indexOf(int&ch,&int&fromIndex)&
&&&&&&&&&&从指定的索引开始搜索，返回在此字符串中第一次出现指定字符处的索引。&
int&indexOf(String&str)&
&&&&&&&&&&返回第一次出现的指定子字符串在此字符串中的索引。&
int&indexOf(String&str,&int&fromIndex)&
&&&&&&&&&&从指定的索引处开始，返回第一次出现的指定子字符串在此字符串中的索引。&
String&intern()&
&&&&&&&&&&返回字符串对象的规范化表示形式。&
int&lastIndexOf(int&ch)&
&&&&&&&&&&返回最后一次出现的指定字符在此字符串中的索引。&
int&lastIndexOf(int&ch,&int&fromIndex)&
&&&&&&&&&&从指定的索引处开始进行后向搜索，返回最后一次出现的指定字符在此字符串中的索引。&
int&lastIndexOf(String&str)&
&&&&&&&&&&返回在此字符串中最右边出现的指定子字符串的索引。&
int&lastIndexOf(String&str,&int&fromIndex)&
&&&&&&&&&&从指定的索引处开始向后搜索，返回在此字符串中最后一次出现的指定子字符串的索引。&
int&length()&
&&&&&&&&&&返回此字符串的长度。&
boolean&matches(String&regex)&
&&&&&&&&&&通知此字符串是否匹配给定的正则表达式。&
int&offsetByCodePoints(int&index,&int&codePointOffset)&
&&&&&&&&&&返回此&String&中从给定的&index&处偏移&codePointOffset&个代码点的索引。&
boolean&regionMatches(boolean&ignoreCase,&int&toffset,&String&other,&int&ooffset,&int&len)&
&&&&&&&&&&测试两个字符串区域是否相等。&
boolean&regionMatches(int&toffset,&String&other,&int&ooffset,&int&len)&
&&&&&&&&&&测试两个字符串区域是否相等。&
String&replace(char&oldChar,&char&newChar)&
&&&&&&&&&&返回一个新的字符串，它是通过用&newChar&替换此字符串中出现的所有&oldChar&而生成的。&
String&replace(CharSequence&target,&CharSequence&replacement)&
&&&&&&&&&&使用指定的字面值替换序列替换此字符串匹配字面值目标序列的每个子字符串。&
String&replaceAll(String&regex,&String&replacement)&
&&&&&&&&&&使用给定的&replacement&字符串替换此字符串匹配给定的正则表达式的每个子字符串。&
String&replaceFirst(String&regex,&String&replacement)&
&&&&&&&&&&使用给定的&replacement&字符串替换此字符串匹配给定的正则表达式的第一个子字符串。&
String[]&split(String&regex)&
&&&&&&&&&&根据给定的正则表达式的匹配来拆分此字符串。&
String[]&split(String&regex,&int&limit)&
&&&&&&&&&&根据匹配给定的正则表达式来拆分此字符串。&
boolean&startsWith(String&prefix)&
&&&&&&&&&&测试此字符串是否以指定的前缀开始。&
boolean&startsWith(String&prefix,&int&toffset)&
&&&&&&&&&&测试此字符串是否以指定前缀开始，该前缀以指定索引开始。&
CharSequence&subSequence(int&beginIndex,&int&endIndex)&
&&&&&&&&&&返回一个新的字符序列，它是此序列的一个子序列。&
String&substring(int&beginIndex)&
&&&&&&&&&&返回一个新的字符串，它是此字符串的一个子字符串。&
String&substring(int&beginIndex,&int&endIndex)&
&&&&&&&&&&返回一个新字符串，它是此字符串的一个子字符串。&
char[]&toCharArray()&
&&&&&&&&&&将此字符串转换为一个新的字符数组。&
String&toLowerCase()&
&&&&&&&&&&使用默认语言环境的规则将此&String&中的所有字符都转换为小写。&
String&toLowerCase(Locale&locale)&
&&&&&&&&&&使用给定&Locale&的规则将此&String&中的所有字符都转换为小写。&
String&toString()&
&&&&&&&&&&返回此对象本身（它已经是一个字符串！）。&
String&toUpperCase()&
&&&&&&&&&&使用默认语言环境的规则将此&String&中的所有字符都转换为大写。&
String&toUpperCase(Locale&locale)&
&&&&&&&&&&使用给定的&Locale&规则将此&String&中的所有字符都转换为大写。&
String&trim()&
&&&&&&&&&&返回字符串的副本，忽略前导空白和尾部空白。&
static&String&valueOf(boolean&b)&
&&&&&&&&&&返回&boolean&参数的字符串表示形式。&
static&String&valueOf(char&c)&
&&&&&&&&&&返回&char&参数的字符串表示形式。&
static&String&valueOf(char[]&data)&
&&&&&&&&&&返回&char&数组参数的字符串表示形式。&
static&String&valueOf(char[]&data,&int&offset,&int&count)&
&&&&&&&&&&返回&char&数组参数的特定子数组的字符串表示形式。&
static&String&valueOf(double&d)&
&&&&&&&&&&返回&double&参数的字符串表示形式。&
static&String&valueOf(float&f)&
&&&&&&&&&&返回&float&参数的字符串表示形式。&
static&String&valueOf(int&i)&
&&&&&&&&&&返回&int&参数的字符串表示形式。&
static&String&valueOf(long&l)&
&&&&&&&&&&返回&long&参数的字符串表示形式。&
static&String&valueOf(Object&obj)&
&&&&&&&&&&返回&Object&参数的字符串表示形式。&
&&从类&java.lang.Object&继承的方法&
clone,&finalize,&getClass,&notify,&notifyAll,&wait,&wait,&wait&
--------------------------------------------------------------------------------
public&char&charAt(int&index)返回指定索引处的&char&值。索引范围为从&0&到&length()&-&1。序列的第一个&char&值在索引&0&处，第二个在索引&1&处，依此类推，这类似于数组索引。&
如果索引指定的&char&值是代理项，则返回代理项值。&
接口&CharSequence&中的&charAt
index&-&char&值的索引。&
此字符串指定索引处的&char&值。第一个&char&值在索引&0&处。&
IndexOutOfBoundsException&-&如果&index&参数为负或小于此字符串的长度。
--------------------------------------------------------------------------------
codePointAt
public&int&codePointAt(int&index)返回指定索引处的字符（Unicode&代码点）。该索引引用&char&值（Unicode&代码单元），其范围从&0&到&length()&-&1。&
如果给定索引指定的&char&值属于高代理项范围，则后续索引小于此&String&的长度。同样，如果后续索引处的&char&值属于低代理项范围，则返回该代理项对相应的增补代码点。否则，返回给定索引处的&char&值。&
index&-&char&值的索引&
该&index&处字符的代码点值&
IndexOutOfBoundsException&-&如果&index&参数为负或小于此字符串的长度。
从以下版本开始：&
--------------------------------------------------------------------------------
codePointBefore
public&int&codePointBefore(int&index)返回指定索引之前的字符（Unicode&代码点）。该索引引用&char&值（Unicode&代码单元），其范围从&1&到&length。&
如果&(index&-&1)&处的&char&值属于低代理项范围，则&(index&-&2)&为非负；如果(index&-&2)&处的
&char&值属于高低理项范围，则返回该代理项对的增补代码点值。如果&index&-&1&处的&char&值是未配对的低（高）代理项，则返回代理项值。&
index&-&应返回的代码点后面的索引&
在给定索引前的&Unicode&代码点。&
IndexOutOfBoundsException&-&如果&index&参数小于&1&或大于此字符串的长度。
从以下版本开始：&
--------------------------------------------------------------------------------
codePointCount
public&int&codePointCount(int&beginIndex,
&&&&&&&&&&&&&&&&&&&&&&&&&&int&endIndex)返回此&String&的指定文本范围中的&Unicode&代码点数。文本范围始于指定的&beginIndex，一直到索引&endIndex&-&1&处的&char。因此，该文本范围的长度（在&char&中）是
&endIndex-beginIndex。该文本范围内未配对的代理项作为一个代码点计数。&
beginIndex&-&该文本范围的第一个&char&的索引。
endIndex&-&该文本范围的最后一个&char&后面的索引。&
指定文本范围中&Unicode&代码点的数量&
IndexOutOfBoundsException&-&如果&beginIndex&为负，或&endIndex&大于此&String&的长度，或&beginIndex&大于&endIndex。
从以下版本开始：&
--------------------------------------------------------------------------------
offsetByCodePoints
public&int&offsetByCodePoints(int&index,
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&int&codePointOffset)返回此&String&中从给定的
&index&处偏移&codePointOffset&个代码点的索引。文本范围内由&index&和&codePointOffset&给定的未配对代理项各计为一个代码点。&
index&-&要偏移的索引
codePointOffset&-&代码点中的偏移量&
String&的索引&
IndexOutOfBoundsException&-&如果&index&为负或大于此&String&的长度；或者如果
&codePointOffset&为正，并且以&index&开头的子字符串比&codePointOffset&具有更少的代码点；或者如果
&codePointOffset&为负，并且&index&前的子字符串比&codePointOffset&的绝对值具有更少的代码点。
从以下版本开始：&
--------------------------------------------------------------------------------
public&void&getChars(int&srcBegin,
&&&&&&&&&&&&&&&&&&&&&int&srcEnd,
&&&&&&&&&&&&&&&&&&&&&char[]&dst,
&&&&&&&&&&&&&&&&&&&&&int&dstBegin)将字符从此字符串复制到目标字符数组。&
要复制的第一个字符在索引&srcBegin&处；要复制的最后一个字符在索引&srcEnd-1&处（因此要复制的字符总数是&srcEnd-srcBegin）。要复制到&dst&子数组的字符从索引&dstBegin&处开始，并结束于索引：&
&&&&&dstbegin&+&(srcEnd-srcBegin)&-&1
srcBegin&-&字符串中要复制的第一个字符的索引。
srcEnd&-&字符串中要复制的最后一个字符之后的索引。
dst&-&目标数组。
dstBegin&-&目标数组中的起始偏移量。&
IndexOutOfBoundsException&-&如果下列任何一项为&true：&
srcBegin&为负。&
srcBegin&大于&srcEnd&
srcEnd&大于此字符串的长度&
dstBegin&为负&
dstBegin+(srcEnd-srcBegin)&大于&dst.length
--------------------------------------------------------------------------------
@Deprecated
public&void&getBytes(int&srcBegin,
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&int&srcEnd,
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&byte[]&dst,
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&int&dstBegin)已过时。&该方法无法将字符正确转换为字节。从&JDK&1.1&起，完成该转换的首选方法是通过&getBytes()&构造方法，该方法使用平台的默认字符集。&
将字符从此字符串复制到目标字节数组中。每个字节接收相应字符的&8&个低位。不复制每个字符的高位，它们也不参与任何方式的转换。&
要复制的第一个字符在索引&srcBegin&处；要复制的最后一个字符在索引&srcEnd-1&处。要复制的字符总数为&srcEnd-srcBegin。将要转换为字节的字符复制到&dst&的子数组中，从索引&dstBegin&处开始，并结束于索引：&
&&&&&dstbegin&+&(srcEnd-srcBegin)&-&1
srcBegin&-&字符串中要复制的第一个字符的索引。
srcEnd&-&字符串中要复制的最后一个字符之后的索引。
dst&-&目标数组。
dstBegin&-&目标数组中的起始偏移量。&
IndexOutOfBoundsException&-&如果下列任何一项为&true：&
srcBegin&为负&
srcBegin&大于&srcEnd&
srcEnd&大于此&String&的长度&
dstBegin&为负&
dstBegin+(srcEnd-srcBegin)&大于&dst.length
--------------------------------------------------------------------------------
public&byte[]&getBytes(String&charsetName)
&&&&&&&&&&&&&&&&throws&java.io.UnsupportedEncodingException使用指定的字符集将此&String&解码为字节序列，并将结果存储到一个新的字节数组中。&
当此字符串不能在给定的字符集中解码时，该方法无指定的行为。当需要进一步控制解码过程时，应使用&CharsetEncoder&类。&
charsetName&-&受支持的&charset&名称&
结果字节数组&
java.io.UnsupportedEncodingException&-&如果指定的字符集不受支持
从以下版本开始：&
--------------------------------------------------------------------------------
public&byte[]&getBytes()使用平台默认的字符集将此&String&解码为字节序列，并将结果存储到一个新的字节数组中。&
当此字符串不能在默认的字符集中解码时，该方法无指定的行为。当需要进一步控制解码过程时，应使用&CharsetEncoder&类。&
结果字节数组
从以下版本开始：&
--------------------------------------------------------------------------------
public&boolean&equals(Object&anObject)比较此字符串与指定的对象。当且仅当该参数不为&null，并且是表示与此对象相同的字符序列的&String&对象时，结果才为&true。&
类&Object&中的&equals
anObject&-&与此&String&进行比较的对象。&
如果&String&相等，则返回&true；否则返回&false。
另请参见：
compareTo(java.lang.String),&equalsIgnoreCase(java.lang.String)
--------------------------------------------------------------------------------
contentEquals
public&boolean&contentEquals(StringBuffer&sb)当且仅当此&String&表示与指定的&StringBuffer&相同的字符序列时，才返回&true。&
sb&-&要比较的&StringBuffer。&
当且仅当此&String&表示与指定的&StringBuffer&相同的字符序列时，才返回&true；否则返回&false。&
NullPointerException&-&如果&sb&为&null
从以下版本开始：&
--------------------------------------------------------------------------------
contentEquals
public&boolean&contentEquals(CharSequence&cs)当且仅当此&String&表示与指定序列相同的&char&值时，才返回&true。&
cs&-&要比较的序列。&
当且仅当此&String&表示与指定序列相同的&char&值的序列时；才返回&true，否则返回&false。&
NullPointerException&-&如果&cs&为&null
从以下版本开始：&
--------------------------------------------------------------------------------
equalsIgnoreCase
public&boolean&equalsIgnoreCase(String&anotherString)将此&String&与另一个
&String&进行比较，不考虑大小写。如果两个字符串的长度相等，并且两个字符串中的相应字符都相等（忽略大小写），则认为这两个字符串是相等的。&
在忽略大小写的情况下，如果下列至少一项为&true，则认为&c1&和&c2&这两个字符相同。&
这两个字符相同（使用&==&运算符进行比较）。&
对每个字符应用方法&Character.toUpperCase(char)&产生相同的结果。&
对每个字符应用方法&Character.toLowerCase(char)&产生相同的结果。
anotherString&-&与此&String&进行比较的&String。&
如果参数不为&null，且这两个&String&在忽略大小写时相等，则返回&true；否则返回&false。
另请参见：
equals(Object),&Character.toLowerCase(char),&Character.toUpperCase(char)
--------------------------------------------------------------------------------
public&int&compareTo(String&anotherString)按字典顺序比较两个字符串。该比较基于字符串中各个字符的
&Unicode&值。将此&String&对象表示的字符序列与参数字符串所表示的字符序列进行比较。如果按字典顺序此&String&对象在参数字符串之前，则比较结果为一个负整数。如果按字典顺序此&String&对象位于参数字符串之后，则比较结果为一个正整数。如果这两个字符串相等，则结果为
&0；compareTo&只有在方法&equals(Object)&返回&true&时才返回&0。&
这是字典排序的定义。如果这两个字符串不同，则要么它们在某个索引处具有不同的字符，该索引对二者均为有效索引，要么它们的长度不同，或者同时具备上述两种情况。如果它们在一个或多个索引位置上具有不同的字符，假设&k&是这类索引的最小值；则按照&&&运算符确定的那个字符串在位置&k&上具有较小的值，其字典顺序在其他字符串之前。这种情况下，compareTo&返回这两个字符串在位置&k&处的两个不同的&char&值，即值：&
this.charAt(k)-anotherString.charAt(k)
如果它们没有不同的索引位置，则较短字符串在字典顺序上位于较长字符串的前面。这种情况下，compareTo&返回这两个字符串长度的不同，即值：&
this.length()-anotherString.length()
接口&Comparable&String&&中的&compareTo
anotherString&-&要比较的&String。&
如果参数字符串等于此字符串，则返回&0&值；如果按字典顺序此字符串小于字符串参数，则返回一个小于&0&的值；如果按字典顺序此字符串大于字符串参数，则返回一个大于&0&的值。
--------------------------------------------------------------------------------
compareToIgnoreCase
public&int&compareToIgnoreCase(String&str)不考虑大小写，按字典顺序比较两个字符串。此方法返回一个整数，它的正负号是调用&compareTo&的正负号，调用时使用了字符串的规范化版本，其大小写差异已通过对每个字符调用
&Character.toLowerCase(Character.toUpperCase(character))&得以消除。&
注意，此方法不&考虑语言环境，因此可能在某些特定的语言环境中产生不理想的排序。java.text&包提供&Collators&来完成语言环境敏感的排序。&
str&-&要比较的&String。&
一个负整数、零或正整数，视指定的&String&大于、等于还是小于该&String&而定，不考虑大小写。
从以下版本开始：&
另请参见：
Collator.compare(String,&String)
--------------------------------------------------------------------------------
regionMatches
public&boolean&regionMatches(int&toffset,
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&String&other,
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&int&ooffset,
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&int&len)测试两个字符串区域是否相等。&
该&String&对象的一个子字符串与参数&other&的一个子字符串进行比较。如果这两个子字符串表示相同的字符序列，则结果为&true。要比较的&String&对象的子字符串从索引&toffset&处开始，长度为&len。要比较的&other&的子字符串从索引&ooffset&处开始，长度为&len。当且仅当下列至少一项为&true&时，结果才为&false&：&
toffset&为负。&
ooffset&为负。&
toffset+len&大于此&String&对象的长度。&
ooffset+len&大于另一个参数的长度。&
存在某个小于&len&的非负整数&k，它满足：this.charAt(toffset+k)&!=&other.charAt(ooffset+k)&
toffset&-&字符串中子区域的起始偏移量。
other&-&字符串参数。
ooffset&-&字符串参数中子区域的起始偏移量。
len&-&要比较的字符数。&
如果字符串的指定子区域完全匹配字符串参数的指定子区域，则返回&true；否则返回&false。
--------------------------------------------------------------------------------
regionMatches
public&boolean&regionMatches(boolean&ignoreCase,
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&int&toffset,
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&String&other,
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&int&ooffset,
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&int&len)测试两个字符串区域是否相等。&
将此&String&对象的子字符串与参数&other&的子字符串进行比较。如果这两个子字符串表示的是相同的字符序列，则结果为&true，当且仅当
&ignoreCase&为&true&时忽略大小写。要比较的&String&对象的子字符串从索引&toffset&处开始，长度为&len。要比较的&other&的子字符串从索引&ooffset&处开始，长度为&len。当且仅当下列至少一项为&true&时，结果才为&false：&
toffset&为负。&
ooffset&为负。&
toffset+len&大于此&String&对象的长度。&
ooffset+len&大于另一个参数的长度。&
ignoreCase&为&false，且存在某个小于&len&的非负整数&k，即：&
this.charAt(toffset+k)&!=&other.charAt(ooffset+k)
ignoreCase&为&true，且存在某个小于&len&的非负整数&k，即：&
Character.toLowerCase(this.charAt(toffset+k))&!=
&&&&&&&&&&&&&&&Character.toLowerCase(other.charAt(ooffset+k))
Character.toUpperCase(this.charAt(toffset+k))&!=
&&&&&&&&&Character.toUpperCase(other.charAt(ooffset+k))
ignoreCase&-&如果为&true，则比较字符时忽略大小写。
toffset&-&字符串中的子区域的起始偏移量。
other&-&字符串参数。
toffset&-&字符串参数中的子区域的起始偏移量。
len&-&要比较的字符数。&
如果此字符串的指定子区域匹配字符串参数的指定子区域，则返回&true；否则返回&false。是否完全匹配或大小写敏感取决于&ignoreCase&参数。
已投稿到：
以上网友发言只代表其个人观点，不代表新浪网的观点或立场。}