Java0621-node

最新推荐文章于 2024-05-07 21:34:58 发布

孙喆.Vinci

最新推荐文章于 2024-05-07 21:34:58 发布

阅读量528

点赞数

分类专栏： Javanode 文章标签： java

本文链接：https://blog.csdn.net/weixin_44579687/article/details/125385549

版权

Javanode 专栏收录该内容

7 篇文章 0 订阅

订阅专栏

Java0621-node

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数组+起始+长度

/**
* @param value:char数组
* @param offset:char数组起始位置
* @param count:从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;
            }
        }
        // Note: offset or count might be near -1>>>1.
        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() {
        // Cannot use Arrays.copyOf because of class initialization order issues
        char result[] = new char[value.length];

		/**
		* @param value:String的原char数组
		* @param 0：原char数组开始位置
		* @param result:目标数组
		* @param 0:目标数组开始位置
		* @param 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);//true
String s3 = "ab";
String s4 = "a"+"b";//两个常量连接，编译时会连接成功
System.out.println(s3==s4);//true
String s5 = s1+"b";//有变量参与，会重新开辟空间
System.out.println(s5==s3);//false
String s6 = "b";
String s7 = s1+s6;
System.out.println(s7==s3);//false
System.out.println(s7==s5);//false

String s8 = "abc";
String s9 = new String("abc");
System.out.println(s8==s9);//false

boolean equals：比较两个字符串值是否相等

/**
* 
*/
public boolean equals(Object anObject) {
        if (this == anObject) {
            return true;
        }
        //instanceof:左边是对象，右边是类；
        //当对象是右边类或子类所创建对象时，返回true；否则，返回false。
        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字符的索引位置

/**
* @param ch:一个字符或字符的ASCII码值
* @return :存在输出下标，不存在返回-1
*/
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) {
		// Note: fromIndex might be near -1>>>1.
		return -1;
	}

	if (ch < Character.MIN_SUPPLEMENTARY_CODE_POINT) {
		// handle most cases here (ch is a BMP code point or a
		// negative value (invalid 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;    /* avoid getfield opcode */

	while ((st < len) && (val[st] <= ' ')) {
		st++;
	}
	while ((st < len) && (val[len - 1] <= ' ')) {
		len--;
	}
	return ((st > 0) || (len < value.length)) ? substring(st, len) : this;
}