12 foreach 裝箱拆箱 可變參數 枚舉

Foreach

int []a=new int[]{1,2,3,4,5,6,7,8};
		for (int  item : a)
		{
			System.out.println(item);
			
		}
           

1. 當周遊集合或數組時，如果需要通路集合或數組的下标，那麼最好使用舊式的方式來實作循環或周遊，而不要使用增強的for循環，因為它丢失了下标資訊。

自動裝箱/拆箱大大友善了基本類型資料和它們包裝類的使用。

•自動裝箱：基本類型自動轉為包裝類.(int >> Integer)

•自動拆箱：包裝類自動轉為基本類型.(Integer >> int)

int a = 3;
		
		Collection<Integer> c = new ArrayList<Integer>();
		
		c.add(3);//将int類型的3轉換為Integer類型并放到集合當中
		c.add(a + 3);
		
		for(Integer i : c)
		{
			System.out.println(i);
		}
           

HashMap<String ,Integer> hashMap=new HashMap<String ,Integer>();
		for(String itemString :args)
		{
			hashMap.put(itemString,(null==hashMap.get(itemString)?1:hashMap.get(itemString)+1));
			
		}
		Iterator<Map.Entry<String,Integer>> iterator=hashMap.entrySet().iterator();
		while (iterator.hasNext())
		{
			Map.Entry<String,Integer> entry=(Entry<String,Integer>) iterator.next();
			System.out.println("單詞 "+entry.getKey()+"  出現的次數 ："+entry.getValue());
			
		}
           

2. Integer類有一個緩存，它會緩存介于-128～127之間的整數。

當生成緩沖中的數字，就指向緩存中的數字，不再生成新的Integer對象，是以i1==i2

當超出緩存中的數字，則生成新的Integer對象 是以i3!=i4

Integer i1=100;
		Integer i2=100;
		Integer i3=200;
		Integer i4=200;
		System.out.println(i1==i2);
		System.out.println(i3==i4);
           

/**
     * Returns an {@code Integer} instance representing the specified
     * {@code int} value.  If a new {@code Integer} instance is not
     * required, this method should generally be used in preference to
     * the constructor {@link #Integer(int)}, as this method is likely
     * to yield significantly better space and time performance by
     * caching frequently requested values.
     *
     * This method will always cache values in the range -128 to 127,
     * inclusive, and may cache other values outside of this range.
     *
     * @param  i an {@code int} value.
     * @return an {@code Integer} instance representing {@code i}.
     * @since  1.5
     */
    public static Integer valueOf(int i) {
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }
           

3. 可變參數：可變參數本質上就是一個數組，對于某個聲明了可變參數的方法來說，我們既可以傳遞離散的值，也可以傳遞數組對象。但如果将方法中的參數定義為數組，那麼隻能傳遞數組對象而不能傳遞離散的值。

4. 可變參數必須要作為方法參數的最後一個參數，即一個方法不可能具有兩個或兩個以上的可變參數。

private static int sum(String str, int... nums)
	{
		System.out.println(str);

		int sum = 0;

		for (int num : nums)
		{
			sum += num;
		}

		return sum;
	}

	public static void main(String[] args)
	{
		int result = sum("a", new int[] { 1, 2 });

		System.out.println(result);

		result = sum("b", 1, 2, 3, 4);

		System.out.println(result);

	}
           

5. 枚舉（Enum）：我們所定義的每個枚舉類型都繼承自java.lang.Enum類，枚舉中的每個成員預設都是public static final的。

6. 而每個枚舉的成員其實就是您定義的枚舉類型的一個執行個體（Instance）。換句話說，當定義了一個枚舉類型後，在編譯時刻就能确定該枚舉類型有幾個執行個體，分别是什麼。在運作期間我們無法再使用該枚舉類型建立新的執行個體了，這些執行個體在編譯期間就已經完全确定下來了。

枚舉應用執行個體

public enum AccessRight
{
	MANAGER, DEPARTMENT, EMPLOYEE;
}
           

public class AccessControl
{
	public static boolean checkRight(AccessRight accessRight)
	{
		if(accessRight == AccessRight.MANAGER)
		{
			return true;
		}
		else if(accessRight == AccessRight.DEPARTMENT)
		{
			return false;
		}
		return false;
	}
	
	public static void main(String[] args)
	{
		AccessRight accessRight = AccessRight.valueOf("MANAGER");
		
		System.out.println(checkRight(accessRight));
	}
}
           

7. 靜态導入：

a) import static com.shengsiyuan.common.Common.Age;

b) import static com.shengsiyuan.common.Common.output;

8. 表示導入Common類中的靜态成員變量AGE以及靜态方法output。注意：使用import static時，要一直導入到類中的靜态成員變量或靜态方法。

9. Java中，無論生成某個類的多少個對象，這些對象都會對應于同一個Class對象。