Java中String常見面試題有哪些
本篇內(nèi)容主要講解“Java中String常見面試題有哪些”，感興趣的朋友不妨來看看。本文介紹的方法操作簡單快捷，實用性強。下面就讓小編來帶大家學習“Java中String常見面試題有哪些”吧!
成都創(chuàng)新互聯(lián)公司是一家以重慶網(wǎng)站建設(shè)、網(wǎng)頁設(shè)計、品牌設(shè)計、軟件運維、seo優(yōu)化、小程序App開發(fā)等移動開發(fā)為一體互聯(lián)網(wǎng)公司。已累計為成都酒樓設(shè)計等眾行業(yè)中小客戶提供優(yōu)質(zhì)的互聯(lián)網(wǎng)建站和軟件開發(fā)服務(wù)。
string基礎(chǔ)
Java String 類
字符串廣泛應用 在 Java 編程中，在 Java 中字符串屬于對象，Java 提供了 String 類來創(chuàng)建和操作字符串。
創(chuàng)建字符串
創(chuàng)建字符串最簡單的方式如下:
String greeting = “菜鳥教程”;
在代碼中遇到字符串常量時，這里的值是 “菜鳥教程“”，編譯器會使用該值創(chuàng)建一個 String 對象。
和其它對象一樣，可以使用關(guān)鍵字和構(gòu)造方法來創(chuàng)建 String 對象。
String 類有 11 種構(gòu)造方法，這些方法提供不同的參數(shù)來初始化字符串，比如提供一個字符數(shù)組參數(shù):
StringDemo.java 文件代碼：
public class StringDemo{ public static void main(String args[]){ char[] helloArray = { 'r', 'u', 'n', 'o', 'o', 'b'}; String helloString = new String(helloArray); System.out.println( helloString ); } }以上實例編譯運行結(jié)果如下：
runoob
注意:String 類是不可改變的，所以你一旦創(chuàng)建了 String 對象，那它的值就無法改變了（詳看筆記部分解析）。
如果需要對字符串做很多修改，那么應該選擇使用 StringBuffer & StringBuilder 類。
String基本用法
創(chuàng)建String對象的常用方法
（1） String s1 = “mpptest”
(2) String s2 = new String();
(3) String s3 = new String(“mpptest”)
String中常用的方法，用法如圖所示，具體問度娘
三個方法的使用： lenth() substring() charAt()
package com.mpp.string; public class StringDemo1 { public static void main(String[] args) { //定義一個字符串"晚來天欲雪 能飲一杯無"
String str = "晚來天欲雪 能飲一杯無";
System.out.println("字符串的長度是："+str.length()); //字符串的雪字打印輸出 charAt(int index)
System.out.println(str.charAt(4)); //取出子串 天欲
System.out.println(str.substring(2)); //取出從index2開始直到最后的子串，包含2
System.out.println(str.substring(2,4)); //取出index從2到4的子串，包含2不包含4 顧頭不顧尾
}
}兩個方法的使用,求字符或子串第一次/最后一次在字符串中出現(xiàn)的位置： indexOf() lastIndexOf()
package com.mpp.string; public class StringDemo2 { public static void main(String[] args) {
String str = new String("趙客縵胡纓 吳鉤胡纓霜雪明"); //查找胡在字符串中第一次出現(xiàn)的位置
System.out.println("\"胡\"在字符串中第一次出現(xiàn)的位置："+str.indexOf("胡")); //查找子串"胡纓"在字符串中第一次出現(xiàn)的位置
System.out.println("\"胡纓\"在字符串中第一次出現(xiàn)的位置"+str.indexOf("胡纓")); //查找胡在字符串中最后一次次出現(xiàn)的位置
System.out.println(str.lastIndexOf("胡")); //查找子串"胡纓"在字符串中最后一次出現(xiàn)的位置
System.out.println(str.lastIndexOf("胡纓")); //從indexof為5的位置，找第一次出現(xiàn)的"吳"
System.out.println(str.indexOf("吳",5));
}
}字符串與byte數(shù)組間的相互轉(zhuǎn)換
package com.mpp.string; import java.io.UnsupportedEncodingException; public class StringDemo3 { public static void main(String[] args) throws UnsupportedEncodingException { //字符串和byte數(shù)組之間的相互轉(zhuǎn)換
String str = new String("hhhabc銀鞍照白馬 颯沓如流星"); //將字符串轉(zhuǎn)換為byte數(shù)組，并打印輸出
byte[] arrs = str.getBytes("GBK"); for(int i=0;i){
System.out.print(arrs[i]);
} //將byte數(shù)組轉(zhuǎn)換成字符串
System.out.println();
String str1 = new String(arrs,"GBK"); //保持字符集的一致，否則會出現(xiàn)亂碼
System.out.println(str1);
}
}==運算符和equals之間的區(qū)別：
引用指向的內(nèi)容和引用指向的地址
package com.mpp.string; public class StringDemo5 { public static void main(String[] args) {
String str1 = "mpp";
String str2 = "mpp";
String str3 = new String("mpp");
System.out.println(str1.equals(str2)); //true 內(nèi)容相同
System.out.println(str1.equals(str3)); //true 內(nèi)容相同
System.out.println(str1==str2); //true 地址相同
System.out.println(str1==str3); //false 地址不同
}
}字符串的不可變性
String的對象一旦被創(chuàng)建，則不能修改，是不可變的
所謂的修改其實是創(chuàng)建了新的對象，所指向的內(nèi)存空間不變
上圖中，s1不再指向imooc所在的內(nèi)存空間，而是指向了hello,imooc
String的連接
@Test
public void contact () {
//1連接方式
String s1 = "a";
String s2 = "a";
String s3 = "a" + s2;
String s4 = "a" + "a";
String s5 = s1 + s2;
//表達式只有常量時，編譯期完成計算
//表達式有變量時，運行期才計算，所以地址不一樣
System.out.println(s3 == s4); //f
System.out.println(s3 == s5); //f
System.out.println(s4 == "aa"); //t
}String、String builder和String buffer的區(qū)別
String是Java中基礎(chǔ)且重要的類，并且String也是Immutable類的典型實現(xiàn)，被聲明為final class，除了hash這個屬性其它屬性都聲明為final,因為它的不可變性，所以例如拼接字符串時候會產(chǎn)生很多無用的中間對象，如果頻繁的進行這樣的操作對性能有所影響。
StringBuffer就是為了解決大量拼接字符串時產(chǎn)生很多中間對象問題而提供的一個類，提供append和add方法，可以將字符串添加到已有序列的末尾或指定位置，它的本質(zhì)是一個線程安全的可修改的字符序列，把所有修改數(shù)據(jù)的方法都加上了synchronized。但是保證了線程安全是需要性能的代價的。
在很多情況下我們的字符串拼接操作不需要線程安全，這時候StringBuilder登場了，StringBuilder是JDK1.5發(fā)布的，它和StringBuffer本質(zhì)上沒什么區(qū)別，就是去掉了保證線程安全的那部分，減少了開銷。
StringBuffer 和 StringBuilder 二者都繼承了 AbstractStringBuilder ，底層都是利用可修改的char數(shù)組(JDK 9 以后是 byte數(shù)組)。
所以如果我們有大量的字符串拼接，如果能預知大小的話最好在new StringBuffer 或者StringBuilder 的時候設(shè)置好capacity，避免多次擴容的開銷。擴容要拋棄原有數(shù)組，還要進行數(shù)組拷貝創(chuàng)建新的數(shù)組。
我們平日開發(fā)通常情況下少量的字符串拼接其實沒太必要擔心，例如
String str = “aa”+”bb”+”cc”;
像這種沒有變量的字符串，編譯階段就直接合成”aabbcc”了，然后看字符串常量池（下面會說到常量池）里有沒有，有也直接引用，沒有就在常量池中生成，返回引用。
如果是帶變量的，其實影響也不大，JVM會幫我們優(yōu)化了。
1、在字符串不經(jīng)常發(fā)生變化的業(yè)務(wù)場景優(yōu)先使用String(代碼更清晰簡潔)。如常量的聲明，少量的字符串操作(拼接，刪除等)。
2、在單線程情況下，如有大量的字符串操作情況，應該使用StringBuilder來操作字符串。不能使用String”+”來拼接而是使用，避免產(chǎn)生大量無用的中間對象，耗費空間且執(zhí)行效率低下（新建對象、回收對象花費大量時間）。如JSON的封裝等。
3、在多線程情況下，如有大量的字符串操作情況，應該使用StringBuffer。如HTTP參數(shù)解析和封裝等。
String類的源碼分析
String類型的intern
public void intern () {
//2：string的intern使用
//s1是基本類型，比較值。s2是string實例，比較實例地址
//字符串類型用equals方法比較時只會比較值
String s1 = "a";
String s2 = new String("a");
//調(diào)用intern時,如果s2中的字符不在常量池，則加入常量池并返回常量的引用
String s3 = s2.intern();
System.out.println(s1 == s2);
System.out.println(s1 == s3);
}String類型的equals
//字符串的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;
// }StringBuffer和Stringbuilder
底層是繼承父類的可變字符數(shù)組value
/**
- The value is used for character storage.
*/
char[] value;
初始化容量為16
/**
- Constructs a string builder with no characters in it and an
- initial capacity of 16 characters.
*/
public StringBuilder() {
super(16);
}
這兩個類的append方法都是來自父類AbstractStringBuilder的方法
public AbstractStringBuilder append(String str) {
if (str == null)
return appendNull();
int len = str.length();
ensureCapacityInternal(count + len);
str.getChars(0, len, value, count);
count += len;
return this;
}
@Override
public StringBuilder append(String str) {
super.append(str);
return this;
}
@Override
public synchronized StringBuffer append(String str) {
toStringCache = null;
super.append(str);
return this;
}append方法
Stringbuffer在大部分涉及字符串修改的操作上加了synchronized關(guān)鍵字來保證線程安全，效率較低。
String類型在使用 + 運算符例如
String a = “a”
a = a + a;時，實際上先把a封裝成stringbuilder，調(diào)用append方法后再用tostring返回，所以當大量使用字符串加法時，會大量地生成stringbuilder實例，這是十分浪費的，這種時候應該用stringbuilder來代替string。
擴容
注意在append方法中調(diào)用到了一個函數(shù)
ensureCapacityInternal(count + len);
該方法是計算append之后的空間是否足夠，不足的話需要進行擴容
public void ensureCapacity(int minimumCapacity) {
if (minimumCapacity > 0)
ensureCapacityInternal(minimumCapacity);
}
private void ensureCapacityInternal(int minimumCapacity) {
// overflow-conscious code
if (minimumCapacity - value.length > 0) {
value = Arrays.copyOf(value,
newCapacity(minimumCapacity));
}
}如果新字符串長度大于value數(shù)組長度則進行擴容
擴容后的長度一般為原來的兩倍 + 2；
假如擴容后的長度超過了jvm支持的最大數(shù)組長度MAX_ARRAY_SIZE。
考慮兩種情況
如果新的字符串長度超過int最大值，則拋出異常，否則直接使用數(shù)組最大長度作為新數(shù)組的長度。
private int hugeCapacity(int minCapacity) {
if (Integer.MAX_VALUE - minCapacity < 0) { // overflow
throw new OutOfMemoryError();
}
return (minCapacity > MAX_ARRAY_SIZE)
? minCapacity : MAX_ARRAY_SIZE;
}刪除
這兩個類型的刪除操作：
都是調(diào)用父類的delete方法進行刪除
public AbstractStringBuilder delete(int start, int end) {
if (start < 0)
throw new StringIndexOutOfBoundsException(start);
if (end > count)
end = count;
if (start > end)
throw new StringIndexOutOfBoundsException();
int len = end - start;
if (len > 0) {
System.arraycopy(value, start+len, value, start, count-end);
count -= len;
}
return this;
}事實上是將剩余的字符重新拷貝到字符數(shù)組value。
這里用到了system.arraycopy來拷貝數(shù)組，速度是比較快的
system.arraycopy方法
轉(zhuǎn)自知乎：
在主流高性能的JVM上（HotSpot VM系、IBM J9 VM系、JRockit系等等），可以認為System.arraycopy()在拷貝數(shù)組時是可靠高效的——如果發(fā)現(xiàn)不夠高效的情況，請報告performance bug，肯定很快就會得到改進。
java.lang.System.arraycopy()方法在Java代碼里聲明為一個native方法。所以最na?ve的實現(xiàn)方式就是通過JNI調(diào)用JVM里的native代碼來實現(xiàn)。
String的不可變性
關(guān)于String的不可變性，這里轉(zhuǎn)一個不錯的回答什么是不可變？
String不可變很簡單，如下圖，給一個已有字符串”abcd”第二次賦值成”abcedl”，不是在原內(nèi)存地址上修改數(shù)據(jù)，而是重新指向一個新對象，新地址。
String和JVM的關(guān)系
下面我們了解下Java棧、Java堆、方法區(qū)和常量池：
Java棧（線程私有數(shù)據(jù)區(qū)）：
每個Java虛擬機線程都有自己的Java虛擬機棧，Java虛擬機棧用來存放棧幀，每個方法被執(zhí)行的時候都會同時創(chuàng)建一個棧幀（Stack Frame）用于存儲局部變量表、操作棧、動態(tài)鏈接、方法出口等信息。每一個方法被調(diào)用直至執(zhí)行完成的過程，就對應著一個棧幀在虛擬機棧中從入棧到出棧的過程。
Java堆（線程共享數(shù)據(jù)區(qū)）：
在虛擬機啟動時創(chuàng)建，此內(nèi)存區(qū)域的唯一目的就是存放對象實例，幾乎所有的對象實例都在這里分配。
方法區(qū)（線程共享數(shù)據(jù)區(qū)）：
方法區(qū)在虛擬機啟動的時候被創(chuàng)建，它存儲了每一個類的結(jié)構(gòu)信息，例如運行時常量池、字段和方法數(shù)據(jù)、構(gòu)造函數(shù)和普通方法的字節(jié)碼內(nèi)容、還包括在類、實例、接口初始化時用到的特殊方法。在JDK8之前永久代是方法區(qū)的一種實現(xiàn)，而JDK8元空間替代了永久代，永久代被移除，也可以理解為元空間是方法區(qū)的一種實現(xiàn)。
常量池（線程共享數(shù)據(jù)區(qū)）：
常量池常被分為兩大類：靜態(tài)常量池和運行時常量池。 靜態(tài)常量池也就是Class文件中的常量池，存在于Class文件中。 運行時常量池（Runtime Constant Pool）是方法區(qū)的一部分，存放一些運行時常量數(shù)據(jù)。
下面重點了解的是字符串常量池：
字符串常量池存在運行時常量池之中（在JDK7之前存在運行時常量池之中，在JDK7已經(jīng)將其轉(zhuǎn)移到堆中）。 字符串常量池的存在使JVM提高了性能和減少了內(nèi)存開銷。 使用字符串常量池，每當我們使用字面量（String s=”1”;）創(chuàng)建字符串常量時，JVM會首先檢查字符串常量池，如果該字符串已經(jīng)存在常量池中，那么就將此字符串對象的地址賦值給引用s（引用s在Java棧中）。如果字符串不存在常量池中，就會實例化該字符串并且將其放到常量池中，并將此字符串對象的地址賦值給引用s（引用s在Java棧中）。
使用字符串常量池，每當我們使用關(guān)鍵字new（String s=new String(”1”);）創(chuàng)建字符串常量時，JVM會首先檢查字符串常量池，如果該字符串已經(jīng)存在常量池中，那么不再在字符串常量池創(chuàng)建該字符串對象，而直接堆中復制該對象的副本，然后將堆中對象的地址賦值給引用s，如果字符串不存在常量池中，就會實例化該字符串并且將其放到常量池中，然后在堆中復制該對象的副本，然后將堆中對象的地址賦值給引用s。
String為什么不可變？
翻開JDK源碼，java.lang.String類起手前三行，是這樣寫的：
public final class String implements java.io.Serializable, Comparable<String>, CharSequence {
/** String本質(zhì)是個char數(shù)組. 而且用final關(guān)鍵字修飾.*/
private final char value[]; ... ...
}首先String類是用final關(guān)鍵字修飾，這說明String不可繼承。再看下面，String類的主力成員字段value是個char[]數(shù)組，而且是用final修飾的。
final修飾的字段創(chuàng)建以后就不可改變。 有的人以為故事就這樣完了，其實沒有。因為雖然value是不可變，也只是value這個引用地址不可變。擋不住Array數(shù)組是可變的事實。
Array的數(shù)據(jù)結(jié)構(gòu)看下圖。
也就是說Array變量只是stack上的一個引用，數(shù)組的本體結(jié)構(gòu)在heap堆。
String類里的value用final修飾，只是說stack里的這個叫value的引用地址不可變。沒有說堆里array本身數(shù)據(jù)不可變。看下面這個例子，
final int[] value={1,2,3} ；
int[] another={4,5,6};
value=another; //編譯器報錯，final不可變 value用final修飾，編譯器不允許我把value指向堆區(qū)另一個地址。
但如果我直接對數(shù)組元素動手，分分鐘搞定。
final int[] value={1,2,3};
value[2]=100; //這時候數(shù)組里已經(jīng)是{1,2,100} 所以String是不可變，關(guān)鍵是因為SUN公司的工程師。
在后面所有String的方法里很小心的沒有去動Array里的元素，沒有暴露內(nèi)部成員字段。private final char value[]這一句里，private的私有訪問權(quán)限的作用都比final大。而且設(shè)計師還很小心地把整個String設(shè)成final禁止繼承，避免被其他人繼承后破壞。所以String是不可變的關(guān)鍵都在底層的實現(xiàn)，而不是一個final?？简灥氖枪こ處煒?gòu)造數(shù)據(jù)類型，封裝數(shù)據(jù)的功力。不可變有什么好處？
這個最簡單地原因，就是為了安全。看下面這個場景（有評論反應例子不夠清楚，現(xiàn)在完整地寫出來），一個函數(shù)appendStr( )在不可變的String參數(shù)后面加上一段“bbb”后返回。appendSb( )負責在可變的StringBuilder后面加“bbb”。
總結(jié)以下String的不可變性。
1 首先final修飾的類只保證不能被繼承，并且該類的對象在堆內(nèi)存中的地址不會被改變。
2 但是持有String對象的引用本身是可以改變的，比如他可以指向其他的對象。
3 final修飾的char數(shù)組保證了char數(shù)組的引用不可變。但是可以通過char[0] = ‘a(chǎn)’來修改值。不過String內(nèi)部并不提供方法來完成這一操作，所以String的不可變也是基于代碼封裝和訪問控制的。
舉個例子
final class Fi {
int a;
final int b = 0;
Integer s;
}
final char[]a = {'a'};
final int[]b = {1};
@Test
public void final修飾類() {
//引用沒有被final修飾，所以是可變的。
//final只修飾了Fi類型，即Fi實例化的對象在堆中內(nèi)存地址是不可變的。
//雖然內(nèi)存地址不可變，但是可以對內(nèi)部的數(shù)據(jù)做改變。
Fi f = new Fi();
f.a = 1;
System.out.println(f);
f.a = 2;
System.out.println(f);
//改變實例中的值并不改變內(nèi)存地址。Fi ff = f; //讓引用指向新的Fi對象，原來的f對象由新的引用ff持有。 //引用的指向改變也不會改變原來對象的地址 f = new Fi(); System.out.println(f); System.out.println(ff); }
這里的對f.a的修改可以理解為char[0] = ‘a(chǎn)’這樣的操作。只改變數(shù)據(jù)值，不改變內(nèi)存值。
String常用工具類
問題描述
很多時候我們需要對字符串進行很多固定的操作,而這些操作在JDK/JRE中又沒有預置,于是我們想到了apache-commons組件,但是它也不能完全覆蓋我們的業(yè)務(wù)需求,所以很多時候還是要自己寫點代碼的,下面就是基于apache-commons組件寫的部分常用方法:
MAVEN依賴
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-lang3</artifactId>
<version>${commons-lang3.version}</version>
</dependency>代碼成果
public class StringUtils extends org.apache.commons.lang3.StringUtils {
/** 值為"NULL"的字符串 */
private static final String NULL_STRING = "NULL";
private static final char SEPARATOR = '_';
/**
* 滿足一下情況返回true<br/>
* ①.入?yún)榭?
* ②.入?yún)榭兆址?
* ③.入?yún)?quot;null"字符串
*
* @param string 需要判斷的字符型
* @return boolean
*/
public static boolean isNullOrEmptyOrNULLString(String string) {
return isBlank(string) || NULL_STRING.equalsIgnoreCase(string);
}
/**
* 把字符串轉(zhuǎn)為二進制碼<br/>
* 本方法不會返回null
*
* @param str 需要轉(zhuǎn)換的字符串
* @return 二進制字節(jié)碼數(shù)組
*/
public static byte[] toBytes(String str) {
return isBlank(str) ? new byte[]{} : str.getBytes();
}
/**
* 把字符串轉(zhuǎn)為二進制碼<br/>
* 本方法不會返回null
*
* @param str 需要轉(zhuǎn)換的字符串
* @param charset 編碼類型
* @return 二進制字節(jié)碼數(shù)組
* @throws UnsupportedEncodingException 字符串轉(zhuǎn)換的時候編碼不支持時出現(xiàn)
*/
public static byte[] toBytes(String str, Charset charset) throws UnsupportedEncodingException {
return isBlank(str) ? new byte[]{} : str.getBytes(charset.displayName());
}
/**
* 把字符串轉(zhuǎn)為二進制碼<br/>
* 本方法不會返回null
*
* @param str 需要轉(zhuǎn)換的字符串
* @param charset 編碼類型
* @param locale 編碼類型對應的地區(qū)
* @return 二進制字節(jié)碼數(shù)組
* @throws UnsupportedEncodingException 字符串轉(zhuǎn)換的時候編碼不支持時出現(xiàn)
*/
public static byte[] toBytes(String str, Charset charset, Locale locale) throws UnsupportedEncodingException {
return isBlank(str) ? new byte[]{} : str.getBytes(charset.displayName(locale));
}
/**
* 二進制碼轉(zhuǎn)字符串<br/>
* 本方法不會返回null
*
* @param bytes 二進制碼
* @return 字符串
*/
public static String bytesToString(byte[] bytes) {
return bytes == null || bytes.length == 0 ? EMPTY : new String(bytes);
}
/**
* 二進制碼轉(zhuǎn)字符串<br/>
* 本方法不會返回null
*
* @param bytes 二進制碼
* @param charset 編碼集
* @return 字符串
* @throws UnsupportedEncodingException 當前二進制碼可能不支持傳入的編碼
*/
public static String byteToString(byte[] bytes, Charset charset) throws UnsupportedEncodingException {
return bytes == null || bytes.length == 0 ? EMPTY : new String(bytes, charset.displayName());
}
/**
* 二進制碼轉(zhuǎn)字符串<br/>
* 本方法不會返回null
*
* @param bytes 二進制碼
* @param charset 編碼集
* @param locale 本地化
* @return 字符串
* @throws UnsupportedEncodingException 當前二進制碼可能不支持傳入的編碼
*/
public static String byteToString(byte[] bytes, Charset charset, Locale locale) throws UnsupportedEncodingException {
return bytes == null || bytes.length == 0 ? EMPTY : new String(bytes, charset.displayName(locale));
}
/**
* 把對象轉(zhuǎn)為字符串
*
* @param object 需要轉(zhuǎn)化的字符串
* @return 字符串, 可能為空
*/
public static String parseString(Object object) {
if (object == null) {
return null;
}
if (object instanceof byte[]) {
return bytesToString((byte[]) object);
}
return object.toString();
}
/**
* 把字符串轉(zhuǎn)為int類型
*
* @param str 需要轉(zhuǎn)化的字符串
* @return int
* @throws NumberFormatException 字符串格式不正確時拋出
*/
public static int parseInt(String str) throws NumberFormatException {
return isBlank(str) ? 0 : Integer.parseInt(str);
}
/**
* 把字符串轉(zhuǎn)為double類型
*
* @param str 需要轉(zhuǎn)化的字符串
* @return double
* @throws NumberFormatException 字符串格式不正確時拋出
*/
public static double parseDouble(String str) throws NumberFormatException {
return isBlank(str) ? 0D : Double.parseDouble(str);
}
/**
* 把字符串轉(zhuǎn)為long類型
*
* @param str 需要轉(zhuǎn)化的字符串
* @return long
* @throws NumberFormatException 字符串格式不正確時拋出
*/
public static long parseLong(String str) throws NumberFormatException {
return isBlank(str) ? 0L : Long.parseLong(str);
}
/**
* 把字符串轉(zhuǎn)為float類型
*
* @param str 需要轉(zhuǎn)化的字符串
* @return float
* @throws NumberFormatException 字符串格式不正確時拋出
*/
public static float parseFloat(String str) throws NumberFormatException {
return isBlank(str) ? 0L : Float.parseFloat(str);
}
/**
* 獲取i18n字符串
*
* @param code
* @param args
* @return
*/
public static String getI18NMessage(String code, Object[] args) {
//LocaleResolver localLocaleResolver = (LocaleResolver) SpringContextHolder.getBean(LocaleResolver.class);
//HttpServletRequest request = ((ServletRequestAttributes)RequestContextHolder.getRequestAttributes()).getRequest();
//Locale locale = localLocaleResolver.resolveLocale(request);
//return SpringContextHolder.getApplicationContext().getMessage(code, args, locale);
return "";
}
/**
* 獲得用戶遠程地址
*
* @param request 請求頭
* @return 用戶ip
*/
public static String getRemoteAddr(HttpServletRequest request) {
String remoteAddr = request.getHeader("X-Real-IP");
if (isNotBlank(remoteAddr)) {
remoteAddr = request.getHeader("X-Forwarded-For");
} else if (isNotBlank(remoteAddr)) {
remoteAddr = request.getHeader("Proxy-Client-IP");
} else if (isNotBlank(remoteAddr)) {
remoteAddr = request.getHeader("WL-Proxy-Client-IP");
}
return remoteAddr != null ? remoteAddr : request.getRemoteAddr();
}
/**
* 駝峰命名法工具
*
* @return toCamelCase(" hello_world ") == "helloWorld"
* toCapitalizeCamelCase("hello_world") == "HelloWorld"
* toUnderScoreCase("helloWorld") = "hello_world"
*/
public static String toCamelCase(String s, Locale locale, char split) {
if (isBlank(s)) {
return "";
}
s = s.toLowerCase(locale);
StringBuilder sb = new StringBuilder();
for (char c : s.toCharArray()) {
sb.append(c == split ? Character.toUpperCase(c) : c);
}
return sb.toString();
}
public static String toCamelCase(String s) {
return toCamelCase(s, Locale.getDefault(), SEPARATOR);
}
public static String toCamelCase(String s, Locale locale) {
return toCamelCase(s, locale, SEPARATOR);
}
public static String toCamelCase(String s, char split) {
return toCamelCase(s, Locale.getDefault(), split);
}
public static String toUnderScoreCase(String s, char split) {
if (isBlank(s)) {
return "";
}
StringBuilder sb = new StringBuilder();
for (int i = 0; i < s.length(); i++) {
char c = s.charAt(i);
boolean nextUpperCase = (i < (s.length() - 1)) && Character.isUpperCase(s.charAt(i + 1));
boolean upperCase = (i > 0) && Character.isUpperCase(c);
sb.append((!upperCase || !nextUpperCase) ? split : "").append(Character.toLowerCase(c));
}
return sb.toString();
}
public static String toUnderScoreCase(String s) {
return toUnderScoreCase(s, SEPARATOR);
}
/**
* 把字符串轉(zhuǎn)換為JS獲取對象值的三目運算表達式
*
* @param objectString 對象串
* 例如：入?yún)?row.user.id/返回：!row?'':!row.user?'':!row.user.id?'':row.user.id
*/
public static String toJsGetValueExpression(String objectString) {
StringBuilder result = new StringBuilder();
StringBuilder val = new StringBuilder();
String[] fileds = split(objectString, ".");
for (int i = 0; i < fileds.length; i++) {
val.append("." + fileds[i]);
result.append("!" + (val.substring(1)) + "?'':");
}
result.append(val.substring(1));
return result.toString();
}
}到此，相信大家對“Java中String常見面試題有哪些”有了更深的了解，不妨來實際操作一番吧！這里是創(chuàng)新互聯(lián)網(wǎng)站，更多相關(guān)內(nèi)容可以進入相關(guān)頻道進行查詢，關(guān)注我們，繼續(xù)學習！
當前題目：Java中String常見面試題有哪些
當前URL：http://jinyejixie.com/article24/gceice.html
成都網(wǎng)站建設(shè)公司_創(chuàng)新互聯(lián)，為您提供小程序開發(fā)、關(guān)鍵詞優(yōu)化、靜態(tài)網(wǎng)站、網(wǎng)站設(shè)計、網(wǎng)站策劃、網(wǎng)站收錄
聲明：本網(wǎng)站發(fā)布的內(nèi)容（圖片、視頻和文字）以用戶投稿、用戶轉(zhuǎn)載內(nèi)容為主，如果涉及侵權(quán)請盡快告知，我們將會在第一時間刪除。文章觀點不代表本網(wǎng)站立場，如需處理請聯(lián)系客服。電話：028-86922220；郵箱：631063699@qq.com。內(nèi)容未經(jīng)允許不得轉(zhuǎn)載，或轉(zhuǎn)載時需注明來源： 創(chuàng)新互聯(lián)
- 中小企業(yè)做全網(wǎng)營銷的必要性 2015-05-07
- 全網(wǎng)營銷占領(lǐng)百度制高點 2014-04-01
- 北京全網(wǎng)營銷外包公司敘述新聞營銷的巨大價值 2015-07-11
- 鳳陽全網(wǎng)營銷推廣都有哪些推廣方式 2020-12-11
- 全網(wǎng)營銷推廣的方式有幾種？ 2015-06-22
- 常見的全網(wǎng)營銷方式都有什么？ 2015-08-30
- 為什么要做全網(wǎng)營銷?全網(wǎng)營銷有哪些好處? 2015-05-14
- 全網(wǎng)營銷推廣，讓成交變得簡單 2016-11-08
- 企業(yè)全網(wǎng)營銷型網(wǎng)站建設(shè)的重點有哪一些？ 2016-11-07
- 全網(wǎng)營銷推廣對企業(yè)非常重要 2022-12-30
- 企業(yè)該如何做好全網(wǎng)營銷推廣？ 2015-06-11
- 全網(wǎng)營銷之seo軟文營銷作用及技巧！ 2016-11-07