java常用類（一）

• 包裝類

  一、為什麼需要 包裝類?

  JAVA并不是純面向對象的語言。Java語言是一個面向對象的語言，但是Java中的基本資料類型卻

  是不面向對象的。但是我們在實際使用中經常需要将基本資料轉化成對象，便于操作。比如：

  集合的操作中。 這時，我們就需要将基本類型資料轉化成對象！

  二、包裝類均位于java.lang包，包裝類和基本資料類型的對應關系：

基本資料類型	包裝類
byte	Byte
boolean	Boolean
short	Short
char	Character
int	Integer
long	Long
float	Float
double	Double

三、包裝類的作用：

①提供：字元串、基本類型資料、對象之間互相轉化的方式！

②包含每種基本資料類型的相關屬性如最大值、最小值等

③所有的包裝類(Wrapper Class)都有類似的方法，掌握一個其他都類似！

package com.qhit.test;

/**
 * 測試包裝類
 * Integer類的使用。其他包裝類用法類似。
 * @author 梁雪
 *
 */
public class TestWrappedClass {
	public static void main(String[] args) {
		//基本資料類型轉成包裝類對象
		Integer   a  = new  Integer(3);
		Integer   b  = Integer.valueOf(30);   

		//把包裝類對象轉成基本資料類型
		int   c  =  b.intValue();
		double d = b.doubleValue();
		
		//把字元串轉成包裝類對象
		Integer  e = new  Integer("9999");
		Integer  f = Integer.parseInt("999888");
		
		//把包裝類對象轉成字元串
		String   str = f.toString();    //""+f
		
		//常見的常量
		System.out.println("int類型最大的整數："+Integer.MAX_VALUE);
		
		
		
		
	}
}

           

int類型最大的整數：2147483647

• 自動裝箱和自動拆箱

  一、 自動裝箱-boxing就是自動将基本資料類型轉換為包裝器類型；

基本類型就自動地封裝到與它相同類型的包裝中

Integer i = 100;

本質上是，編譯器編譯時為我們添加了： Integer i = Integer.valueOf(100);

二、自動拆箱autounboxing就是自動将包裝器類型轉換為基本資料類型。

包裝類對象自動轉換成基本類型資料。如：

int a = new Integer(100);

本質上，編譯器編譯時為我們添加了：

int a = new Integer(100).intValue();

看下面代碼 測試自動裝箱、自動拆箱

/**
 * 測試自動裝箱、自動拆箱
 * @author 梁雪
 *
 */
public class TestAutoBox {
	public static void main(String[] args) {
		Integer   a  = 234;   //自動裝箱。Integer  a = Integer.valueOf(234);
		int   b =  a;				//自動拆箱。編譯器會修改成：int  b = a.intValue();
		
		Integer  c = null; 
//		if(c!=null){
//			int  d = c;			//自動拆箱：調用了：c.intValue()
//		}
		

		//緩存[-128,127]之間的數字。實際就是系統初始的時候，建立了[-128,127]之間的一個緩存數組。
		//當我們調用valueOf()的時候，首先檢查是否在[-128,127]之間，如果在這個範圍則直接從緩存數組中拿出已經建好的對象
		//如果不在這個範圍，則建立新的Integer對象。
		Integer in1 = Integer.valueOf(-128);  
        Integer in2 = -128;
        System.out.println(in1 == in2);//true 因為123在緩存範圍内
        System.out.println(in1.equals(in2));//true
        System.out.println("################");
        Integer in3 = 1234;
        Integer in4 = 1234;
        System.out.println(in3 == in4);//false 因為1234不在緩存範圍内
        System.out.println(in3.equals(in4));//true
 		
	}
}

           

• 字元串相關類String

  一、String(不可變字元序列)

  ①Java字元串就是Unicode字元序列，例如串“Java”就是4個Unicode字元J,a,v,a組成的。

  ②Java字元串就是Unicode字元序列，例如串“Java”就是4個Unicode字元J,a,v,a組成的。

  ③Java允許使用符号"+"把兩個字元串連接配接起來

String s1 = “Hello”;String s2 = “World!”; 
String s = s1 + s2; //HelloWorld!
           

二、String類的常用方法

• char charAt(int index)

傳回字元串中第index個字元。

• boolean equals(String other)

如果字元串與other相等，傳回true

• boolean equalsIgnoreCase(String other)

如果字元串與other相等（忽略大小寫），則傳回true

• int indexOf(String str) lastIndexOf() • int length()

傳回字元串的長度。

• String replace(char oldChar,char newChar)

傳回一個新串它是通過用 newChar 替換此字元串中出現的所有oldChar而生

• boolean startsWith(String prefix)

如果字元串以prefix開始，則傳回true

• boolean endsWith(String prefix)

如果字元串以prefix結尾，則傳回true

• String substring(int beginIndex) • String substring(int beginIndex,int endIndex)

傳回一個新字元串，該串包含從原始字元串beginIndex到串尾或endIndex-1的所有字元

• String toLowerCase()

傳回一個新字元串，該串将原始字元串中的所有大寫字母改成小寫字母

• String toUpperCase()

傳回一個新字元串，該串将原始字元串中的所有小寫字母改成大寫字母

• String trim()

傳回一個新字元串，該串删除了原始字元串頭部和尾部的空格

三、字元串相等的判斷(一般使用equals方法)

equals判斷字元串值相等，==判斷字元串對象引用相等！

public class StringTest3 {
public static void main(String[] args) {
String s1 = "abc";
String s2 = "abc";
String s3 = new String("abc");
String s4 = new String("abc");
System.out.println(s1==s2); //true
System.out.println(s1==s3); //false
System.out.println(s3==s4); //false
}
}
           

• StringBuffe和StringBuilder

  StringBuffer和StringBuilder非常類似，均代表可變的字元序列，而且方法也一樣

/**
 * 測試StringBuilder、StringBuffer可變字元序列
 * @author 梁雪
 *
 */
public class TestStringBuilder {
	public static void main(String[] args) {
		String  str;
		
		//StringBuilder線程不安全，效率高（一般使用它）；StringBuffer線程安全，效率低。
		StringBuilder  sb = new StringBuilder("abcdefg");
		
		System.out.println(Integer.toHexString(sb.hashCode()));  
		System.out.println(sb);
		
		sb.setCharAt(2, 'M');
		System.out.println(Integer.toHexString(sb.hashCode()));  
		System.out.println(sb);
		
	}
}

           

/**
 * 測試StringBuilder、StringBuffer可變字元序列的常用方法.
 * @author 梁雪
 *
 */
public class TestStringBuilder2 {
	public static void main(String[] args) {
		StringBuilder   sb =  new StringBuilder();
		
		for(int i=0;i<26;i++){
			char temp = (char)('a'+i);
			sb.append(temp);
		}
		
		System.out.println(sb);
		sb.reverse();		//倒序
		System.out.println(sb);
		sb.setCharAt(3, '高');
		System.out.println(sb);
		sb.insert(0, '我').insert(6, '愛').insert(10, '你');  		//鍊式調用。核心就是：該方法調用了return this，把自己傳回了。
		System.out.println(sb);
		
		sb.delete(20, 23);
		System.out.println(sb);
		
		
	}
}

           

字元串選用

String：不可變字元序列

StringBuilder：可變字元序列、效率高、線程不安全

StringBuilder：可變字元序列、效率低、線程安全

String使用陷阱：

string s="a"; //建立了一個字元串
s=s+"b";

/*實際上原來的"a"字元串對象已經丢棄了，現在又産生了一個字元串s+"b"。如果多次執
行這些改變串内容的操作，會導緻大量副本字元串對象存留在記憶體中，降低效率。如果這樣的
操作放到循環中，會極大影響程式的性能。*/
           

package cn.sxt.test;

/**
 * 測試可變字元序列和不可變字元序列使用的陷阱
 * 
 * @author 梁雪
 *
 */
public class TestStringBuilder3 {
	public static void main(String[] args) {

		/** 使用String進行字元串的拼接 */
		String str8 = "";
		// 本質上使用StringBuilder拼接, 但是每次循環都會生成一個StringBuilder對象
		long num1 = Runtime.getRuntime().freeMemory();// 擷取系統剩餘記憶體空間
		long time1 = System.currentTimeMillis();// 擷取系統的目前時間
		for (int i = 0; i < 5000; i++) {
			str8 = str8 + i;// 相當于産生了10000個對象
		}
		long num2 = Runtime.getRuntime().freeMemory();
		long time2 = System.currentTimeMillis();
		System.out.println("String占用記憶體 : " + (num1 - num2));
		System.out.println("String占用時間 : " + (time2 - time1));
		
		
		/** 使用StringBuilder進行字元串的拼接 */
		StringBuilder sb1 = new StringBuilder("");
		long num3 = Runtime.getRuntime().freeMemory();
		long time3 = System.currentTimeMillis();
		for (int i = 0; i < 5000; i++) {
			sb1.append(i);
		}
		long num4 = Runtime.getRuntime().freeMemory();
		long time4 = System.currentTimeMillis();
		System.out.println("StringBuilder占用記憶體 : " + (num3 - num4));
		System.out.println("StringBuilder占用時間 : " + (time4 - time3));
	}
}