本文目錄一覽：
JAVA語句
String : 字元串類型
一、構造函數
String(byte[ ] bytes)：通過byte數組構造字元串對象。
String(char[ ] value)：通過char數組構造字元串對象。
String(Sting original)：構造一個original的副本。即：拷貝一個original。
String(StringBuffer buffer)：通過StringBuffer數組構造字元串對象。
例如：
byte[] b = {‘a’,’b’,’c’,’d’,’e’,’f’,’g’,’h’,’i’,’j’};
char[] c = {‘0′,’1′,’2′,’3′,’4′,’5′,’6′,’7′,’8′,’9’};
String sb = new String(b); //abcdefghij
String sb_sub = new String(b,3,2); //de
String sc = new String(c); //0123456789
String sc_sub = new String(c,3,2); //34
String sb_copy = new String(sb); //abcdefghij
System.out.println(“sb:”+sb);
System.out.println(“sb_sub:”+sb_sub);
System.out.println(“sc:”+sc);
System.out.println(“sc_sub:”+sc_sub);
System.out.println(“sb_copy:”+sb_copy);
輸出結果：sb:abcdefghij
sb_sub:de
sc:0123456789
sc_sub:34
sb_copy:abcdefghij
二、方法：
說明：①、所有方法均為public。
②、書寫格式： [修飾符] 返回類型方法名([參數列表])
例如：static int parseInt(String s)
表示此方法(parseInt)為類方法(static),返回類型為(int),方法所需要為String類型。
1. char charAt(int index) ：取字元串中的某一個字元，其中的參數index指的是字元串中序數。字元串的序數從0開始到length()-1 。
例如：String s = new String(“abcdefghijklmnopqrstuvwxyz”);
System.out.println(“s.charAt(5): ” + s.charAt(5) );
結果為： s.charAt(5): f
2. int compareTo(String anotherString) ：當前String對象與anotherString比較。相等關係返回0；不相等時，從兩個字元串第0個字元開始比較，返回第一個不相等的字元差，另一種情況，較長字元串的前面部分恰巧是較短的字元串，返回它們的長度差。
3. int compareTo(Object o) ：如果o是String對象，和2的功能一樣；否則拋出ClassCastException異常。
例如:String s1 = new String(“abcdefghijklmn”);
String s2 = new String(“abcdefghij”);
String s3 = new String(“abcdefghijalmn”);
System.out.println(“s1.compareTo(s2): ” + s1.compareTo(s2) ); //返回長度差
System.out.println(“s1.compareTo(s3): ” + s1.compareTo(s3) ); //返回’k’-‘a’的差
結果為：s1.compareTo(s2): 4
s1.compareTo(s3): 10
4. String concat(String str) ：將該String對象與str連接在一起。
5. boolean contentEquals(StringBuffer sb) ：將該String對象與StringBuffer對象sb進行比較。
6. static String copyValueOf(char[] data) ：
7. static String copyValueOf(char[] data, int offset, int count) ：這兩個方法將char數組轉換成String，與其中一個構造函數類似。
8. boolean endsWith(String suffix) ：該String對象是否以suffix結尾。
例如：String s1 = new String(“abcdefghij”);
String s2 = new String(“ghij”);
System.out.println(“s1.endsWith(s2): ” + s1.endsWith(s2) );
結果為：s1.endsWith(s2): true
9. boolean equals(Object anObject) ：當anObject不為空並且與當前String對象一樣，返回true；否則，返回false。
10. byte[] getBytes() ：將該String對象轉換成byte數組。
11. void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) ：該方法將字元串拷貝到字元數組中。其中，srcBegin為拷貝的起始位置、srcEnd為拷貝的結束位置、字元串數值dst為目標字元數組、dstBegin為目標字元數組的拷貝起始位置。
例如：char[] s1 = {‘I’,’ ‘,’l’,’o’,’v’,’e’,’ ‘,’h’,’e’,’r’,’!’};//s1=I love her!
String s2 = new String(“you!”); s2.getChars(0,3,s1,7); //s1=I love you!
System.out.println( s1 );
結果為：I love you!
12. int hashCode() ：返回當前字元的哈希表碼。
13. int indexOf(int ch) ：只找第一個匹配字元位置。
14. int indexOf(int ch, int fromIndex) ：從fromIndex開始找第一個匹配字元位置。
15. int indexOf(String str) ：只找第一個匹配字元串位置。
16. int indexOf(String str, int fromIndex) ：從fromIndex開始找第一個匹配字元串位置。
例如：String s = new String(“write once, run anywhere!”);
String ss = new String(“run”);
System.out.println(“s.indexOf(‘r’): ” + s.indexOf(‘r’) );
System.out.println(“s.indexOf(‘r’,2): ” + s.indexOf(‘r’,2) );
System.out.println(“s.indexOf(ss): ” + s.indexOf(ss) );
結果為：s.indexOf(‘r’): 1
s.indexOf(‘r’,2): 12
s.indexOf(ss): 12
17. int lastIndexOf(int ch)
18. int lastIndexOf(int ch, int fromIndex)
19. int lastIndexOf(String str)
20. int lastIndexOf(String str, int fromIndex) 以上四個方法與13、14、15、16類似，不同的是：找最後一個匹配的內容。
public class CompareToDemo {
public static void main (String[] args) {
String s1 = new String(“acbdebfg”);
System.out.println(s1.lastIndexOf((int)’b’,7));
}
}
運行結果：5
（其中fromIndex的參數為 7，是從字元串acbdebfg的最後一個字元g開始往前數的位數。既是從字元c開始匹配，尋找最後一個匹配b的位置。所以結果為 5）
21. int length() ：返回當前字元串長度。
22. String replace(char oldChar, char newChar) ：將字元號串中第一個oldChar替換成newChar。
23. boolean startsWith(String prefix) ：該String對象是否以prefix開始。
24. boolean startsWith(String prefix, int toffset) ：該String對象從toffset位置算起，是否以prefix開始。
例如：String s = new String(“write once, run anywhere!”);
String ss = new String(“write”);
String sss = new String(“once”);
System.out.println(“s.startsWith(ss): ” + s.startsWith(ss) );
System.out.println(“s.startsWith(sss,6): ” + s.startsWith(sss,6) );
結果為：s.startsWith(ss): true
s.startsWith(sss,6): true
25. String substring(int beginIndex) ：取從beginIndex位置開始到結束的子字元串。
26.String substring(int beginIndex, int endIndex) ：取從beginIndex位置開始到endIndex位置的子字元串。
27. char[ ] toCharArray() ：將該String對象轉換成char數組。
28. String toLowerCase() ：將字元串轉換成小寫。
29. String toUpperCase() ：將字元串轉換成大寫。
例如：String s = new String(“java.lang.Class String”);
System.out.println(“s.toUpperCase(): ” + s.toUpperCase() );
System.out.println(“s.toLowerCase(): ” + s.toLowerCase() );
結果為：s.toUpperCase(): JAVA.LANG.CLASS STRING
s.toLowerCase(): java.lang.class string
30. static String valueOf(boolean b)
31. static String valueOf(char c)
32. static String valueOf(char[] data)
33. static String valueOf(char[] data, int offset, int count)
34. static String valueOf(double d)
35. static String valueOf(float f)
36. static String valueOf(int i)
37. static String valueOf(long l)
38. static String valueOf(Object obj)
以上方法用於將各種不同類型轉換成Java字元型。這些都是類方法。
Java中String類的常用方法:
public char charAt(int index)
返回字元串中第index個字元；
public int length()
返回字元串的長度；
public int indexOf(String str)
返回字元串中第一次出現str的位置；
public int indexOf(String str,int fromIndex)
返回字元串從fromIndex開始第一次出現str的位置；
public boolean equalsIgnoreCase(String another)
比較字元串與another是否一樣（忽略大小寫）；
public String replace(char oldchar,char newChar)
在字元串中用newChar字元替換oldChar字元
public boolean startsWith(String prefix)
判斷字元串是否以prefix字元串開頭；
public boolean endsWith(String suffix)
判斷一個字元串是否以suffix字元串結尾；
public String toUpperCase()
返回一個字元串為該字元串的大寫形式；
public String toLowerCase()
返回一個字元串為該字元串的小寫形式
public String substring(int beginIndex)
返回該字元串從beginIndex開始到結尾的子字元串；
public String substring(int beginIndex,int endIndex)
返回該字元串從beginIndex開始到endsIndex結尾的子字元串
public String trim()
返回該字元串去掉開頭和結尾空格後的字元串
public String[] split(String regex)
將一個字元串按照指定的分隔符分隔，返回分隔後的字元串數組
實例：
public class SplitDemo{
public static void main (String[] args) {
String date = “2008/09/10”;
String[ ] dateAfterSplit= new String[3];
dateAfterSplit=date.split(“/”); //以「/」作為分隔符來分割date字元串，並把結果放入3個字元串中。
for(int i=0;idateAfterSplit.length;i++)
System.out.print(dateAfterSplit[i]+” “);
}
}
運行結果：2008 09 10 //結果為分割後的3個字元串
實例：
TestString1.java:
程序代碼
public class TestString1
{
public static void main(String args[]) {
String s1 = “Hello World” ;
String s2 = “hello world” ;
System.out.println(s1.charAt(1)) ;
System.out.println(s2.length()) ;
System.out.println(s1.indexOf(“World”)) ;
System.out.println(s2.indexOf(“World”)) ;
System.out.println(s1.equals(s2)) ;
System.out.println(s1.equalsIgnoreCase(s2)) ;
String s = “我是J2EE程序員” ;
String sr = s.replace(‘我’,’你’) ;
System.out.println(sr) ;
}
}
TestString2.java:
程序代碼
public class TestString2
{
public static void main(String args[]) {
String s = “Welcome to Java World!” ;
String s2 = ” magci ” ;
System.out.println(s.startsWith(“Welcome”)) ;
System.out.println(s.endsWith(“World”)) ;
String sL = s.toLowerCase() ;
String sU = s.toUpperCase() ;
System.out.println(sL) ;
System.out.println(sU) ;
String subS = s.substring(11) ;
System.out.println(subS) ;
String s1NoSp = s2.trim() ;
System.out.println(s1NoSp) ;
}
}
=是賦值 比如 int a = 0; int b = 1; a = b; 那麼把b的值賦值給a a為1
== 返回一個boolean值(真或者假)
如上面的 int a = 0; int b = 1; a==b(返回值為false假);
把b賦值給a a = b; 這時再 a==b(返回值就為true真).
JAVA有哪些實用的基本語法
. 表達式語句
int k, i=3, j=4;�
k=i+j;�
System.out.println(〃k=〃+k);
2. 複合語句
class Block {�
public static void main(String args〔〕) {�
int k, i=3, j=4;�
k=i+j;�
System.out.println(〃k=〃+k);�
{�
float f;�
f=j+4.5F;�
i++;�
System.out.println(〃f=〃+f);�
}�
System.out.println(〃i=〃+i);�
}�
}
選擇語句
利用選擇語句結構可以根據條件控制程序流程，改變程序執行的順序。
if語句
if語句的語法格式為：
if (條件表達式)�
s1語句;
這是最簡單的單分支結構。條件表達式的值為true，就執行s1語句，否則就忽略s1語句。s1語句可以是複合語句。
if…else語句
if語句通常與else語句配套使用，形成二分支結構。它的語法格式為：
if (條件表達式)�
s1語句;�
else�
s2語句;
當條件表達式的值為true，就執行s1語句，忽略else和s2語句；條件表達式的值為false，程序忽略s1語句，執行else後面的s2語句。s1和s2都可以是複合語句。
if…else複合結構
對於複雜的情況，可以嵌套使用if…else語句。它的語法格式為：
if (條件表達式1)�
s1語句;�
else if (條件表達式2)�
s2語句;�
else�
s3語句;
在這裡依次計算條件表達式，如果某個條件表達式的值為true，就執行它後面的語句，其餘部分被忽略；所有表達式的值都為false，就執行最後一個else後的s3語句。s1、s2和s3都可以是複合語句。
switch開關語句
雖然嵌套的條件語句可實現多個分支處理，但嵌套太多時容易出錯和混亂，這時可以使用開關語句switch處理。實際上開關語句switch也是一種if…else結構，不過它使你在編程時很容易寫出判斷條件，特別是有很多條件選項的時候。
開關語句switch的語法格式：
switch (表達式) {�
case 常量1:�
語句1;�
break;
case 常量2:�
語句2;�
break;�
……�
default:�
語句n;�
}
其中switch、case、default是關鍵字，default子句可以省略。開關語句先計算表達式，然後將表達式值與各個常量比較，如果表達式值與某個常量相等，就執行該常量後面的語句；如果都不相等，就執行default下面的語句。如果無default子句，就什麼都不執行，直接跳出開關語句。
使用開關語句時，注意以下幾點：
? case後面的常量必須是整數或字元型，而且不能有相同的值；
? 通常在每一個case中都應使用break語句提供一個出口，使流程跳出開關語句。否則，在第一個滿足條件case後面的所有語句都會被執行，這種情況叫做落空。
循環語句
循環可使程序根據一定的條件重複執行某一部分程序代碼，直到滿足終止循環條件為止。
Java中提供的循環語句有： 確定次數循環（for）、條件循環（while）、先執行後判定循環（do）。
for循環語句
如果希望程序的一部分內容按固定的次數重複執行，通常可以使用for循環。for循環採用一個計數器控制循環次數，每循環一次計數器就計數，直到完成給定的循環次數為止。
for循環的語法格式為：
for (表達式1; 表達式2; 表達式3)�
循環體
其中表達式1可以給出計數器的初值，是一個賦值語句；表達式2指出循環結束條件，是一個邏輯表達式；表達式3指出計數器每次的增量，是一個賦值語句。
注意： 計數器可在for語句之前定義，也可在循環括弧中定義。計數器增量為1時常寫成增量運算的形式，以加快運算速度。根據需要，增量可以大於或小於1。增量計算也可以放在循環體中進行，即把表達式3移到循環體內的適當位置，原位置為空。
使用循環語句時常常會遇到死循環的情況，也就是無限制地循環下去。所以在使用for循環時，要注意初值、終值和增量的搭配。終值大於初值時，增量應為正值，終值小於初值時，增量應為負值。編程時必須密切關注計數器的改變，這是實現正常循環避免陷入死循環的關鍵。
while循環語句
while循環不像for循環那麼複雜，while循環只需要一個條件判斷語句，便可以進行循環操作。
while循環的語法格式為：
while (條件表達式) �
循環體
其中while是關鍵字。每次循環之前都要計算條件表達式，其值為true時，就執行一次循環體中的語句，然後再計算條件表達式，決定是否再次執行循環體中的語句；如果條件表達式的值為false時，就跳出循環體，執行循環體下面的語句。
注意： while循環中的條件表達式是邏輯表達式，所以循環體中一定要有改變條件表達式值的語句，使條件表達式的值有機會變為false，否則會陷入死循環。
do…while循環語句
do…while循環與while循環相反，是先執行循環體中的語句，再計算while後面的條件表達式，若條件表達式值為false則跳出循環；否則繼續下一輪循環。
有些情況下，不管條件表達式的值是為true還是false，都希望把指定的語句至少執行一次，那麼就應使用do…while循環。
do…while循環的語法格式為：
do {�
循環體�
} while (條件表達式);
其中do、while是關鍵字。程序首先執行do下面的循環體，然後計算while後麵條件表達式的值，如果其值為true，則重複執行循環體；否則，就結束循環。
與while循環相同，do循環在循環體中也一定要有改變條件表達式值為false的語句，否則會陷入死循環。do…while循環控制並不是很常用，但有時卻非常重要，使用時特別注意不要忘記了while語句結尾處的分號「；」。
循環語句嵌套
ex:做個例子 是累計求和的。
�
public class Sum1 {�
public static void main(String args〔〕) {�
int n=10, sum=0;�
while (n0) {�
sum=0;�
for (int i=1; i=n; i++)�
sum+=i;�
System.out.println(〃前〃+n+〃個數的總和為： 〃+sum);�
n–;�
}�
}�
}
循環語句小結
一個循環一般應包括4部分內容。
（1） 初始化部分： 用來設置循環的一些初始條件，計數器清零等。
（2） 循環體部分： 這是反覆被執行的一段代碼，可以是單語句，也可以是複合語句。
（3） 迭代部分： 這是在當前循環結束，下一次循環開始時執行的語句，常用來使計數器加1或減1。
（4） 終止部分： 通常是一個布爾表達式，每一次循環要對該表達式求值，以驗證是否滿足循環終止條件。
跳轉語句
跳轉語句可以無條件改變程序的執行順序。Java支持3種跳轉語句： break、continue和return。
break語句
break語句提供了一種方便的跳出循環的方法。使用break語句可以立即終止循環，跳出循環體，即使循環沒有結束也如此。
break語句的使用示例，輸出結果如圖3.10所示。
class B {�
public static void main(String args〔〕) {�
boolean test=true;�
int i=0;�
while (test) {�
i=i+2;�
System.out.println(〃i=〃+i);�
if (i=10)�
break;�
}�
System.out.println(〃 i為〃+i+〃時循環結束〃);�
}�
}
帶標號的break語句
標號是標記程序位置的標識符。break語句只能跳轉到循環語句下面的第一條語句上，而帶標號的break語句可直接跳轉到標號處。正常的break只退出一重循環，如果要退出多重循環，可以使用帶標號的break語句。它的語法格式為：
標識符:�
…�
break 標識符;
做個例子說明
運行該工程，正常情況下可從鍵盤接受16個輸入字元，但當輸入b按回車時，break lab1語句就會結束二重循環。
class B1 {�
public static void main(String args〔〕) throws java.io.IOException {�
char ch;��
lab1: // 此處為標號標識符�
for (int i=0; i4; i++)�
for (int j=0; j4; j++) {�
ch=(char)System.in.read();�
System.in.skip(2);�
if (ch==′b′)�
break lab1;//跳到標號標識符處�
if (ch==′c′)�
System.out.println(〃繼續〃);
}�
System.out.println(〃結束兩重循環〃);�
}�
}
continue語句
continue語句只能用在循環結構中，它跳過循環體中尚未執行的語句，重新開始下一輪循環，從循環體第一個語句開始執行。
下面的可以輸出1～9中除6以外所有偶數的平方值
class C2 {�
public static void main(String args〔〕) {�
for (int i=2;i=9;i+=2) {�
if (i==6)�
continue; �
System.out.println(i+〃 的平方 = 〃+i*i); }�
}�
}
帶標號的continue語句
Java也支持帶標號的continue語句，它通常用在嵌套循環的內循環中，可以用標號標出想跳到哪一條語句繼續重複執行程序。其語法格式為：
標識符:�
…�
continue 標識符;
帶標號的continue語句的使用
class C3{�
public static void main(String args〔〕) {�
lab1:�
for (int i=1; i=3; i++)�
for (int j=1; j=3; j++) {�
System.out.println(〃i:〃+i+〃 j:〃+j);�
if (i+j3) {�
System.out.println(〃Continue〃);�
continue lab1;�
}�
System.out.println(〃i=〃+i+〃 j=〃+j);�
}�
}�
}
求100～200間的所有素數。用嵌套的for循環做
public class Find {�
public static void main(String args〔〕) {�
System.out.println(〃 ** 100～200間的所有素數 **〃);�
int n=0;��
outer:�
for (int i=101; i200; i+=2) {�
int k=15;�
for (int j=2; j=k; j++)�
if (i%j==0)�
continue outer;�
System.out.print(〃 〃+i);�
n++;�
if (n10)�
continue;
System.out.println();�
n=0;�
}�
System.out.println();�
}�
}
return語句
return語句用於方法的返回上，當程序執行到return語句時，終止當前方法的執行，返回到調用這個方法的語句。return語句通常位於一個方法體的最後一行，有帶參數和不帶參數兩種形式，帶參數形式的return語句退出該方法並返回一個值。
當方法用void聲明時，說明不需要返回值（即返回類型為空），應使用不帶參數return語句。不帶參數的return語句也可以省略，當程序執行到這個方法的最後一條語句時，遇到方法的結束標誌}就自動返回到調用這個方法的程序中。
帶參數的return語句格式為：
return 表達式;
當程序執行到這個語句時，首先計算「表達式」的值，然後將表達式的值返回到調用該方法的語句。返回值的數據類型必須與方法聲明中的返回值類型一致，可以使用強制類型轉換來使類型一致。
帶參數的return語句的使用
class CircleArea {�
final static double PI=3.14159;�
public static void main(String args〔〕) {�
double r1=8.0, r2=5.0;�
System.out.println(〃半徑為〃+r1+〃的圓面積＝〃+area(r1));�
System.out.println(〃半徑為〃+r2+〃的圓面積＝〃+area(r2));�
}�
static double area(double r) {�
return (PI*r*r);�
}�
}
什麼是java基本語句？
1、表達式語句
一些表達式除了計算表達式的值以外，還有「副作用」，這些表達式可以直接做語句（後面加分號）。
例如：a = 1; // Assignment
x *= 2; // Assignment with operation
i++; // Post-increment
–c; // Pre-decrement
System.out.println(“statement”); // Method invocation
2、複合語句：用一對大括弧括起來的一組語句（在Delphi里，是用begin/end對包含）
凡是可以出現語句的地方，都可以出現複合語句。
3、空語句：單個分號
4、帶標號的語句：語句前面加上標識符（作為語句的標號）和冒號，break語句和continue語句可能會使用標號例如：rowLoop: for(int r = 0; r rows.length; r++) { // A labeled loop
colLoop: for(int c = 0; c columns.length; c++) { // Another one
break rowLoop; // Use a label}}5、局部變數聲明語句 [final] type name [= value] [, name [= value]] …;
局部變數（簡稱變數），是存儲值的位置的符號名，定義在方法中或複合語句中；所有變數在使用前必須先聲明—這就是變數聲明語句；
Java是強類型語言，變數聲明規定了變數的類型，只有該類型的值可以存儲在該變數中；
註：Pascal、C#是強類型語言，C、C++不是
1）最簡單形式：只規定變數類型和變數名；比如
int counter;
2）在變數聲明中包含初始化，即：等號後面的表達式規定了變數的初始值；例如：int i = 0;String s = readLine( );
int[] data = {x+1, x+2, x+3}; // Array initializers
3）單個變數聲明語句可以聲明並且初始化多個變數，條件是這些變數必須有相同的類型；變數之間用逗號隔開。例如：
Java的常用輸入輸出語句？
常用的輸入語句是：
輸入字元串：new Scanner(System.in).next();
輸入整數：new Scanner(System.in).nextInt();
輸入小數：new Scanner(System.in).nextDouble()；
常用的輸出語句：
換行輸出： System.out.println(變數或字元串);
非換行輸出： System.out.print(變數或字元串);
換行輸出錯誤提示（默認是紅字）：System.err.println(變數或字元串);
不換行輸出錯誤提示（默認是紅字）： System.err.print(變數或字元串));
原創文章，作者：AOXA，如若轉載，請註明出處：https://www.506064.com/zh-tw/n/140135.html
微信掃一掃 
支付寶掃一掃 