【JDK1.8源码阅读】String.class

最新推荐文章于 2023-10-12 07:00:00 发布
最新推荐文章于 2023-10-12 07:00:00 发布
阅读量265 收藏 1
点赞数
分类专栏： # Java源码系列（JDK1.8）
版权源自：dahouzi.cn
本文链接：https://blog.csdn.net/lglglgl/article/details/104966752
版权

String.class

常量

  1. String底层是使用字符数组存储的
  2. 所有String字符串被创建后就不可改变，因此创建后的字符串底层是共享的。
  3. String类里面的value包括一个hash(int)和private final char value[]，广义上只要两者任一值不同，既是不同。

public final class String implements java.io.Serializable, Comparable<String>, CharSequence {
	private final char value[];
	private int hash;
	private static final long serialVersionUID = -6849794470754667710L;
	private static final ObjectStreamField[] serialPersistentFields = new ObjectStreamField[0];
	public String() {
		this.value = "".value;//this.value = "".value，意思指长度为零的空字符串
	}
	public String(String original) {
		this.value = original.value;
		this.hash = original.hash;
	}
	public String(char value[]) {
		this.value = Arrays.copyOf(value, value.length);
	}

方法

compareTo

compareTo和compareToIgnoreCase两个方法，由源码可看出：

  1. 首先取出两个字符串的长度，比较较小的长度内，两者是否相等。
  2. 若不相等，则直接返回该位置字符的ASCII码相减后的值。
  3. 若各位置都相等，则将两个字符串长度的差值返回。
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;
//不如直接returnlen1-len2，这一段何用
		int k = 0;
		while (k < lim) {
			char c1 = v1[k];
			char c2 = v2[k];
			if (c1 != c2) {
				return c1 - c2;
			}
			k++;
		}
		return len1 - len2;
	}

	public int compareToIgnoreCase(String str) {
		return CASE_INSENSITIVE_ORDER.compare(this, str);
	}

regionMatches

regionMatches() 方法用于检测两个字符串在一个区域内是否相等。

public boolean regionMatches(int toffset, String other, int ooffset, int len) {
		char ta[] = value;
		int to = toffset;
		char pa[] = other.value;
		int po = ooffset;
		// Note: toffset, ooffset, or len might be near -1>>>1.
		if ((ooffset < 0) || (toffset < 0) || (toffset > (long) value.length - len)
				|| (ooffset > (long) other.value.length - len)) {
			return false;
		}
		while (len-- > 0) {
			if (ta[to++] != pa[po++]) {
				return false;
			}
		}
		return true;
	}

	public boolean regionMatches(boolean ignoreCase, int toffset, String other, int ooffset, int len) {
		char ta[] = value;
		int to = toffset;
		char pa[] = other.value;
		int po = ooffset;
		if ((ooffset < 0) || (toffset < 0) || (toffset > (long) value.length - len)
				|| (ooffset > (long) other.value.length - len)) {
			return false;
		}
		while (len-- > 0) {
			char c1 = ta[to++];
			char c2 = pa[po++];
			if (c1 == c2) {
				continue;
			}
			if (ignoreCase) {
				char u1 = Character.toUpperCase(c1);
				char u2 = Character.toUpperCase(c2);
				if (u1 == u2) {
					continue;
				}
				
				if (Character.toLowerCase(u1) == Character.toLowerCase(u2)) {
					continue;
				}
			}
			return false;
		}
		return true;
	}

startsWith

startsWith() 方法用于检测字符串是否以指定的前缀开始

public boolean startsWith(String prefix, int toffset) {
		char ta[] = value;
		int to = toffset;
		char pa[] = prefix.value;
		int po = 0;
		int pc = prefix.value.length;
		// Note: toffset might be near -1>>>1.
		if ((toffset < 0) || (toffset > value.length - pc)) {
			return false;
		}
		while (--pc >= 0) {
			if (ta[to++] != pa[po++]) {
				return false;
			}
		}
		return true;
	}

	public boolean startsWith(String prefix) {
		return startsWith(prefix, 0);
	}

	public boolean endsWith(String suffix) {
		return startsWith(suffix, value.length - suffix.value.length);
	}

public class Test {
public static void main(String args[]) {
    String Str = new String("www.runoob.com");
    System.out.print("返回值 :" );
    System.out.println(Str.startsWith("www") );//true
    System.out.print("返回值 :" );
    System.out.println(Str.startsWith("runoob") );//false
    System.out.print("返回值 :" );
    System.out.println(Str.startsWith("runoob", 4) );//true
}
}

indexOf

字符串的IndexOf()方法搜索在该字符串上是否出现了作为参数传递的字符串,如果找到字符串,则返回字符的起始位置

public int indexOf(String str) {
		return indexOf(str, 0);
	}

	public int indexOf(String str, int fromIndex) {
		return indexOf(value, 0, value.length, str.value, 0, str.value.length, fromIndex);
	}

	static int indexOf(char[] source, int sourceOffset, int sourceCount, String target, int fromIndex) {
		return indexOf(source, sourceOffset, sourceCount, target.value, 0, target.value.length, fromIndex);
	}

	static int indexOf(char[] source, int sourceOffset, int sourceCount, char[] target, int targetOffset,
			int targetCount, int fromIndex) {
		if (fromIndex >= sourceCount) {
			return (targetCount == 0 ? sourceCount : -1);
		}
		if (fromIndex < 0) {
			fromIndex = 0;
		}
		if (targetCount == 0) {
			return fromIndex;
		}

		char first = target[targetOffset];
		int max = sourceOffset + (sourceCount - targetCount);

		for (int i = sourceOffset + fromIndex; i <= max; i++) {
			/* Look for first character. */
			if (source[i] != first) {
				while (++i <= max && source[i] != first)
					;
			}
			/* Found first character, now look at the rest of v2 */
			if (i <= max) {
				int j = i + 1;
				int end = j + targetCount - 1;
				for (int k = targetOffset + 1; j < end && source[j] == target[k]; j++, k++);
				if (j == end) {
					/* Found whole string. */
					return i - sourceOffset;
				}
			}
		}
		return -1;
	}

substring

返回一个新字符串，它是此字符串的一个子字符串。该子字符串始于指定索引处的字符，一直到此字符串末尾。

异常：如果 beginIndex 为负或大于此 String 对象的长度，则抛出IndexOutOfBoundsException 
例  ：  "unhappy".substring(2)   returns"happy"
　　　	"mybaby".substring(3)   returns"aby"

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);
	}
	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);
	}

	public CharSequence subSequence(int beginIndex, int endIndex) {
		return this.substring(beginIndex, endIndex);
	}

replace

replace() 方法通过用 newChar 字符替换字符串中出现的所有 oldChar 字符，并返回替换后的新字符串。

public String replaceFirst(String regex, String replacement) {
		return Pattern.compile(regex).matcher(this).replaceFirst(replacement);
	}

	public String replaceAll(String regex, String replacement) {
		return Pattern.compile(regex).matcher(this).replaceAll(replacement);
	}

	public String replace(CharSequence target, CharSequence replacement) {
		return Pattern.compile(target.toString(), Pattern.LITERAL).matcher(this)
				.replaceAll(Matcher.quoteReplacement(replacement.toString()));
	}

toLowerCase

public String toLowerCase(Locale locale) {
		if (locale == null) {
			throw new NullPointerException();
		}

		int firstUpper;
		final int len = value.length;

		/* Now check if there are any characters that need to be changed. */
		scan: {
			for (firstUpper = 0; firstUpper < len;) {
				char c = value[firstUpper];
				if ((c >= Character.MIN_HIGH_SURROGATE) && (c <= Character.MAX_HIGH_SURROGATE)) {
					int supplChar = codePointAt(firstUpper);
					if (supplChar != Character.toLowerCase(supplChar)) {
						break scan;
					}
					firstUpper += Character.charCount(supplChar);
				} else {
					if (c != Character.toLowerCase(c)) {
						break scan;
					}
					firstUpper++;
				}
			}
			return this;
		}

		char[] result = new char[len];
		int resultOffset = 0; /* result may grow, so i+resultOffset
								 * is the write location in result */

		/* Just copy the first few lowerCase characters. */
		System.arraycopy(value, 0, result, 0, firstUpper);

		String lang = locale.getLanguage();
		boolean localeDependent = (lang == "tr" || lang == "az" || lang == "lt");
		char[] lowerCharArray;
		int lowerChar;
		int srcChar;
		int srcCount;
		for (int i = firstUpper; i < len; i += srcCount) {
			srcChar = (int) value[i];
			if ((char) srcChar >= Character.MIN_HIGH_SURROGATE && (char) srcChar <= Character.MAX_HIGH_SURROGATE) {
				srcChar = codePointAt(i);
				srcCount = Character.charCount(srcChar);
			} else {
				srcCount = 1;
			}
			if (localeDependent || srcChar == '\u03A3' || // GREEK CAPITAL LETTER SIGMA
					srcChar == '\u0130') { // LATIN CAPITAL LETTER I WITH DOT ABOVE
				lowerChar = ConditionalSpecialCasing.toLowerCaseEx(this, i, locale);
			} else {
				lowerChar = Character.toLowerCase(srcChar);
			}
			if ((lowerChar == Character.ERROR) || (lowerChar >= Character.MIN_SUPPLEMENTARY_CODE_POINT)) {
				if (lowerChar == Character.ERROR) {
					lowerCharArray = ConditionalSpecialCasing.toLowerCaseCharArray(this, i, locale);
				} else if (srcCount == 2) {
					resultOffset += Character.toChars(lowerChar, result, i + resultOffset) - srcCount;
					continue;
				} else {
					lowerCharArray = Character.toChars(lowerChar);
				}

				/* Grow result if needed */
				int mapLen = lowerCharArray.length;
				if (mapLen > srcCount) {
					char[] result2 = new char[result.length + mapLen - srcCount];
					System.arraycopy(result, 0, result2, 0, i + resultOffset);
					result = result2;
				}
				for (int x = 0; x < mapLen; ++x) {
					result[i + resultOffset + x] = lowerCharArray[x];
				}
				resultOffset += (mapLen - srcCount);
			} else {
				result[i + resultOffset] = (char) lowerChar;
			}
		}
		return new String(result, 0, len + resultOffset);
	}

	public String toLowerCase() {
		return toLowerCase(Locale.getDefault());
	}

valueOf

valueOf将传入的变量转成String

	public static String valueOf(Object obj) {
		return (obj == null) ? "null" : obj.toString();
	}
	public static String valueOf(char data[]) {
		return new String(data);
	}
	public static String valueOf(char data[], int offset, int count) {
		return new String(data, offset, count);
	}
	public static String copyValueOf(char data[], int offset, int count) {
		return new String(data, offset, count);
	}
	public static String copyValueOf(char data[]) {
		return new String(data);
	}
	public static String valueOf(boolean b) {
		return b ? "true" : "false";
	}
	public static String valueOf(char c) {
		char data[] = { c };
		return new String(data, true);
	}
	public static String valueOf(int i) {
		return Integer.toString(i);
	}
	public static String valueOf(long l) {
		return Long.toString(l);
	}
	public static String valueOf(float f) {
		return Float.toString(f);
	}
	public static String valueOf(double d) {
		return Double.toString(d);
	}
valueOf与copyValueOf区别

看以下代码可知，两者完全没有区别的。面试官要是用这个问题秀优越感，直接PASS掉这家公司就好。

摘：String的底层是由char[]实现的：通过一个char[]类型的value属性！早期的String构造器的实现呢，不会拷贝数组的，直接将参数的char[]数组作为String的value属性。然后test[0] = ‘A’;
将导致字符串的变化。为了避免这个问题，提供了copyValueOf方法，每次都拷贝成新的字符数组来构造新的String对象。但是现在的String对象，在构造器中就通过拷贝新数组实现了，所以这两个方面在本质上已经没区别了。https://zhidao.baidu.com/question/195140952.html

public static String valueOf(char data[]) {
		return new String(data);
	}
public static String copyValueOf(char data[]) {
		return new String(data);
	}
空空dream
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
javajdk源码学习-JavaSourceLearn:JDK源码学习
05-24
jdk源码学习 JavaSourceLearn 版本号 版本 corretto-1.8.0_275 方式 逐步阅读源码添加注释、notes文件夹添加笔记 计划学习任务计划 标题为包名，后面序号为优先级1-4，优先级递减 java.lang Object 1 String 1 ...
string.class是什么意思？
m0_60311922的博客
02-14 4390
这个是反射，String.class可以返回一个代表String类的类对象（官方叫类类型，Class Type，因为Java里面万物皆对象，所以类其实也是一个对象）。 另外把String实例化之后，再用getClass();方法也可以返回类对象。比如 String s= new String("lalala"); s.getClass(); 而且String.class== s.getClass(); 也就是说一个类的类对象只能有一个。 转载自：如下图 ...
关于String.class中的方法。
weixin_42603009的博客
05-21 4305
package cnn.bytecode.demo; import java.text.SimpleDateFormat; import java.util.Date; public class StringStudy { public static void main(String[] args) { // 时间的转换 Date date = new Date(); ...
string class操作
qq_41961154的博客
05-05 643
C++ 使用 string 类处理字符串 1.string类中的函数 (1) 构造 (2) 追加 (3) 赋值 (4) 位置与清除 (5) 长度与容量 (6) 比较 (7) 子 串 (8) 搜索 (9) 运算符 2. 注意事项 操作string对象中的字符串内容时，有时会用到“index”。 很多string的函数接受两个数字...
C++ 字符串类（string class）使用详解【学习笔记】
Aliven888的博客
09-26 3077
文档声明： 以下资料均属于本人在学习过程中产出的学习笔记，如果错误或者遗漏之处，请多多指正。并且该文档在后期会随着学习的深入不断补充完善。 资料仅供学习交流使用。 作者：Aliven888 1、简述 String class：字符串是代表字符序列的对象。 标准字符串类通过类似于标准字节容器的接口为此类对象提供支持，但增加了专门设计用于单字节字符字符串的功能。 字符串类是basic_string类模板的实例化，该模板使用char（即字节）作为其字符类型，并具有其默认的char_traits和分配器类型（.
javaSE - 认识字符串（String class）上半部分
ryy1999的博客
12-16 489
在java里面有表示字符串的类 String使用双引号，且双引号中包含任意数量的字符【“abcdef”，“a”】，就是字符串。使用单引号，且单引号中，只包含一个字符【‘a’，‘强’】，就是字符。字符串是一种不可变对象. 它的内容不可改变.String 类的内部实现也是基于 char[] 来实现的, 但是 String 类并没有提供 set 方法之类的来修改内部的字符数组。
Jdk动态代理 底层
01-20
当spring没有手动开启Cglib动态代理，即：或@EnableAspectJAutoProxy(proxyTargetClass = true)，默认使用的就是Jdk动态代理。动态代理的应用范围很广，例如：日志、事务管理、缓存等。本文将模拟@Cacheable，即缓...
（String）字符串原理详解
01-20
1、JDK1.8中String类的源码定义 1.1、主要的类变量如下所示： public final class String implements java.io.Serializable, Comparable, CharSequence { //存储字符串的字符数组 private final char value[]; /...
面试String的特点及重要方法
12-22
大家好，最近呢本人也是在面试，顺便记录一些让我们如何拿到高薪offer的经验和技巧，在我个人觉得，想要面试官对你满意...以主流的JDK1.8来说，String的内部存储结构为char数组 ，源码如下： public final class String
jdk1.6 windows 64位
02-24
组成　JDK包含的基本组件包括：　·javac – 编译器，将源程序转成字节码 ·jar – 打包工具，将相关的类文件打包成一个文件 ·javadoc – 文档生成器，从源码注释中提取文档 ·jdb – debugger，查错工具 ·java –...
String Class - 字符串类型 - 下半部分
2202_75570972的博客
10-12 73
例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。提示：以下是本篇文章正文内容，下面案例可供参考。
String类之详解（三）
qq_40298054的博客
11-17 346
  String类之详解（三） 7、String中转换功能的函数  byte[] getBytes()           使用平台的默认字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。 char[] toCharArray()           将此字符串转换为一个新的字符数组。 static String ...
C++之＜string class＞
gangaue的博客
06-05 415
这篇文章注意学习string类的基本用法和底层原理！！！string class是标准库中模板类的一个实例，底层是类似一个动态数组【1】字符串转整形 【2】字符串相加注意：在OJ中，有关字符串的题目基本以string类的形式出现，而且在常规工作中，为了简单、方便、快捷，基本都使用string类，很少有人去使用C库中的字符串操作函数【string文档介绍】 注意：这个类独立于所使用的编码来处理字节 如果用来处理多字节或变长字符(如UTF-8)的序列，个类的所有成员(如长度或大小)以及它的迭代器，将仍然按照字节
方法重载的坑
hello0_0world的博客
03-27 162
最近在看一些java的源码，看到String的valueOf(Object obj)这段源码，如下： public static String valueOf(Object obj) { return (obj == null) ? "null" : obj.toString(); } 于是我传了个null值进去：如下： System.out.println(S...
剖析java.lang.String类
weixin_46811632的博客
04-04 559
介绍类的结构 public final class String implements java.io.Serializable, Comparable<String>, CharSequence 可以看到String类父类是Object类，并且它实现了3个接口。一个CharSequence（是所有char字符的可读的根接口），一个comparable可比较的接口，以及序列化接口。 源码类上的注释是这样说明String类的： String类是一个字符串，Java...
Java String 源码
迷路北极的鱼
08-12 269
昨天面试，被面试官吊打。问的问题都知道一点，但是不够深入。实现细节，原理什么的好像都没仔细去看。突然意识到，之前的学习好像一直在赶进度，为了面试去学习，只学了点皮毛。痛定思痛，开始看源码了。希望能坚持下去吧。。。。 先奉上面试题： 1.String的底层实现是什么？ 2.String的replace方法是怎么实现的？ 接下来就开始进入正题：String源码探索之路： String 开篇注释：String 是字符串常量，当它被创建之后，它的值就不能被改变（所以很多字符串的操作都是拷贝到一个新的字符数
Java源码学习笔记之lang包——包装类String.class
想当架构师的码农
07-19 344
前言：为学习所发现而记录。 JDK 版本：1.8 按照惯例，还是先把方法全去掉瞅瞅有什么接口，有什么属性再说。 public final class String implements java.io.Serializable, Comparable<String>, CharSequence { private final cha...
docker tag jdk1.8 192.168.12.132:5000/jdk1.8
最新发布
04-15
对于你提到的命令`docker tag jdk1.8 192.168.12.132:5000/jdk1.8`，它的作用是将本地的`jdk1.8`镜像打上一个新的标签`192.168.12.132:5000/jdk1.8`。 具体来说，这个命令将会创建一个新的标签为`192.168.12.132:...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值