2024年最全阿里最新面试必备项之Java的String类，持续更新中！(1)，dubbozookeeper面试题

最后

金三银四到了，送上一个小福利！

本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录

需要这份系统化的资料的朋友，可以点击这里获取

• String 的使用

• @author 13roky

• @date 2021-04-24 10:34

*/

public class StringTest {

/*

String:字符串,使用一对""来表示.

1.String类是被声明为final的,不可被继承.

2.String实现了Serializable接口:标识字符串是支持序列化的. (io流)

实现了Comparable接口:可以比较大小.

3.String内部定义了final char[] value用于存储字符串数字. final表示数组和其元素不能被修改。(为了节省jvm的内存空间jdk9已经改为byte[]类型数组)

4.String:代表不可变的字符序列。简称：不可变性。

体现:1.当对字符串重新赋值时,需要重新指定内存区域赋值,不能使用原有的value进行赋值.(因为原有的value是final的)

2.当对现有的字符串进行连接操作时,需要重新指定内存区域赋值,不能使用原有的value赋值.

3.当调用String的replace()方法修改字符或字符串时,也必须重新指定内存区域赋值,不能使用原有的value赋值.

5.通过字面量的方式(区别于new)给一个字符串赋值,此时的字符串值生命在字符串常量池中.

6.字符串常量池中是不会存储相同内容的字符串的.

*/

@Test

public void test01(){

//字面量的定义方式, 在内存中用的是同一个内存地址

String s1 = “abc”;

String s2 = “abc”;

//==比较的是地址值,为true说明s1和s2在内存中指向的是同一个位置

System.out.println(s1 == s2);//true

s1 = “hello”;

System.out.println(s1);//hello

System.out.println(s2);//abc

System.out.println(“================================================”);

String s3 = “abc”;

s3 += “def”;

System.out.println(s3);//abcdef

System.out.println(s2);//abc

System.out.println(“================================================”);

String s4 = “adb”;

String s5 = s4.replace(‘a’,‘m’);

System.out.println(s4);//abc

System.out.println(s5);//mbc

}

}

图解:

由于字符串常量池中是不会存储相同内容的字符串的，所以在字符串常量池中s1和s2指向同一个内存地址。

由于String内部定义了final char[] value用于存储字符串数字，final表示数组和其元素不能被修改，其也就有了不可变的字符序列的性质。所以改变s1取值为hello后，并不会改变字符串常量池中的对应位置的值，而是会新开辟一个内存地址存放hello值，并且s1指向新的内存地址。

[

](https://jq.qq.com/?_wv=1027&k=0IsBuUb0)

以下图解类似。

[

](https://jq.qq.com/?_wv=1027&k=0IsBuUb0)

1.3 String new方式赋值的内存理解

---

Demo:

package com.broky.commonClass;

import org.junit.jupiter.api.Test;

/**

• String 的使用

• @author 13roky

• @date 2021-04-24 10:34

*/

public class StringTest {

/*

String实例化方式测试:

方式一: 通过字面量定义的方式

方式二: 通过new + 构造器的方式

面试题：String s = new String("abc);方式创建对象，在内存中创建了几个对象？

两个：一个是堆空间中new结构，另一个是char[]对应的常量池中的数据"abc"

*/

@Test

public void test2() {

//通过字面量定义的方式:此时的s1和s2的数据javaEE生命在方法区中的字符串常量池中.

String s1 = “javaEE”;

String s2 = “javaEE”;

//通过new + 构造器的方式:此时的s3和s4保存的地址值是数据在堆空间中开辟空间后对应的地址值.

String s3 = new String(“javaEE”);

String s4 = new String(“javaEE”);

System.out.println(s1 == s2);//true

System.out.println(s1 == s3);//false

System.out.println(s1 == s4);//false

System.out.println(s3 == s4);//false

System.out.println(s3.equals(s4));//true

System.out.println(“=================================================”);

Person p1 = new Person(“Tom”,12);

Person p2 = new Person(“Tom”,12);

System.out.println(p1.name.equals(p2.name));//true

System.out.println(p1.name == p2.name);//true

}

}//加入Java开发交流君样：756584822一起吹水聊天

class Person{

public String name;

public int age;

public Person(String name,int age) {

this.name = name;

this.age = age;

}

}

图解:

new的结构是存在于堆中的，比如String s3 = new String("javaEE");

1.4 String 拼接字面量和变量的方式赋值

---

Demo：

package com.broky.commonClass;

import org.junit.jupiter.api.Test;

/**

• String 的使用

• @author 13roky

• @date 2021-04-24 10:34

*/

public class StringTest {

/*

1.常量与常量的拼接结果在常量池。且常量池中不会存在享同内容的常量。

2.只要其中有一个是变量，结果就在堆中。

3.如果拼接的结果调用intern()方法，返回值就会在常量池中。

*/

@Test

public void test03() {

String s1 = “javaEE”;

String s2 = “hadoop”;

String s3 = “javaEEhadoop”;

String s4 = “javaEE” + “hadoop”;//引号中的为字面量，这里是字面量的拼接

String s5 = s1 + “hadoop”;

String s6 = “javaEE” + s2;

String s7 = s1 + s2;

final String s8 = “hadoop”;

String s9 = “javaEE” + s8;

System.out.println(s3 == s4);//true

System.out.println(s3 == s5);//false

System.out.println(s3 == s6);//false

System.out.println(s3 == s7);//false

System.out.println(s5 == s6);//false

System.out.println(s5 == s7);//false

System.out.println(s6 == s7);//false

System.out.println(s3 == s9);//true

String s10 = s5.intern();//返回值得到的s8使用的常量值中已经存在的”javaEEhadoop“（s5.intern返回的时常量池中对应的内存地址）

System.out.println(s3 == s10);//true

}

}

图解：

• 常量与常量的拼接，结果直接保存在常量池中。如String s4 = “javaEE” + “hadoop”;,如果常量池中存在“javaEEhadoop”，那么s4直接指向其地址。

• 只要拼接赋值时，其中有一个是变量，那么结果就会存在于堆中，如String s5 = s1 + “hadoop”;,栈中的变量名s5指向堆中对应的地址0x0001，堆中的地址又指向常量池的地址0x1214。

• s5指向的是堆中的内存地址0x0001，但是方法s5.intern返回的直接是常量池中的地址。所以String s10 = s5.intern();这行代码会让s10直接指向常量池对应的内存地址。[

](https://jq.qq.com/?_wv=1027&k=0IsBuUb0)

package com.broky.commonClass.exer;

import java.util.Arrays;

/**

• @author 13roky

• @date 2021-04-26 7:27

*/

public class StringValueChangeEx {

String str = new String(“good”);

char[] ch = {‘t’,‘e’,‘s’,‘t’};

public void change(String str,char ch[]){

str = “test ok”;

ch[0] = ‘b’;

}

//加入Java开发交流君样：756584822一起吹水聊天

public static void main(String[] args) {

StringValueChangeEx test01 = new StringValueChangeEx();

test01.change(test01.str, test01.ch);

//这里涉及字符串的拼接,所以会用toString方法,而char中的toString返回的是哈希值,所以要用arrays类

System.out.println(test01.str + " and " + Arrays.toString(test01.ch)); //good and [C@2f4d3709

System.out.println(test01.str); //good

System.out.println(test01.ch); //test

}

}

1.5 String类常用方法

---

• int Length():返回字符的长度:return value.Length

• char charAt(int index):返回某索引处的字return vaLue[index]

• booLean isEmpty():判断是否是空字符牢:return value. Length == 0`

• String toLowercase():使用默认语言环境,将 String中的所有字符转换为小写

• String toUppercase():使用默认语言环境,将 String中的所有字符转换为大写

• String trim():返回字符的副本,忽略前导空白和尾部空白

• boolean equals(Object obj):比较字符的内容是否相同

• booLean equalsIgnoreCase(String anotherString):与equls方法类似,忽略大小写

• String concat(string str):将指定字符牢连接到此字符的结尾。等价于用"+"

• int compare To(String anotherstring):比较两个字符的大小

• String substring(int beginIndex):返回一个新的字符,它是此字符的从 beginIndex开始截取到最后一个子字符串.

• String substring(int beginIndex, int endindex):返回一个新字符串,它是此字符从beginIndex开始截取到endIndex(不包含)的一个子字符串.

Demo:

package com.broky.commonClass;

import org.junit.jupiter.api.Test;

import java.util.Locale;

/**

• @author 13roky

• @date 2021-04-26 21:47

*/

public class CommonMethod {

/*

int Length():返回字符的长度: return value.Length

char charAt( nt index):返回某索引处的字return vaLue[index]

booLean isEmpty():判断是否是空字符牢: return value. Length == 0

String toLowercase():使用默认语言环境,将 String中的所有字符转换为小写

String toUppercase():使用默认语言环境,将 String中的所有字符转换为大写

String trim():返园字符的副本,忽略前导空白和尾部空白

boolean equals(Object obj):比较字符的内容是否相同

booLean equalsIgnoreCase(String anotherString):与equls方法类似,忽略大小写

String concat(string str):将指定字符牢连接到此字符的结尾。等价于用"+"

int compare To(String anotherstring):比较两个字符的大小

String substring(int beginIndex):返回一个新的字符,它是此字符的从 beginIndex开始截取到最后一个子字符串.

String substring(int beginIndex, int endindex):返回一个新字符串,它是此字符从beginIndex开始截取到endIndex(不包含)的一个子字符串.

*/

@Test

public void test01(){

String s1 =“HelloWorld”;

System.out.println(s1.length());

System.out.println(s1.charAt(0));

System.out.println(s1.charAt(9));

System.out.println(s1.isEmpty());

String s2 = s1.toLowerCase();

System.out.println(s1);

System.out.println(s2);

String s3 = " he llo world ";

String s4 = s3.trim();

System.out.println(s3);

System.out.println(s4);

}

@Test

public void test02(){

String s1 = “HelloWorld”;

String s2 = “helloworld”;

System.out.println(s1.equals(s2));

System.out.println(s1.equalsIgnoreCase(s2));

String s3 = “abc”;

String s4 = “def”.concat(s3);

System.out.println(s4);

String s5 = “abc”;

String s6 = new String(“abd”);

System.out.println(s5.compareTo(s6));

String s7 = “13roky学Java”;

String s8 = s7.substring(2,6);

System.out.println(s7);

System.out.println(s8);

}

}

• boolean endsWith(String suffix):测试此字符串是否以指定的后缀结束

• boolean startsWith(String prefix):测试此字符串是否以指定的前缀开始

• boolean startsWith(String prefix, int toffset):测试此字符串从指定索引开始的子字符串是否以指定的前缀开始

• boolean contains(CharSequence s):当且仅当此字符串包含指定的char值序列时,返回true

• int indexOf(String str): 返回指定子字符串在此字符串中第一次出现处的索引

• int indexOf(String str,int fromIndex):返回指定子字符串在此字符串中第一次出现处的索引,从指定的索引处开始

• int lastIndexOf(String str):返回指定子字符串在此字符串中最右边出现处的索引

• int lastIndexOf(String str,int fromIndex):返回指定子字符串在此字符串中最后一次出现处的索引,从指定的索引开始反向搜索(从右往左搜索)indexOf和lastindexOf方法如果未找到,返回结果都是-1

Demo:

package com.broky.commonClass;

import jdk.jfr.DataAmount;

import org.junit.jupiter.api.Test;

import java.util.Locale;

/**

• @author 13roky

• @date 2021-04-26 21:47

*/

public class CommonMethod {

/*

boolean endsWith(String suffix):测试此字符串是否以指定的后缀结束

boolean startsWith(String prefix):测试此字符串是否以指定的前缀开始

boolean startsWith(String prefix, int toffset):测试此字符串从指定索引开始的子字符串是否以指定的前缀开始

boolean contains(CharSequence s):当且仅当此字符串包含指定的char值序列时,返回true

int indexOf(String str): 返回指定子字符串在此字符串中第一次出现处的索引

int indexOf(String str,int fromIndex):返回指定子字符串在此字符串中第一次出现处的索引,从指定的索引处开始

int lastIndexOf(String str):返回指定子字符串在此字符串中最右边出现处的索引

int lastIndexOf(String str,int fromIndex):返回指定子字符串在此字符串中最后一次出现处的索引,从指定的索引开始反向搜索(从右往左搜索)

indexOf和lastindexOf方法如果未找到,返回结果都是-1

*/

@Test

public void test03(){

String str1 = “helloworld”;

boolean b1 = str1.endsWith(“rld”);

System.out.println(b1);

boolean b2 = str1.startsWith(“He”);

System.out.println(b2);

boolean b3 =str1.startsWith(“ll”,2);

System.out.println(b3);

最后

一次偶然，从朋友那里得到一份“java高分面试指南”，里面涵盖了25个分类的面试题以及详细的解析：JavaOOP、Java集合/泛型、Java中的IO与NIO、Java反射、Java序列化、Java注解、多线程&并发、JVM、Mysql、Redis、Memcached、MongoDB、Spring、Spring Boot、Spring Cloud、RabbitMQ、Dubbo 、MyBatis 、ZooKeeper 、数据结构、算法、Elasticsearch 、Kafka 、微服务、Linux。

这不，马上就要到招聘季了，很多朋友又开始准备“金三银四”的春招啦，那我想这份“java高分面试指南”应该起到不小的作用，所以今天想给大家分享一下。

请注意：关于这份“java高分面试指南”，每一个方向专题（25个）的题目这里几乎都会列举，在不看答案的情况下，大家可以自行测试一下水平 且由于篇幅原因，这边无法展示所有完整的答案解析

本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录

需要这份系统化的资料的朋友，可以点击这里获取

System.out.println(b3);

最后

一次偶然，从朋友那里得到一份“java高分面试指南”，里面涵盖了25个分类的面试题以及详细的解析：JavaOOP、Java集合/泛型、Java中的IO与NIO、Java反射、Java序列化、Java注解、多线程&并发、JVM、Mysql、Redis、Memcached、MongoDB、Spring、Spring Boot、Spring Cloud、RabbitMQ、Dubbo 、MyBatis 、ZooKeeper 、数据结构、算法、Elasticsearch 、Kafka 、微服务、Linux。

这不，马上就要到招聘季了，很多朋友又开始准备“金三银四”的春招啦，那我想这份“java高分面试指南”应该起到不小的作用，所以今天想给大家分享一下。

[外链图片转存中…(img-bvqmgzyF-1715123401992)]

请注意：关于这份“java高分面试指南”，每一个方向专题（25个）的题目这里几乎都会列举，在不看答案的情况下，大家可以自行测试一下水平 且由于篇幅原因，这边无法展示所有完整的答案解析

本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录

需要这份系统化的资料的朋友，可以点击这里获取