javastring

Ⅰ 在java中String...是什麼意思

1、首先String不屬於8種基本數據類型，String是一個對象。 因為對象的默認值是null，所以String的默認值也是null；但它又是一種特殊的對象，有其它對象沒有的一些特性。

2、關於String的其他知識點

（1）String類是final類，也即意味著String類不能被繼承，並且它的成員方法都默認為final方法。在Java中，被final修飾的類是不允許被繼承的，並且該類中的成員方法都默認為final方法。

（2）String對象一旦被創建就是固定不變的了，對String對象的任何改變都不影響到原對象，相關的任何change操作都會生成新的對象。

（3）每當我們創建字元串常量時，JVM會首先檢查字元串常量池，如果該字元串已經存在常量池中，那麼就直接返回常量池中的實例引用。如果字元串不存在常量池中，就會實例化該字元串並且將其放到常量池中。由於String字元串的不可變性我們可以十分肯定常量池中一定不存在兩個相同的字元串

/**
*採用字面值的方式賦值*/publicvoidtest1(){
Stringstr1="aaa";
Stringstr2="aaa";
System.out.println("===========test1============");
System.out.println(str1==str2);//true可以看出str1跟str2是指向同一個對象}

Ⅱ java中的string方法

從一個byte數組里,從第offset位置開始取,取length長度,按照規定的Charset字元編碼集來獲取byte里的數據簡單示例：public
static
void
main(String[]
args)
{
byte[]
a
=
{'a','b','c','d','e','f','g','h','i'};
String
aa
=
new
String(a,5,3,Charset.defaultCharset());
String
bb
=
new
String(a,5,3,Charset.forName("US-ASCII"));
System.out.println(aa);
System.out.println(bb);
}當然，如果byte數組內存放的用中文字元或者其他字元，測試起來更有意義~

Ⅲ 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類對象。

(3)javastring擴展閱讀：

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什麼意思啊

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中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是什麼

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學習方面的問題可以訪問這個網頁，網頁鏈接，希望我的回答能幫到你。

Ⅶ java中string類的方法有哪些

方法摘要
char charAt(int index)
返回指定索引處的 char 值。
int codePointAt(int index)
返回指定索引處的字元（Unicode 代碼點）。
int codePointBefore(int index)
返回指定索引之前的字元（Unicode 代碼點）。
int codePointCount(int beginIndex, int endIndex)
返回此 String 的指定文本范圍中的 Unicode 代碼點數。
int compareTo(String anotherString)
按字典順序比較兩個字元串。
int compareToIgnoreCase(String str)
不考慮大小寫，按字典順序比較兩個字元串。
String concat(String str)
將指定字元串聯到此字元串的結尾。
boolean contains(CharSequence s)
當且僅當此字元串包含 char 值的指定序列時，才返回 true。
boolean contentEquals(CharSequence cs)
當且僅當此 String 表示與指定序列相同的 char 值時，才返回 true。
boolean contentEquals(StringBuffer sb)
當且僅當此 String 表示與指定的 StringBuffer 相同的字元序列時，才返回 true。
static String ValueOf(char[] data)
返回指定數組中表示該字元序列的字元串。
static String ValueOf(char[] data, int offset, int count)
返回指定數組中表示該字元序列的字元串。
boolean endsWith(String suffix)
測試此字元串是否以指定的後綴結束。
boolean equals(Object anObject)
比較此字元串與指定的對象。
boolean equalsIgnoreCase(String anotherString)
將此 String 與另一個 String 進行比較，不考慮大小寫。
static String format(Locale l, String format, Object... args)
使用指定的語言環境、格式字元串和參數返回一個格式化字元串。
static String format(String format, Object... args)
使用指定的格式字元串和參數返回一個格式化字元串。
byte[] getBytes()
使用平台默認的字元集將此 String 解碼為位元組序列，並將結果存儲到一個新的位元組數組中。
void getBytes(int srcBegin, int srcEnd, byte[] dst, int dstBegin)
已過時。 該方法無法將字元正確轉換為位元組。從 JDK 1.1 起，完成該轉換的首選方法是通過 getBytes() 構造方法，該方法使用平台的默認字元集。
byte[] getBytes(String charsetName)
使用指定的字元集將此 String 解碼為位元組序列，並將結果存儲到一個新的位元組數組中。
void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)
將字元從此字元串復制到目標字元數組。
int hashCode()
返回此字元串的哈希碼。
int indexOf(int ch)
返回指定字元在此字元串中第一次出現處的索引。
int indexOf(int ch, int fromIndex)
從指定的索引開始搜索，返回在此字元串中第一次出現指定字元處的索引。
int indexOf(String str)
返回第一次出現的指定子字元串在此字元串中的索引。
int indexOf(String str, int fromIndex)
從指定的索引處開始，返回第一次出現的指定子字元串在此字元串中的索引。
String intern()
返回字元串對象的規范化表示形式。
int lastIndexOf(int ch)
返回最後一次出現的指定字元在此字元串中的索引。
int lastIndexOf(int ch, int fromIndex)
從指定的索引處開始進行後向搜索，返回最後一次出現的指定字元在此字元串中的索引。
int lastIndexOf(String str)
返回在此字元串中最右邊出現的指定子字元串的索引。
int lastIndexOf(String str, int fromIndex)
從指定的索引處開始向後搜索，返回在此字元串中最後一次出現的指定子字元串的索引。
int length()
返回此字元串的長度。
boolean matches(String regex)
通知此字元串是否匹配給定的正則表達式。
int offsetByCodePoints(int index, int codePointOffset)
返回此 String 中從給定的 index 處偏移 codePointOffset 個代碼點的索引。
boolean regionMatches(boolean ignoreCase, int toffset, String other, int ooffset, int len)
測試兩個字元串區域是否相等。
boolean regionMatches(int toffset, String other, int ooffset, int len)
測試兩個字元串區域是否相等。
String replace(char oldChar, char newChar)
返回一個新的字元串，它是通過用 newChar 替換此字元串中出現的所有 oldChar 而生成的。
String replace(CharSequence target, CharSequence replacement)
使用指定的字面值替換序列替換此字元串匹配字面值目標序列的每個子字元串。
String replaceAll(String regex, String replacement)
使用給定的 replacement 字元串替換此字元串匹配給定的正則表達式的每個子字元串。
String replaceFirst(String regex, String replacement)
使用給定的 replacement 字元串替換此字元串匹配給定的正則表達式的第一個子字元串。
String[] split(String regex)
根據給定的正則表達式的匹配來拆分此字元串。
String[] split(String regex, int limit)
根據匹配給定的正則表達式來拆分此字元串。
boolean startsWith(String prefix)
測試此字元串是否以指定的前綴開始。
boolean startsWith(String prefix, int toffset)
測試此字元串是否以指定前綴開始，該前綴以指定索引開始。
CharSequence subSequence(int beginIndex, int endIndex)
返回一個新的字元序列，它是此序列的一個子序列。
String substring(int beginIndex)
返回一個新的字元串，它是此字元串的一個子字元串。
String substring(int beginIndex, int endIndex)
返回一個新字元串，它是此字元串的一個子字元串。
char[] toCharArray()
將此字元串轉換為一個新的字元數組。
String toLowerCase()
使用默認語言環境的規則將此 String 中的所有字元都轉換為小寫。
String toLowerCase(Locale locale)
使用給定 Locale 的規則將此 String 中的所有字元都轉換為小寫。
String toString()
返回此對象本身（它已經是一個字元串！）。
String toUpperCase()
使用默認語言環境的規則將此 String 中的所有字元都轉換為大寫。
String toUpperCase(Locale locale)
使用給定的 Locale 規則將此 String 中的所有字元都轉換為大寫。
String trim()
返回字元串的副本，忽略前導空白和尾部空白。
static String valueOf(boolean b)
返回 boolean 參數的字元串表示形式。
static String valueOf(char c)
返回 char 參數的字元串表示形式。
static String valueOf(char[] data)
返回 char 數組參數的字元串表示形式。
static String valueOf(char[] data, int offset, int count)
返回 char 數組參數的特定子數組的字元串表示形式。
static String valueOf(double d)
返回 double 參數的字元串表示形式。
static String valueOf(float f)
返回 float 參數的字元串表示形式。
static String valueOf(int i)
返回 int 參數的字元串表示形式。
static String valueOf(long l)
返回 long 參數的字元串表示形式。
static String valueOf(Object obj)
返回 Object 參數的字元串表示形式。
從類 java.lang.Object 繼承的方法
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Ⅷ 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是什麼

就是那個意思。
String 類代表字元串。Java 程序中的所有字元串字面值（如 "abc" ）都作為此類的實例實現。

字元串是常量；它們的值在創建之後不能更改。字元串緩沖區支持可變的字元串。因為 String 對象是不可變的，所以可以共享。例如：

String str = "abc";
等效於：

char data[] = {'a', 'b', 'c'};
String str = new String(data);

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