2.1簡單數據類型
2.1.1 標識符和保留字
1.標識符
程序員對程序中的各個元素加以命名時使用的命名記號稱爲標識符(identifier)。Java語言中,標識符是以字母,下劃線(_),美元符($)開始的一個字符序列,後面可以跟字母,下劃線,美元符,數字。例如,identifier,userName,User_Name,_sys_val, $change爲合法的標識符,而2mail room#,class 爲非法的標識符。
2.保留字
具有專門的意義和用途,不能當作一般的標識符使用,這些標識符稱爲保留字(reserved word),也稱爲關鍵字,下面列出了java語言中的所有保留字:
bstract,break,byte,boolean,catch,case,class,char,continue,default,double,do,else,extends,false,final,float,for,finally,if,import,implements,int,interface,instanceof,long,length,native,new,null,package,private,protected,public,return,switch,synchronized,short,static,super,try,true,this,throw,throws,threadsafe,transient,void,while
。
java語言中的保留字均用小寫字母表示。
2.1.2 數據類型概
1. java中的數據類型劃分
java語言的數據類型有簡單類型和複合類型:
簡單數據類型包括:
整數類型(Integer):byte, short, int, long
浮點類型(Floating):float,double
字符類型(Textual):char
布爾類型(Logical):boolean
複合數據類型包括:
class
interface
數組
2.常量和變量
常量:用保留字final來實現
final typeSpecifier varName=value[,varName[=value]…];
如:final int NUM=100;
變量:是java 程序中的基本存儲單元,它的定義包括變量名、變量類型和作用域幾個部分。其定義格式如下:
typeSpecifier varName[=value[,varName[=value]…];
如:int count; char c='a';
變量的作用域指明可訪問該變量的一段代碼,聲明一個變量的同時也就指明瞭變量的作用域。按作用域來分,變量可以有下面幾種:局部變量、類變量、方法參數和例外處理參數。在一個確定的域中,變量名應該是唯一的。局部變量在方法或方法的一個塊代碼中聲明,它的作用域爲它所在的代碼塊(整個方法或方法中的某塊代碼)。類變量在類中聲明,而不是在類的某個方法中聲明,它的作用域是整個類。方法參數傳遞給方法,它的作用域就是這個方法。例外處理參數傳遞給例外處理代碼,它的作用域就是例外處理部分。
2.1.3 簡單數據類型
1.布爾類型--boolean
布爾型數據只有兩個值true和false,且它們不對應於任何整數值。布爾型變量的定義如:
boolean b=true;
2.字符類型--char
字符常量:
字符常量是用單引號括起來的一個字符,如'a','A';
字符型變量:
類型爲char,它在機器中佔16位,其範圍爲0~65535。字符型變量的定義如:
char c='a'; /*指定變量c爲char型,且賦初值爲'a'*/
3.整型數據
整型常量:
◇ 十進制整數
如123,-456,0
◇ 八進制整數
以0開頭,如0123表示十進制數83,-011表示十進制數-9。
◇ 十六進制整數
以0x或0X開頭,如0x123表示十進制數291,-0X12表示十進制數-18。
整型變量:
數據類型
|
所佔位數
|
數的範圍
|
byte
|
8
|
-27~27-1
|
bhort
|
16
|
-215~215-1
|
int
|
32
|
-231~231-1
|
long
|
64
|
-263~263-1
|
4.浮點型(實型)數據
實型常量:
◇ 十進制數形式
由數字和小數點組成,且必須有小數點,如0.123, 1.23, 123.0
◇ 科學計數法形式
如:123e3或123E3,其中e或E之前必須有數字,且e或E後面的指數必須爲整數。
◇ float型的值,必須在數字後加f或F,如1.23f。
實型變量:
數據類型
|
所佔位數
|
數的範圍
|
float
|
32
|
3.4e-038 ~3.4e+038
|
double
|
64
|
1.7e-038 ~1.7e+038
|
5.簡單數據類型的例子:
【例2.1】
public class Assign {
public static void main (String args [ ] ) {
int x , y ; //定義x,y兩個整型變量
float z = 1.234f ; //指定變量z爲float型,且賦初值爲1.234
double w = 1.234 ; //指定變量w爲double型,且賦初值爲1.234
boolean flag = true ; //指定變量flag爲boolean型,且賦初值爲true
char c ; //定義字符型變量c
String str ; //定義字符串變量str
String str1 = " Hi " ; //指定變量str1爲String型,且賦初值爲Hi
c = ' A ' ; //給字符型變量c賦值'A'
str = " bye " ; //給字符串變量str賦值"bye"
x = 12 ; //給整型變量x賦值爲12
y = 300; //給整型變量y賦值爲300
}
}
2.1.4 簡單數據類型中各類型數據間的優先關係和相互轉換
1.不同類型數據間的優先關係如下:
低------------------------------------------->高
byte,short,char-> int -> long -> float -> double
2.自動類型轉換規則
整型,實型,字符型數據可以混合運算。運算中,不同類型的數據先轉化爲同一類型,然後進行運算,轉換從低級到高級;
操作數1類型
|
操作數2類型
|
轉換後的類型
|
byte、short、char | int | int |
byte、short、char、int | long | long |
byte、short、char、int、long | float | float |
byte、short、char、int、long、float | double | double |
3.強制類型轉換
高級數據要轉換成低級數據,需用到強制類型轉換,如:
int i;
byte b=(byte)i; /*把int型變量i強制轉換爲byte型*/
2.2 運算符和表達式
2.2.1 運算符
對各種類型的數據進行加工的過程成爲運算,表示各種不同運算的符號稱爲運算符,參與運算的數據稱爲操作數,按操作數的數目來分,可有:
◇ 一元運算符:++,--,+,-
◇ 二元運算符:+,-,>
◇ 三元運算符:?:
基本的運算符按功能劃分,有下面幾類:
1 算術運算符: +,―,*,/,%,++,――。
例如:
3+2;
a-b;
i++;
--i;
2 關係運算符: >,<,>=,<=,==,!=。
例如:
count>3;
I==0;
n!=-1;
3 布爾邏輯運算符: !,&&,|| 。
例如:
flag=true;
!(flag);
flag&&false;
4 位運算符: >>,<<,>>>,&,|,^,~。
例如:
a=10011101; b=00111001;則有如下結果:
a<<3 =11101000;
a>>3 =11110011 a>>>3=00010011;
a&b=00011001; a|b=10111101;
~a=01100010; a^b=10100100;
5 賦值運算符 =,及其擴展賦值運算符如+=,―=,*=,/=等。
例如:
i=3;
i+=3; //等效於i=i+3;
6 條件運算符 ? :
例如:result=(sum= =0 ? 1 : num/sum);
7 其它:
包括分量運算符· ,下標運算符 [],實例運算符instanceof,內存分配運算符new,強制類型轉換運算符 (類型),方法調用運算符 () 等。例如:
System.out.println("hello world");
int array1[]=new int[4];
2.2.2 表達式
表達式是由操作數和運算符按一定的語法形式組成的符號序列。一個常量或一個變量名字是最簡單的表達式,其值即該常量或變量的值;表達式的值還可以用作其他運算的操作數,形成更復雜的表達式。
1.表達式的類型
表達式的類型由運算以及參與運算的操作數的類型決定,可以是簡單類型,也可以是複合類型:
布爾型表達式: x&&y||z;
整型表達式: num1+num2;
2.運算符的優先次序
表達式的運算按照運算符的優先順序從高到低進行,同級運算符從左到右進行:
優先次序
|
運算符
|
1
|
. [] ()
|
2
|
++ -- ! ~ instanceof
|
3
|
new (type)
|
4
|
* / %
|
5
|
+ -
|
6
|
>> >>> <<
|
7
|
> < >= <=
|
8
|
= = !=
|
9
|
&
|
10
|
^
|
11
|
|
|
12
|
&&
|
13
|
||
|
14
|
?:
|
15
|
= += -= *= /= %= ^=
|
16
|
&= |= <<= >>= >>>=
|
例如,下述條件語句分四步完成:
Result=sum==0?1:num/sum;
第1步:result=sum==0?1:(num/sum)
第2步:result=(sum==0)?1:(num/sum)
第3步:result=((sum==0)?1:(num/sum))
第4步:result=
2.3控制語句
Java程序通過控制語句來執行程序流,完成一定的任務。程序流是由若干個語句組成的,語句可以是單一的一條語句,如c=a+b,也可以是用大括號{}括起來的一個複合語句。Java中的控制語句有以下幾類:
◇ 分支語句:if-else, switch
◇ 循環語句:while, do-while, for
◇ 與程序轉移有關的跳轉語句:break, continue, return
◇ 例外處理語句:try-catch-finally, throw
◇ 註釋語句://,/* */, /** */
2.3.1 分支語句
分支語句提供了一種控制機制,使得程序的執行可以跳過某些語句不執行,而轉去執行特定的語句。
1.條件語句 if-else
if(boolean-expression)
statement1;
[else statement2;]
2.多分支語句 switch
switch (expression){
case value1 : statement1;
break;
case value2 : statement2;
break;
…………
case valueN : statemendN;
break;
[default : defaultStatement; ]
}
◇ 表達式expression的返回值類型必須是這幾種類型之一:int,byte,char,short。
◇ case子句中的值valueN必須是常量,而且所有case子句中的值應是不同的。
◇ default子句是可選的。
◇break語句用來在執行完一個case分支後,使程序跳出switch語句,即終止switch語句的執行(在一些特殊情況下,多個不同的case值要執行一組相同的操作,這時可以不用break)。
2.3.2 循環語句
循環語句的作用是反覆執行一段代碼,直到滿足終止循環的條件爲止。Java語言中提供的循環語句有:
◇ while語句
◇ do-while語句
◇ for語句
1.while語句
[initialization]
while (termination){
body;
[iteration;]
}
2.do-while語句
[initialization]
do {
body;
[iteration;]
} while (termination);
3.for語句
for (initialization; termination; iteration){
body;
}
◇ for語句執行時,首先執行初始化操作,然後判斷終止條件是否滿足,如果滿足,則執行循環體中的語句,最後執行迭代部分。完成一次循環後,重新判斷終止條件。
◇ 初始化、終止以及迭代部分都可以爲空語句(但分號不能省),三者均爲空的時候,相當於一個無限循環。
◇ 在初始化部分和迭代部分可以使用逗號語句,來進行多個操作。逗號語句是用逗號分隔的語句序列。
for( i=0, j=10; i<j; i++, j--){
……
}
2.3.3 跳轉語句
◇ break語句
◇ continue語句
◇ 返回語句return
1.break語句
◇ 在switch語中,break語句用來終止switch語句的執行。使程序從switch語句後的第一個語句開始執行。
◇ 在Java中,可以爲每個代碼塊加一個括號,一個代碼塊通常是用大括號{}括起來的一段代碼。加標號的格式如下:
BlockLabel: { codeBlock }
break語句的第二種使用情況就是跳出它所指定的塊,並從緊跟該塊的第一條語句處執行。例如:
break BlockLabel;
break語句
a:{…… //標記代碼塊a
b:{…… //標記代碼塊b
c:{…… //標記代碼塊c
break b;
…… //此處的語句塊不被執行
}
…… /此處的語句塊不被執行
}
…… //從此處開始執行
}
2.continue語句
continue語句用來結束本次循環,跳過循環體中下面尚未執行的語句,接着進行終止條件的判斷,以決定是否繼續循環。對於for語句,在進行終止條件的判斷前,還要先執行迭代語句。它的格式爲:
continue;
也可以用continue跳轉到括號指明的外層循環中,這時的格式爲
continue outerLable;
例如:
outer: for( int i=0; i<10; i++ ){ //外層循環
inner: for( int j=0; j<10; j++ ){ //內層循環
if( i<j ){
……
continue outer;
}
……
}
……
}
3.返回語句return
return語句從當前方法中退出,返回到調用該方法的語句處,並從緊跟該語句的下一條語句繼續程序的執行。返回語句有兩種格式:
return expression ;
return;
return語句通常用在一個方法體的最後,否則會產生編譯錯誤,除非用在if-else語句中
2.3.4 例外處理語句
包括try,catch,finally,throw語
2.4 數組
java語言中,數組是一種最簡單的複合數據類型。數組是有序數據的集合,數組中的每個元素具有相同的數據類型,可以用一個統一的數組名和下標來唯一地確定數組中的元素。數組有一維數組和多維數組。
2.4.1 一維數組
1. 一維數組的定義
type arrayName[ ];
類型(type)可以爲Java中任意的數據類型,包括簡單類型和複合類型。
例如:
int intArray[ ];
Date dateArray[];
2.一維數組的初始化
◇ 靜態初始化
int intArray[]={1,2,3,4};
String stringArray[]={"abc", "How", "you"};
◇ 動態初始化
1)簡單類型的數組
int intArray[];
intArray = new int[5];
2)複合類型的數組
String stringArray[ ];
String stringArray = new String[3];/*爲數組中每個元素開闢引用
空間(32位) */
stringArray[0]= new String("How");//爲第一個數組元素開闢空間
stringArray[1]= new String("are");//爲第二個數組元素開闢空間
stringArray[2]= new String("you");// 爲第三個數組元素開闢空間
3.一維數組元素的引用
數組元素的引用方式爲:
arrayName[index]
index爲數組下標,它可以爲整型常數或表達式,下標從0開始。每個數組都有一個屬性length指明它的長度,例如:intArray.length指明數組intArray的長度。
2.4.2 多維數組
Java語言中,多維數組被看作數組的數組。
1.二維數組的定義
type arrayName[ ][ ];
type [ ][ ]arrayName;
2.二維數組的初始化
◇ 靜態初始化
int intArray[ ][ ]={{1,2},{2,3},{3,4,5}};
Java語言中,由於把二維數組看作是數組的數組,數組空間不是連續分配的,所以不要求二維數組每一維的大小相同。
◇ 動態初始化
1) 直接爲每一維分配空間,格式如下:
arrayName = new type[arrayLength1][arrayLength2];
int a[ ][ ] = new int[2][3];
2) 從最高維開始,分別爲每一維分配空間:
arrayName = new type[arrayLength1][ ];
arrayName[0] = new type[arrayLength20];
arrayName[1] = new type[arrayLength21];
…
arrayName[arrayLength1-1] = new type[arrayLength2n];
3) 例:
二維簡單數據類型數組的動態初始化如下,
int a[ ][ ] = new int[2][ ];
a[0] = new int[3];
a[1] = new int[5];
對二維複合數據類型的數組,必須首先爲最高維分配引用空間,然後再順次爲低維分配空間。
而且,必須爲每個數組元素單獨分配空間。
例如:
String s[ ][ ] = new String[2][ ];
s[0]= new String[2];//爲最高維分配引用空間
s[1]= new String[2]; //爲最高維分配引用空間
s[0][0]= new String("Good");// 爲每個數組元素單獨分配空間
s[0][1]= new String("Luck");// 爲每個數組元素單獨分配空間
s[1][0]= new String("to");// 爲每個數組元素單獨分配空間
s[1][1]= new String("You");// 爲每個數組元素單獨分配空間
3.二維數組元素的引用
對二維數組中的每個元素,引用方式爲:arrayName[index1][index2]
例如: num[1][0];
4.二維數組舉例:
【例2.2】兩個矩陣相乘
public class MatrixMultiply{
public static void main(String args[]){
int i,j,k;
int a[][]=new int [2][3]; //動態初始化一個二維數組
int b[][]={{1,5,2,8},{5,9,10,-3},{2,7,-5,-18}};//靜態初始化
一個二維數組
int c[][]=new int[2][4]; //動態初始化一個二維數組
for (i=0;i<2;i++)
for (j=0; j<3 ;j++)
a[i][j]=(i+1)*(j+2);
for (i=0;i<2;i++){
for (j=0;j<4;j++){
c[i][j]=0;
for(k=0;k<3;k++)
c[i][j]+=a[i][k]*b[k][j];
}
}
System.out.println("*******Matrix C********");//打印Matrix C標記
for(i=0;i<2;i++){
for (j=0;j<4;j++)
System.out.println(c[i][j]+" ");
System.out.println();
}
}
}
2.5
字符串的處理
2.5.1 字符串的表示
Java語言中,把字符串作爲對象來處理,類String和StringBuffer都可以用來表示一個字符串。(類名都是大寫字母打頭)
1.字符串常量
字符串常量是用雙引號括住的一串字符。
"Hello World!"
2.String表示字符串常量
用String表示字符串:
String( char chars[ ] );
String( char chars[ ], int startIndex, int numChars );
String( byte ascii[ ], int hiByte );
String( byte ascii[ ], int hiByte, int startIndex, int numChars );
String使用示例:
String s=new String() ; 生成一個空串
下面用不同方法生成字符串"abc":
char chars1[]={'a','b','c'};
char chars2[]={'a','b','c','d','e'};
String s1=new String(chars1);
String s2=new String(chars2,0,3);
byte ascii1[]={97,98,99};
byte ascii2[]={97,98,99,100,101};
String s3=new String(ascii1,0);
String s4=new String(ascii2,0,0,3);
3.用StringBuffer表示字符串
StringBuffer( ); /*分配16個字符的緩衝區*/
StringBuffer( int len ); /*分配len個字符的緩衝區*/
StringBuffer( String s ); /*除了按照s的大小分配空間外,再分配16個
字符的緩衝區*/
2.5.2 訪問字符串
1.類String中提供了length( )、charAt( )、indexOf( )、lastIndexOf( )、getChars( )、getBytes( )、toCharArray( )等方法。
◇ public int length() 此方法返回字符串的字符個數
◇ public char charAt(int index) 此方法返回字符串中index位置上的字符,其中index 值的 範圍是0~length-1
◇ public int indexOf(int ch)
public lastIndexOf(in ch)
返回字符ch在字符串中出現的第一個和最後一個的位置
◇ public int indexOf(String str)
public int lastIndexOf(String str)
返回子串str中第一個字符在字符串中出現的第一個和最後一個的位置
◇ public int indexOf(int ch,int fromIndex)
public lastIndexOf(in ch ,int fromIndex)
返回字符ch在字符串中位置fromIndex以後出現的第一個和最後一個的位置
◇ public int indexOf(String str,int fromIndex)
public int lastIndexOf(String str,int fromIndex)
返回子串str中的第一個字符在字符串中位置fromIndex後出現的第一個和最後一個的位置。
◇ public void getchars(int srcbegin,int end ,char buf[],int dstbegin)
srcbegin 爲要提取的第一個字符在源串中的位置, end爲要提取的最後一個字符在源串中的位置,字符數組buf[]存放目的字符串, dstbegin 爲提取的字符串在目的串中的起始位置。
◇public void getBytes(int srcBegin, int srcEnd,byte[] dst, int dstBegin)
參數及用法同上,只是串中的字符均用8位表示。
2.類StringBuffer提供了 length( )、charAt( )、getChars( )、capacity()等方法。
方法capacity()用來得到字符串緩衝區的容量,它與方法length()所返回的值通常是不同的。
2.5.3 修改字符串
修改字符串的目的是爲了得到新的字符串,類String和類StringBuffer都提供了相應的方法。有關各個方法的使用,參考java 2 API。
1.String類提供的方法:
concat( )
replace( )
substring( )
toLowerCase( )
toUpperCase( )
◇ public String contat(String str);
用來將當前字符串對象與給定字符串str連接起來。
◇ public String replace(char oldChar,char newChar);
用來把串中出現的所有特定字符替換成指定字符以生成新串。
◇ public String substring(int beginIndex);
public String substring(int beginIndex,int endIndex);
用來得到字符串中指定範圍內的子串。
◇ public String toLowerCase();
把串中所有的字符變成小寫。
◇ public String toUpperCase();
把串中所有的字符變成大寫。
2.StringBuffer類提供的方法:
append( )
insert( )
setCharAt( )
如果操作後的字符超出已分配的緩衝區,則系統會自動爲它分配額外的空間。
◇ public synchronized StringBuffer append(String str);
用來在已有字符串末尾添加一個字符串str。
◇ public synchronized StringBuffer insert(int offset, String str);
用來在字符串的索引offset位置處插入字符串str。
◇ public synchronized void setCharAt(int index,char ch);
用來設置指定索引index位置的字符值。
注意:String中對字符串的操作不是對源操作串對象本身進行的,而是對新生成的一個源操作串對象的拷貝進行的,其操作的結果不影響源串。
相反,StringBuffer中對字符串的連接操作是對源串本身進行的,操作之後源串的值發生了變化,變成連接後的串。
2.5.4 其它操作
1.字符串的比較
String中提供的方法:
equals( )和equalsIgnoreCase( )
它們與運算符'= ='實現的比較是不同的。運算符'= ='比較兩個對象是否引用同一個實例,而equals( )和equalsIgnoreCase( )則比較 兩個字符串中對應的每個字符值是否相同。
2.字符串的轉化
java.lang.Object中提供了方法toString( )把對象轉化爲字符串。
3.字符串"+"操作
運算符'+'可用來實現字符串的連接:
String s = "He is "+age+" years old.";
其他類型的數據與字符串進行"+"運算時,將自動轉換成字符串。具體過程如下:
String s=new StringBuffer("he is").append(age).append("years old").toString();
注意:除了對運算符"+"進行了重載外,java不支持其它運算符的重載。
【本講小結】
java中的數據類型有簡單數據類型和複合數據類型兩種,其中簡單數據類型包括整數類型、浮點類型、字符類型和布爾類型;複合數據類型包含類、接口和數組。表達式是由運算符和操作數組成的符號序列,對一個表達式進行運算時,要按運算符的優先順序從高向低進行,同級的運算符則按從左到右的方向進行。條件語句、循環語句和跳轉語句是java中常用的控制語句。
數組是最簡單的複合數據類型,數組是有序數據的集合,數組中的每個元素具有相同的數據類型,可以用一個統一的數組名和下標來唯一地確定數組中的元素。Java中,對數組定義時並不爲數組元素分配內存,只有初始化後,才爲數組中的每一個元素分配空間。已定義的數組必須經過初始化後,纔可以引用。數組的初始化分爲靜態初始化和動態初始化兩種,其中對複合數據類型數組動態初始化時,必須經過兩步空間分配:首先,爲數組開闢每個元素的引用空間;然後,再爲每個數組元素開闢空間。Java中把字符串當作對象來處理, java.lang.String類提供了一系列操作字符串的方法,使得字符串的生成、訪問和修改等操作容易和規範。