stringjava
㈠ java string是什麼類型
Java中String是一個特殊的包裝類數據,有兩種創建形式：
- String s = "abc";
- String s = new String("abc");
第一種先在棧中創建一個對String類的對象引用變數s，然後去查找"abc"是否被保存在字元串常量池中，如果沒有則在棧中創建三個char型的值'a'、'b'、'c'，然後在堆中創建一個String對象object，它的值是剛才在棧中創建的三個char型值組成的數組{'a'、'b'、'c'}，接著這個String對象object被存放進字元串常量池，最後將s指向這個對象的地址，如果"abc"已經被保存在字元串常量池中，則在字元串常量池中找到值為"abc"的對象object，然後將s指向這個對象的地址。
第一種特點：JVM會自動根據棧中數據的實際情況來決定是否有必要創建新對象。
第二種可以分解成兩步1、String object = "abc"; 2、String s = new String(object); 第一步參考第一種創建方式，而第二步由於"abc"已經被創建並保存到字元串常量池中，因此jvm只會在堆中新創建一個String對象，它的值共享棧中已有的三個char型值。
第二種特點：一概在堆中創建新對象，而不管其字元串值是否相等，是否有必要創建新對象。
在講字元串比較前，必須要了解==和equals的區別：
因為java所有類都繼承於Object基類，而Object中equals用==來實現，所以equals和==是一樣的，都是比較對象地址，java api里的類大部分都重寫了equals方法，包括基本數據類型的封裝類、String類等。對於String類==用於比較兩個String對象的地址，equals則用於比較兩個String對象的內容(值)。
㈡ java中string和String的區別
java中string和String的區別如下：
String 一般指 java.lang.String 類，作為字元串
string 一般用來作為一個String類型對象的名稱
packagecom.qiu.lin.he;
publicclassCeShi{
publicstaticvoidmain(String[]args){
Stringstring="測試String和string的區別";
System.out.println(string);
}
}
結果如下：
㈢ java中string什麼意思啊
1. 首先String不屬於8種基本數據類型，String是一個對象。 因為對象的默認值是null，所以String的默認值也是null；但它又是一種特殊的對象，有其它對象沒有的一些特性。
2. new String()和new String(「」)都是申明一個新的空字元串，是空串不是null；
3. String str=」kvill」； String str=new String (「kvill」);的區別： 在這里，我們不談堆，也不談棧，只先簡單引入常量池這個簡單的概念。 常量池(constant pool)指的是在編譯期被確定，並被保存在已編譯的.class文件中的一些數據。它包括了關於類、方法、介面等中的常量，也包括字元串常量。
㈣ java中string怎麼使用
以下是關於string的七種用法，注意哦，記得要時常去查看java的API文檔，那個裡面也有很詳細的介紹
1>獲取
1.1：字元串中包含的字元數，也就是字元串的長度。
int length():獲取長度
1.2：根據位置獲取位置上某個字元。
char charAt(int index)
1.3:根據字元獲取該字元在字元串中的位置。
int indexOf(int ch):返回的是ch在字元串中第一次出現的位置。
int indexOf(int ch,int fromIndex):從fromIndex指定位置開始，獲取ch在字元串中出現的位置。
int indexOf(String str):返回的是str在字元串中第一次出現的位置。
int indexOf(String str，int fromIndex):從fromIndex指定位置開始，獲取str在字元串中出現的位置。
1.4：int lastIndexOf(String str):反向索引。
2>判斷
2.1：字元串中是否包含某一個子串。
boolean contains(str);
特殊之處：indexOf(str):可以索引str第一次出現為止，如果返回-1，表示該str不在字元串中存在。
所以，也可以用於對指定判斷是否包含。
if(str.indexOf("a")!=1)
而且該方法既可以判斷，也可以獲取出現的位置。
2.2：字元串中是否有內容。
boolean isEmpty():原理就是判斷長度是否為0。
2.3：字元串是否以指定內容開頭。
boolean startsWith(str);
2.4：字元串是否以指定內容結尾。
boolean endsWith(str);
2.5：判斷字元內容是否相同，復寫了object類中的equals方法。
boolean equals(str);
2.6:判斷內容是否相同，並忽略大小寫。
boolean.equalsIgnorecase();
3>轉換
3.1：將字元數組轉成字元串。
構造函數：String(char[])
String(char[],offset,count):將字元數組中的一部分轉成字元串
靜態方法：
static String ValueOf(char[]);
static String ValueOf(char[] data,int offset,int count);
static String valueOf(char[]);
3.2：將字元串轉成字元組
char[] tocharArray();
3.3：將位元組數組轉成字元串。
String(byte[])
String(byte[],offset,count):將位元組數組中的一部分轉成字元串
3.4：將字元串轉成位元組數組。
byte[] getBytes()
3.5:將基本數據類型轉成字元串，
static String valueOf(int)
static String valueOf(double)
// 3+"" 與 String.valueOf(3)的值是一樣的
特殊：字元串和位元組數組在轉換過程中，是可以指定編碼的。
4>替換
String replace(oldchar,newchar);
5>切割
String[] split(regex);
6>子串。獲取字元串中的而一部分
String subString(begin);
String subString(begin,end);
7>轉換，去除空格，比較。
7.1：將字元串轉成大寫或小寫
String toUpperCsae() 大轉小
String toLowerCsae() 小轉大
7.2：將字元串兩端的多個空格去除
String trim();
7.3：對兩個字元串進行自然順序的比較
int compareTo(string);
請看如下代碼，下面的代碼都是針對上面string七種用法而進行一一舉例說明：
復制代碼 代碼如下:
class StringMethodDemo
{
public static void method_Zhuanhuan_Qukong_Bijiao()
{
String s = " hello Java ";
//列印結果是：（hello和java前後門都有空格）hello java
sop(s.toUpperCase());
//列印結果是：（HELLO和JAVA前後門都有空格）HELLO JAVA
sop(s.toLowerCase());
//列印及結果是：不帶空格的「hello java」
sop(s.trim());
//比較數的大寫，列印結果是：1，因為b對應ascii值是98，
//a對應是97，所以b-a=1
String s1 = "abc";
String s2 = "aaa";
sop(s1.compareTo(s2));
}
public static void method_sub()
{
String s = "abcdef";
//列印結果是：cdef，從指定位置開始到結尾。如果角標不存在，會出現字元串角標越界。
sop(s.substring(2));
//列印結果是：cd，包含頭，不包含尾。
sop(s.substring(2,4));
}
public static void method_split()
{
String s = "zhangsan,lisi,wangwu";
String[] arr = s.split(",");
for(int x=0; x<arr.length; x++)
{
sop(arr[x]);
}
}
public static void method_replace()
{
String s = "hello java";
//String s1 = s.replace('a','n');
//String s1 = s.replace('w','n'); 如果要替換的字元不存在，返回的還是原串
String s1 = s.replace("java","world");//列印結果是：hello world
sop("s="+s); //列印結果是：hello java因為字元串一旦被初始化，值就不可被改變
sop("s1="+s1);//列印結果是：hello jnvn
}
public static void method_trans()
{
char[] arr = {'a','b','c','d','e','f'};
String s = new String(arr,1,3);
sop("s="+s);//列印結果是：bcd
String s1 = "zxcvbnm";
char[] chs = s1.toCharArray();
for(int x=0; x<chs.length; x++)
{
sop("ch="+chs[x]);//列印結果是：ch=z，x,c,v,b,n,m
}
}
public static void method_is()
{
String str = "ArrayDemo.java";
//判斷文件名稱是否是Array單詞開頭
sop(str.startsWith("Array"));
//判斷文件名稱是否是.java的文件
sop(str.endsWith(".java"));
//判斷文件中是否包含Demo
sop(str.contains("Demo"));
}
public static void method_get()
{
String str = "abcdeakpf";
//長度
sop(str.length());
//根據索引獲取字元
sop(str.charAt(4));
//sop(str.charAt(40));當訪問到字元串中不存在的角標時會發生（字元串角標越界異常）
//根據字元獲取索引
//sop(str.indexOf('a'));
sop(str.indexOf('a',3));//列印的是5，因為角標3是d，
//所以從d後面開始找a，第5個角標是a
//sop(str.indexOf('t',3))列印：-1，如果沒有找到角標，返回-1
//反向索引一個字元出現的位置(從右往左查找，但是角標還是從左開始)
sop(str.lastIndexOf("a"));
}
public static void main(String[] args)
{
method_Zhuanhuan_Qukong_Bijiao();
//method_sub();
//method_split();
//method_replace();
//method_trans();
//method_is();
//method_get();
/*
String s1 = "abc";
String s2 = new String("abc");
String s3 = "abc";
System.out.println(s1==s2);
System.out.println(s1==s3);
*/
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
㈤ java中的string用法
java中的string用法，可以到java api查找方法的使用方式：
classStringMethodDemo
{
publicstaticvoidmethod_Zhuanhuan_Qukong_Bijiao()
{
Strings="helloJava";
//列印結果是：（hello和java前後門都有空格）hellojava
sop(s.toUpperCase());
//列印結果是：（HELLO和JAVA前後門都有空格）HELLOJAVA
sop(s.toLowerCase());
//列印及結果是：不帶空格的「hellojava」
sop(s.trim());
//比較數的大寫，列印結果是：1，因為b對應ascii值是98，
//a對應是97，所以b-a=1
Strings1="abc";
Strings2="aaa";
sop(s1.compareTo(s2));
}
publicstaticvoidmethod_sub()
{
Strings="abcdef";
//列印結果是：cdef，從指定位置開始到結尾。如果角標不存在，會出現字元串角標越界。
sop(s.substring(2));
//列印結果是：cd，包含頭，不包含尾。
sop(s.substring(2,4));
}
publicstaticvoidmethod_split()
{
Strings="zhangsan,lisi,wangwu";
String[]arr=s.split(",");
for(intx=0;x<arr.length;x++)
{
sop(arr[x]);
}
}
publicstaticvoidmethod_replace()
{
Strings="hellojava";
//Strings1=s.replace('a','n');
//Strings1=s.replace('w','n');如果要替換的字元不存在，返回的還是原串
Strings1=s.replace("java","world");//列印結果是：helloworld
sop("s="+s);//列印結果是：hellojava因為字元串一旦被初始化，值就不可被改變
sop("s1="+s1);//列印結果是：hellojnvn
}
publicstaticvoidmethod_trans()
{
char[]arr={'a','b','c','d','e','f'};
Strings=newString(arr,1,3);
sop("s="+s);//列印結果是：bcd
Strings1="zxcvbnm";
char[]chs=s1.toCharArray();
for(intx=0;x<chs.length;x++)
{
sop("ch="+chs[x]);//列印結果是：ch=z，x,c,v,b,n,m
}
}
publicstaticvoidmethod_is()
{
Stringstr="ArrayDemo.java";
//判斷文件名稱是否是Array單詞開頭
sop(str.startsWith("Array"));
//判斷文件名稱是否是.java的文件
sop(str.endsWith(".java"));
//判斷文件中是否包含Demo
sop(str.contains("Demo"));
}
publicstaticvoidmethod_get()
{
Stringstr="abcdeakpf";
//長度
sop(str.length());
//根據索引獲取字元
sop(str.charAt(4));
//sop(str.charAt(40));當訪問到字元串中不存在的角標時會發生（字元串角標越界異常）
//根據字元獲取索引
//sop(str.indexOf('a'));
sop(str.indexOf('a',3));//列印的是5，因為角標3是d，
//所以從d後面開始找a，第5個角標是a
//sop(str.indexOf('t',3))列印：-1，如果沒有找到角標，返回-1
//反向索引一個字元出現的位置(從右往左查找，但是角標還是從左開始)
sop(str.lastIndexOf("a"));
}
publicstaticvoidmain(String[]args)
{
method_Zhuanhuan_Qukong_Bijiao();
//method_sub();
//method_split();
//method_replace();
//method_trans();
//method_is();
//method_get();
/*
Strings1="abc";
Strings2=newString("abc");
Strings3="abc";
System.out.println(s1==s2);
System.out.println(s1==s3);
*/
}
publicstaticvoidsop(Objectobj)
{
System.out.println(obj);
}
}
㈥ string在java中怎麼用
當執行String a="abc";時，JAVA虛擬機會在棧中創建三個char型的值'a'、'b'和'c',然後在堆中創建一個String對象，它的值（value）是剛才在棧中創建的三個char型值組成的數組{'a','b','c'},最後這個新創建的String對象會被添加到字元串池中。如果我們接著執行String b=new String（"abc"）；代碼，由於"abc"已經被創建並保存於字元串池中，因此JAVA虛擬機只會在堆中新創建一個String對象，但是它的值（value）是共享前一行代碼執行時在棧中創建的三個char型值值'a'、'b'和'c'.
String a="abc"; 創建了一個對象 這個對象是在字元串池裡吧 而不是堆里 所以只創建了一個對象
而String b=new String（"abc"）；在字元串常量池以及 堆里都有對象所以是兩個對象
String a="abc"; 在常量池中
new String（"abc"）； 在堆中
String str1 = "abc";引用的對象在棧（或者叫String池）中。
String str1 =new String （"abc"）； 引用的對象在內存/堆中。
㈦ java中string是什麼
就是那個意思。
String 類代表字元串。Java 程序中的所有字元串字面值（如 "abc" ）都作為此類的實例實現。
字元串是常量；它們的值在創建之後不能更改。字元串緩沖區支持可變的字元串。因為 String 對象是不可變的，所以可以共享。例如：
String str = "abc";
等效於：
char data[] = {'a', 'b', 'c'};
String str = new String(data);
㈧ java中String[][] 是什麼東西string[]又是什麼東西
String[][]是二維數組。例如：String[][]str=newString[4][4]，這是創建了一個有4行4列元素的數組。
String[]代表一維數組。例如：String[]str=newString[4]，這個創建一個有4個元素的數組。
String[]代表格式為String數組;如str[1] str[2]等。String[][]代表多維數組了.[][],可以理解為幾行幾列。
String是編程語言中的字元串，String類是不可變的，對String類的任何改變，都是返回一個新的String類對象。
(8)stringjava擴展閱讀：
String的主要功能：
String 類提供的成員執行以下操作：比較 String 對象；返回 String 對象內字元或字元串的索引；復制 String 對象的值；分隔字元串或組合字元串；修改字元串的值；將數字、日期和時間或枚舉值的格式設置為字元串；對字元串進行規范化。
使用 Compare、CompareOrdinal、CompareTo、Equals、EndsWith 和 StartsWith 方法進行比較。
使用 IndexOf、IndexOfAny、LastIndexOf 和 LastIndexOfAny 方法可獲取字元串中子字元串或 Unicode 字元的索引。
使用 Copy 和 CopyTo 可將字元串或子字元串復制到另一個字元串或 Char 類型的數組。
使用 Substring 和 Split 方法可通過原始字元串的組成部分創建一個或多個新字元串；使用 Concat 和 Join 方法可通過一個或多個子字元串創建新字元串。
使用 Insert、Replace、Remove、PadLeft、PadRight、Trim、TrimEnd 和 TrimStart 可修改字元串的全部或部分。
使用 ToLower、ToLowerInvariant、ToUpper 和 ToUpperInvariant 方法可更改字元串中 Unicode 字元的大小寫。
使用 Length 屬性可獲取字元串中 Char 對象的數量；使用 Chars 屬性可訪問字元串中實際的 Char 對象。
使用 IsNormalized 方法可測試某個字元串是否已規范化為特定的範式。使用 Normalize 方法可創建規范化為特定範式的字元串。
㈨ 關於java中String類！！！！
ava字元串類(java.lang.String)是Java中使用最多的類，也是最為特殊的一個類，很多時候，我們對它既熟悉又陌生。
一、從根本上認識java.lang.String類和String池
首先，我建議先看看String類的源碼實現，這是從本質上認識String類的根本出發點。從中可以看到：
1、String類是final的，不可被繼承。public final class String。
2、String類是的本質是字元數組char[], 並且其值不可改變。private final char value[];
然後打開String類的API文檔，可以發現：
3、String類對象有個特殊的創建的方式，就是直接指定比如String x = "abc"，"abc"就表示一個字元串對象。而x是"abc"對象的地址，也叫
做"abc"對象的引用。
4、String對象可以通過「+」串聯。串聯後會生成新的字元串。也可以通過concat()來串聯，這個後面會講述。
6、Java運行時會維護一個String Pool（String池），JavaDoc翻譯很模糊「字元串緩沖區」。String池用來存放運行時中產生的各種字元串，
並且池中的字元串的內容不重復。而一般對象不存在這個緩沖池，並且創建的對象僅僅存在於方法的堆棧區。
5、創建字元串的方式很多，歸納起來有三類：
其一，使用new關鍵字創建字元串，比如String s1 = new String("abc");
其二，直接指定。比如String s2 = "abc";
其三，使用串聯生成新的字元串。比如String s3 = "ab" + "c";
二、String對象的創建
String對象的創建也很講究，關鍵是要明白其原理。
原理1：當使用任何方式來創建一個字元串對象s時，Java運行時（運行中JVM）會拿著這個X在String池中找是否存在內容相同的字元串對象，
如果不存在，則在池中創建一個字元串s，否則，不在池中添加。
原理2：Java中，只要使用new關鍵字來創建對象，則一定會（在堆區或棧區）創建一個新的對象。
原理3：使用直接指定或者使用純字元串串聯來創建String對象，則僅僅會檢查維護String池中的字元串，池中沒有就在池中創建一個，有則罷
了！但絕不會在堆棧區再去創建該String對象。
原理4：使用包含變數的表達式來創建String對象，則不僅會檢查維護String池，而且還會在堆棧區創建一個String對象。
另外，String的intern()方法是一個本地方法，定義為public native String intern(); intern()方法的價值在於讓開發者能將注意力集中到
String池上。當調用 intern 方法時，如果池已經包含一個等於此 String 對象的字元串（該對象由 equals(Object) 方法確定），則返回池
中的字元串。否則，將此 String 對象添加到池中，並且返回此 String 對象的引用。
三、不可變類
不可改變的字元串具有一個很大的優點：編譯器可以把字元串設置為共享。
不可變類String有一個重要的優點－它們不會被共享引用。
是這樣的，JAVA為了提高效率，所以對於String類型進行了特別的處理－－－為string類型提供了串池
定義一個string類型的變數有兩種方式：
string name= "tom ";
string name =new string( "tom ")
使用第一種方式的時候，就使用了串池，
使用第二中方式的時候，就是一種普通的聲明對象的方式
如果你使用了第一種方式，那麼當你在聲明一個內容也是 "tom "的string時，它將使用串池裡原來的那個內存，而不會重新分配內存，也就是說，string saname= "tom ",將會指向同一塊內存
另外關於string類型是不可改變的問題：
string類型是不可改變的，也就是說，當你想改變一個string對象的時候，比如name= "madding "
那麼虛擬機不會改變原來的對象，而是生成一個新的string對象，然後讓name去指向它，如果原來的那個 "tom "沒有任何對象去引用它，虛擬機的垃圾回收機制將接收它。
據說這樣可以提高效率！！！
㈩ java中String是什麼
Java字元串，在開發中用的是比較頻繁的一個類，我們平時要表達一句話的含義，就可以使用字元串(String)來詳細的描述;
Java中已經將字元串進行了很好的封裝，我們可以使用String類將字元串進行隨意的操作，比如字元串的反轉，字元串的分割，字元串的拼接等。
Java String類提供了很多的構造方法，他可以根據我們傳入的不同的參數，轉換成我們想要的數據;比如可以將字元數組，位元組數據，ASCII碼數組轉換為字元串，而且可以根據傳入的參數，判斷將數據的哪些位置的內容轉換為字元串;
在java中除了String之外還有幾個常用的字元串類StringBuffer和StringBuilder，在執行效率方面StringBuilder最快，String最慢，在Java源碼中，String類裡面有個常量private final char value[];用來存儲字元串信息，多以對象一旦創建成功之後，內容就不會改變，但實際上修改值得時候，是不斷的創建回收內容，所以String速率最慢;StringBuffer和StringBuilder都是繼承於AbstractStringBuilder這個類，在這個類中有個變數char[] value;數組進行字元串內容的存儲，變數是可變的，所以不用隨時去分配空間，速度相對於String就會快;對於StringBuffer和StringBuffer兩個類，在源碼中由於StringBuffer中很多方法都被synchronized修飾，所以StringBuffer是線程安全的，也是由於這個原因，StringBuffer速度就相對於StringBuilder慢;
在我們操作比較少量的數據的時候可以使用String，如果數據在多個線程中共享，需要考慮到線程安全，可以使用StringBuffer;
以下為java中String常用的方法示例：
更多java學習方面的問題可以訪問這個網頁，網頁鏈接，希望我的回答能幫到你。