Java總結第八章
本章內容：
1.基本資料型別的包裝類
2.String類，StringBuffer類，StringBuilder類
3.內部類
一.基本資料型別的包裝類
1.基本資料型別有時要轉成引用資料型別，所以java針對所有的基本資料型別都提供了對應的包裝類。但包裝類並不是用來取代基本型別的。
下面即對基本資料型別對應的包裝類：
|
基本資料型別 |
包裝類 |
|
byte（位元組） |
java.lang.Byte |
|
char（字元） |
java.lang.Character |
|
short（短整型） |
java.lang.Short |
|
int（整型） |
java.lang.Integer |
|
long（長整型） |
java.lang.Long |
|
float（浮點型） |
java.lang.Float |
|
double（雙精度） |
java.lang.Double |
|
boolean（布林） |
java.lang.Boolean |
2.包裝類和基本資料型別
基本資料型別轉換為包裝類的語法：
Integer intValue = new Integer(21);
包裝類轉換為基本資料型別的語法：
Integer integerId=new Integer(25);
int intId=integerId.intValue();
3.自動裝箱、拆箱
JDK5.0中為基本資料型別提供了自動裝箱
裝箱：將基本資料型別包裝為對應的包裝類物件
拆箱：將包裝類物件轉換成對應的基本資料型別下面就char型來詮釋自動裝箱拆箱
package boxing; public class CharacterDemo { public static void main(String[] args) { Character c='a'; // 自動裝箱 char x=c; // 自動拆箱 System.out.println("變為大寫："+Character.toUpperCase('a')); System.out.println("變為小寫："+Character.toLowerCase('Y')); } }
執行截圖如下：
package boxing;
public class IntegerDemo {
public static void main(String[] args) {
System.out.println("int的最大值："+Integer.MAX_VALUE);
System.out.println("int的最小值："+Integer.MIN_VALUE);
Integer a=100; // 自動裝箱
int b=a; // 自動拆箱
String str="123";
int temp=Integer.parseInt(str); // 將字串轉換為int
System.out.println(temp+5);
}
}執行結果截圖如下：
二.字串相關類
1.String類
* String代表字串型別，字串內容本身不可改變，字串儲存於“字串常量池“中。
補充：棧記憶體一般放區域性變數的基本資料型別。物件的引用型別。
靜態區放靜態，對所有例項化物件共享。
字串常量值其實也放在堆記憶體中，但單獨拿出來講就在字串常量池裡，常量池屬於堆記憶體。
* String的兩種例項化方式：
a.直接賦值法（常用）
eg: String str=“Hello”;
b.通過new操作符例項化
eg：String str=new String（“hello”）；
* 一個字串就是一個String類的匿名物件。所謂匿名物件，就是在堆記憶體中開闢了空間，但在棧記憶體中並沒有引用指向的物件。
例如：
package string.trap;
public class StringDemo {
public static void main(String[] args) {
String str="hello";
change(str);
System.out.println(str);
}
public static void change(String str){
str="中國";
}
}在此時change裡的方法的字串並沒有被指向，這個部分是在堆記憶體中另開闢的空間，但在棧記憶體中沒有引用指向物件，故輸出結果依然是“hello”。
執行結果截圖為：
* 字串常用方法：
1.public String(byte[] bytes)
使用平臺的預設字符集解碼，將位元組陣列轉換為字串
2.public String(byte[] bytes,Charset charset)
使用指定字符集解碼，將位元組陣列轉換為字串
3.public char charAt(int index)
根據索引位置獲取字串中的某個字元
4.public boolean contains(CharSequence s)
判斷當前物件代表的字串是否包含引數字串內容
5.public boolean equals(Object anObject)
判斷字串內容是否相同
6.public byte[] getBytes()
將字串轉換為位元組陣列
7.public int indexOf(String str)
返回引數字串在當前字串中的索引位置
8.public int lastIndexOf(String str)
從後往前找引數字串，返回引數字串在當前字串中的索引位置
9.public int length()
返回當前字串的長度
10.public String toLowerCase()
將字串轉換為小寫
對以上常用方法進行驗證：
package string;
public class StringMethod {
public static void main(String[] args) {
String str="中華人民共和國";
System.out.println(str.charAt(2)); // 根據索引位置獲取字串中的某個字元
System.out.println(str.contains("人民")); // 判斷當前物件代表的字串是否包含引數字串內容
System.out.println(str.indexOf("民共和"));
// 將"abcde"的d變為大寫
String s1="abcdedx";
System.out.println("從後往前找d:"+s1.lastIndexOf("d"));
String s2="wxYz";
System.out.println(s2.toUpperCase());
System.out.println(s2.toLowerCase());
System.out.println("中華人民共和國".substring(3));
System.out.println("中華人民共和國".substring(3,6));
String s3=" 中 國 人 ";
System.out.println("s3的長度："+s3.length());
System.out.println("刪除了前後空格後的長度："+s3.trim().length());
System.out.println("*************************************");
String country="中國,美國,俄羅斯,義大利,瑞典";
String[] array=country.split(",");
System.out.println("遍歷拆分後的字串：");
for(String cou:array){
System.out.print(cou+" ");
}
}
}
2.StringBuffer類，StringBuilder類
這兩個類功能幾乎一樣，代表可變的字元序列，稱為字串緩衝區，工作原理是：預先申請一塊記憶體，存放字元序列，如果字元序列滿了，會重新改變快取區的大小，以容納更多的字元序列。
StringBuffer，StringBuilder，String的區別：
StringBuffer和StringBuilder是可變物件，若連續操作String物件則會產生大量垃圾，而且“斷開------連線”很頻繁。
StringBuffer與StringBuilder相比，StringBuilder是執行緒不安全的。
就StringBuffer舉例：
package stringbuffer;
public class StringBufferMethod {
public static void main(String[] args) {
StringBuffer sb=new StringBuffer();
sb.append("中國").append("香水").append("Java");
System.out.println("反轉之前：");
System.out.println(sb.toString());
sb.reverse(); // 反轉緩衝區的內容
System.out.println("反轉之後：");
System.out.println(sb.toString());
StringBuffer sb2=new StringBuffer();
sb2.append(false).append(12.5).append("hello");
sb2.insert(1,true); // 在索引為1處插入true
System.out.println(sb2);
}
}
執行結果截圖：
三.內部類
1.在類的內部定義另一個類。如果在類Outer的內部再定義一個類Inner，此時Inner就稱為內部類，而Outer則稱為外部類。
2.內部類的定義格式
public class 外部類{
//外部類成員
public class 內部類{
//內部類成員
}
}
3.內部類在編譯完成後也會產生.class檔案，而檔名稱則是”外部類名稱$內部類名稱.class”
** 什麼時候使用內部類？
類中有屬性或者方法不足以描述某個複雜的問題，但這個問題又包含在類中，這時就應該使用內部類。
使用內部類的好處：
1 可以方便地訪問外部類的私有屬性
2 減少了類檔案編譯後的產生的位元組碼檔案的大小
缺點：使程式結構不清楚
**** 成員內部類
成員內部類中不能定義static變數
成員內部類持有外部類的引用
外部例項化成員內部類的格式：外部類.內部類 內部類物件=外部類例項.new 內部類();
如：
package inner.member;
public class Outer {
private String name="中國人";
// 成員內部類
class MemberInner{
public void method(){
System.out.println("內部類可以訪問外部類的私有屬性："+name);
}
}
public MemberInner getMemberInstance(){
return new MemberInner();
}
}
package inner.member;
public class TestMember {
public static void main(String[] args) {
Outer out=new Outer();
out.getMemberInstance().method(); // 通過在外部類中的成員方法中獲取內部類物件
// 外部類.內部類 內部類物件=外部類例項.new 內部類();
Outer.MemberInner in=out.new MemberInner();
in.method();
}
}
**** 靜態內部類
如果一個內部類使用static宣告，則此內部類就稱為靜態內部類，其實也相當於外部類。可以通過外部類.內部類來訪問。
靜態內部類不會持有外部類的引用，建立時可以不用建立外部類物件
靜態內部類可以訪問外部的靜態變數，如果訪問外部類的非static成員變數必須通過外部類的例項訪問
外部例項化靜態內部類物件的格式：
外部類.內部類 內部類物件= new 外部類.內部類();
如：
package inner.staticdemo;
public class Outer {
private String name="中國";
private static int population=14;
static class StaticInner{
public void method(){
System.out.println("靜態內部類直接訪問外部類的static屬性："+population);
Outer out=new Outer();
System.out.println("在靜態內部類中通過外部類物件訪問非static屬性："+out.name);
}
}
public static StaticInner getStaticInner(){
return new StaticInner();
}
}package inner.staticdemo;
public class TestStaticInner {
public static void main(String[] args) {
Outer.getStaticInner().method();
System.out.println("************************");
Outer.StaticInner in=new Outer.StaticInner();
in.method();
}
}截圖如下：
*** 區域性內部類
局域內部類是定義在一個方法中的內嵌類，所以類的作用範圍僅限於該方法中，而類生成的物件也只能在該方法中使用。
局域內部類不能包含靜態成員
特別注意：局域內部類要想訪問包含其的方法中的引數，則方法中的引數前必須加上final關鍵字(JDK<=1.7)。
如：
package inner.local;
public class Outer {
private String name="中國";
public void func(int x){
class LocalInner{
public void method(){
System.out.println("局域內部類訪問外部類的屬性："+name);
System.out.println("局域內部類訪問包含其方法的引數"+x);
}
}
new LocalInner().method(); // 在局域內部類所在的方法中例項化局域內部類物件，並呼叫其方法
}
}package inner.local;
public class TestLocal {
public static void main(String[] args) {
Outer out=new Outer();
out.func(5);
}
}
*** 匿名內部類
如果一個內部類在整個操作中只使用一次的話，就可以定義為匿名內部類
沒有名字的內部類，這是java為了方便我們編寫程式而設計的一個機制，因為有時候有的內部類只需要建立一個它的物件就可以了，以後再不會用到這個類，這時候使用匿名內
部類就比較合適。
如：
package inner.anonymity;
public interface Jumping {
public void jump();
}package inner.anonymity;
public class TestAnonumity {
public static void main(String[] args) {
Jumping j=new Jumping(){
@Override
public void jump() {
System.out.println("某人跳樓了...");
}
};
j.jump();
}
}