Java0621-node
目录
- 1 JDK常用的类
- 1.1 学习标准
- 1.2 学习方法
- 1.3 String
- 1.3.1 定义
- 1.3.2 构造方法
- 1.3.3 方法
- 1.3.3.1 字符串属性相关
- 1.3.3.2 字符串比较
- 1.3.3.3 索引
- 1.3.3.4 拆分
- 1.3.3.5 转换为字符串
1 JDK常用的类
1.1 学习标准
- 创建对象，有什么属性，有什么方法（方法名，参数，返回值）
- 类，方法体如何实现
1.2 学习方法
- Ctrl+Shift+T 搜索一个类，通过outline查看类的构成
- API帮助文档
1.3 String
1.3.1 定义
- String 类代表字符串。Java 程序中的所有字符串字面值（如 “abc” ）都作为此类的实例实现。
- 字符串是常量，其值在创建后不能更改，可以共享使用
private final char value[]; - 本质是char[]数组
1.3.2 构造方法
- 无参构造：空的字符串
public String() {
this.value = "".value;
}
- char数组为参数的构造方法
public String(char value[]) {
this.value = Arrays.copyOf(value, value.length);
}
- char数组+起始+长度
public String(char value[], int offset, int count) {
if (offset < 0) {
throw new StringIndexOutOfBoundsException(offset);
}
if (count <= 0) {
if (count < 0) {
throw new StringIndexOutOfBoundsException(count);
}
if (offset <= value.length) {
this.value = "".value;
return;
}
}
if (offset > value.length - count) {
throw new StringIndexOutOfBoundsException(offset + count);
}
this.value = Arrays.copyOfRange(value, offset, offset+count);
}
注意：
String a = new String("abc");
肯会创建1个或两个对象：new和“abc”，常量池里若是有“abc”，则不创建
1.3.3 方法
String s = null；不能使用方法，会空指针
1.3.3.1 字符串属性相关
- char[] toCharArray()：字符串转为字符数组
public char[] toCharArray() {
char result[] = new char[value.length];
System.arraycopy(value, 0, result, 0, value.length);
return result;
}
- int length：字符串长度，及字符的个数，空格也算
public int length() {
return value.length;
}
- boolean isEmpty：是否为空，只能判断字符串个数，不能判断是否为null
public boolean isEmpty() {
return value.length == 0;
}
1.3.3.2 字符串比较
==：比较地址
equals：比较字面常量
String s1 = "a";
String s2 = "a";
System.out.println(s1==s2);
String s3 = "ab";
String s4 = "a"+"b";
System.out.println(s3==s4);
String s5 = s1+"b";
System.out.println(s5==s3);
String s6 = "b";
String s7 = s1+s6;
System.out.println(s7==s3);
System.out.println(s7==s5);
String s8 = "abc";
String s9 = new String("abc");
System.out.println(s8==s9);
- boolean equals：比较两个字符串值是否相等
public boolean equals(Object anObject) {
if (this == anObject) {
return true;
}
if (anObject instanceof String) {
String anotherString = (String)anObject;
int n = value.length;
if (n == anotherString.value.length) {
char v1[] = value;
char v2[] = anotherString.value;
int i = 0;
while (n-- != 0) {
if (v1[i] != v2[i])
return false;
i++;
}
return true;
}
}
return false;
}
忽略大小写比较，全部转换成小写或者大写
2. String toLowerCase()：转换成小写
public String toLowerCase() {
return toLowerCase(Locale.getDefault());
}
- String toUpperCase()：转换成大写
public String toUpperCase() {
return toUpperCase(Locale.getDefault());
}
- boolean equalsIgnoreCase(String anotherSting)：忽略大小写比较
public boolean equalsIgnoreCase(String anotherString) {
return (this == anotherString) ? true
: (anotherString != null)
&& (anotherString.value.length == value.length)
&& regionMatches(true, 0, anotherString, 0, value.length);
}
- int compareTo（String anotherString）：按字典顺序比较两个字符串，不考虑大小写。0：等于，正数：大于，负数：小于
public int compareTo(String anotherString) {
int len1 = value.length;
int len2 = anotherString.value.length;
int lim = Math.min(len1, len2);
char v1[] = value;
char v2[] = anotherString.value;
int k = 0;
while (k < lim) {
char c1 = v1[k];
char c2 = v2[k];
if (c1 != c2) {
return c1 - c2;
}
k++;
}
return len1 - len2;
}
1.3.3.3 索引
- char cahrAt(int index)：返回对应索引位置的字符
public char charAt(int index) {
if ((index < 0) || (index >= value.length)) {
throw new StringIndexOutOfBoundsException(index);
}
return value[index];
}
- int indexOf(int ch)：从左往右找第一个出现int字符的索引位置
public int indexOf(int ch) {
return indexOf(ch, 0);
}
- int indexOf(int ch,int fromIndex)：从fromIndex开始，向右查找，第一个出现的索引位置
public int indexOf(int ch, int fromIndex) {
final int max = value.length;
if (fromIndex < 0) {
fromIndex = 0;
} else if (fromIndex >= max) {
return -1;
}
if (ch < Character.MIN_SUPPLEMENTARY_CODE_POINT) {
final char[] value = this.value;
for (int i = fromIndex; i < max; i++) {
if (value[i] == ch) {
return i;
}
}
return -1;
} else {
return indexOfSupplementary(ch, fromIndex);
}
}
- int indexOf(String str)：从左往右找出第一个出现str的索引位置
public int indexOf(String str) {
return indexOf(str, 0);
}
- int lastIndexOf(int ch)：从右往左找出第一个出现int字符的索引位置，如果找不到返回-1
public int lastIndexOf(int ch) {
return lastIndexOf(ch, value.length - 1);
}
- String substring(int beginIndex)：从beginIndex开始到结束，截取一个新的字符串
public String substring(int beginIndex) {
if (beginIndex < 0) {
throw new StringIndexOutOfBoundsException(beginIndex);
}
int subLen = value.length - beginIndex;
if (subLen < 0) {
throw new StringIndexOutOfBoundsException(subLen);
}
return (beginIndex == 0) ? this : new String(value, beginIndex, subLen);
}
- String substring(int beginIndex, int endIndex)：截取[beginIndex，endIndex）之间的字符串
public String substring(int beginIndex, int endIndex) {
if (beginIndex < 0) {
throw new StringIndexOutOfBoundsException(beginIndex);
}
if (endIndex > value.length) {
throw new StringIndexOutOfBoundsException(endIndex);
}
int subLen = endIndex - beginIndex;
if (subLen < 0) {
throw new StringIndexOutOfBoundsException(subLen);
}
return ((beginIndex == 0) && (endIndex == value.length)) ? this
: new String(value, beginIndex, subLen);
}
- boolean startsWith(String prefix)：判断字符串是否以prefix开头
public boolean startsWith(String prefix) {
return startsWith(prefix, 0);
}
- boolean endsWith(String suffix)：判断字符串是否以suffix结尾
public boolean endsWith(String suffix) {
return startsWith(suffix, (value.length - suffix.value.length));
}
1.3.3.4 拆分
- String[] split(String regex)：以regex为分隔符，进行拆分，支持正则表达式
public String[] split(String regex) {
return split(regex, 0);
}
- String trim()：去除一个字符串前面和后面的空格
public String trim() {
int len = value.length;
int st = 0;
char[] val = value;
while ((st < len) && (val[st] <= ' ')) {
st++;
}
while ((st < len) && (val[len - 1] <= ' ')) {
len--;
}
return ((st > 0) || (len < value.length)) ? substring(st, len) : this;
}
1.3.3.5 转换为字符串
String valueOf()：将指定类型的数据转换为字符串
本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)
