java.lang包是java語言中被用於編程的基本包。編寫的程序基本上都要用到這個包內的常用類。
包含了基本數據類型包裝類(Boolean,Number,Character,Void)以及常用類型類（String,StringBuilder,StringBuffer）
Number類 是所有數值類的父類，其直接子類
AtomicInteger, AtomicLong, BigDecimal, BigInteger, Byte, Double, Float, Integer, Long, Short
一、Integer類 int整型的包裝類
數值范圍(-231~~231-1) 這是64位的jdk，，占用4字節，最大長度為32位
主要以下部分內容
- Integet類生成整型對象的靜態方法 也就是將字符串轉換成整型
- Integer對象轉換成字符串的方法。
- Integer類的equals(Object obj)和toString()方法
- Comparable<Integer>接口方法的實現
生成Integer對象方法
public static Integer valueOf(String s)或者public static Integer valueOf(String s, int radix)
這兩個方法都是將字符串轉換成整型對象，
Integer.valueOf("123")和Integer.valueOf("123",10)這方法是等同了，不帶radix參數時，默認指定s的值是十進制數據，即radix=10
而如果s的值不是十進制數據時則要調用valueOf(String s, int radix)方法，要指定該字符串是多少進制數據。
如Integer.valueOf("abc",16) 指定字符串"abc" 是十六進制數據
這將會返回一個數值為2748的Integer對象,也就是10*162+11*161+12*160=2748
valueOf()方法直接調用了，public static int parseInt(String s, int radix) ,將字符串解析成整型，
可以代表整型數據的字符，0-9 a-z A-Z 這些數據可以表示整型數據，如果字符串中包含其它字符，則會發生異常。
a-z和A-Z，其實表示的是同一整型數據，a和A 一樣表示10，b和B表示11
note：
十六進制 字母范圍為只能A-F ，因為十六進制單個字符能夠表示的數值為16，滿16進1
如果執行語句
parseInt("G",16)
這會報錯 java.lang.NumberFormatException: For input string: "G"
指定的進制數不能解析這個字符串
/** * All possible chars for representing a number as a String */ final static char[] digits = { '0' , '1' , '2' , '3' , '4' , '5' , '6' , '7' , '8' , '9' , 'a' , 'b' , 'c' , 'd' , 'e' , 'f' , 'g' , 'h' , 'i' , 'j' , 'k' , 'l' , 'm' , 'n' , 'o' , 'p' , 'q' , 'r' , 's' , 't' , 'u' , 'v' , 'w' , 'x' , 'y' , 'z' };
Integer對象轉換成字符串的方法
Integer類內部有一些靜態方法，用於將整型轉換為字符串類型,
String hexString = Integer.toHexString(50);//整型轉換為16進制字符串 String binaryString = Integer.toBinaryString(50);//二進制 String decimalString = Integer.toString(50);//默認十進制 String octalString = Integer.toOctalString(50);//八進制 String otherString = Integer.toString(50, 27);//任意進制，這里為27進制，進制范圍為：2~36 System.out.println(hexString); System.out.println(binaryString); System.out.println(decimalString); System.out.println(octalString); System.out.println(otherString);
輸出結果為
10
32
110010
50
62
1n
整型數據轉換成字符串用這個沒什么問題，但是負數轉換成字符串的時候出現了很多問題
除了
Integer.toString（int i）
Integer.toString(int i, int radix)
這兩個方法的正負整數轉換成字符串只是在前面加一個負號。其他的暫時看不懂，不糾結
10
ffffffce
11111111111111111111111111001110
-50
37777777716
-1n
Integer類的equals(Object obj)和toString()方法
Integer類中重寫了繼承自Object類的equals(Object obj)方法，
Object類中的equals(Object obj )
public boolean equals(Object obj) { return (this == obj); }
由於==這個運算符是判斷兩個對象引用的內存地址是否相等，相等，表示兩個object其實引用的是同一內存地址，同一對象。
Integer.equals(Object obj)
public boolean equals(Object obj) { if (obj instanceof Integer) { return value == ((Integer)obj).intValue(); } return false; }
重寫的equals()方法，如果對象不是Integer類型，返回false，如果是Integer類型，在判斷對象的值是否相等。所以要比較兩個整型對象的值是否相等，可以使用equals()方法進行比較
Integer.toString()，，也是重寫了Object的toString()方法,返回了是Integer對象的值
Object.toString() public String toString() { return getClass().getName() + "@" + Integer.toHexString(hashCode()); }
Integer.toString() public String toString() { return toString(value); } public static String toString(int i) { if (i == Integer.MIN_VALUE) return "-2147483648"; int size = (i < 0) ? stringSize(-i) + 1 : stringSize(i); char[] buf = new char[size]; getChars(i, size, buf); return new String(buf, true); }
Object的toString()是返回 字符串格式： “類名@16進制的哈希值”，
以后要謹慎使用toString（）方法了。
Comparable<Integer>接口方法的實現，對象列表的升序降序接口
我們通過重寫改接口方法，可以對列表進行升序或降序排列。
Number類的實現類，也就是基本數據類型的包裝類Integer, Float, Double,Long,Byte等都實現的Comparable接口，
默認就可以調用List或者array的排序方法進行升序或降序排序。
This interface imposes a total ordering on the objects of each class that implements it. This ordering is referred to as the class's natural ordering, and the class's compareTo method is referred to as its natural comparison method.
此接口對實現它的每個類的對象強加一個總排序。這種排序被稱為類的自然排序，類的compareTo方法被稱為其自然比較方法。
Lists (and arrays) of objects that implement this interface can be sorted automatically by Collections.sort (and Arrays.sort).
只有實現的這個接口的對象list列表或array數組才可以使用sort方法讓列表或數組的元素被自動排序
只需要實現compareTo()方法即可
public int compareTo(){}這個比較方法，，
如果要將對象列表進行升序排序，則第i個元素和第i+1元素 要滿足a[i]>a[i+1] 返回1 a[i]<a[i+1] 返回-1 a[i]=a[i+1] 返回0
如果要將對象列表進行降序排序 要滿足 a[i]>a[i+1] 返回-1 a[i]<a[i+1] 返回1 a[i]=a[i+1] 返回0
Collections.sort方法實現的就是按照此比較的東西排列
升序（從小到大）：
if(price < o.price){
return -1;
}
if(price > o.price){
return 1;
}
降序（從大到小）：
if(price < o.price){
return 1;
}
if(price > o.price){
return -1;
}
//將對象按價格進行升序排序 @Override public int compareTo(flower o) { //首先比較price，如果price相同返回0 if(price < o.price){ return -1; } if(price > o.price){ return 1; } return 0; }
為什么升序 返回值為1時，是n的值要大於n+1的值，而返回值為-1時n的值要小於n+1呢？
這個要查看源碼才可以知道原理。(不好奇的可以不看哦^~^)
由於這個List.sort（）這個排序方法時使用二分排序，源碼如下，
private static void binarySort(Object[] a, int lo, int hi, int start) { assert lo <= start && start <= hi; if (start == lo) start++; for ( ; start < hi; start++) { Comparable pivot = (Comparable) a[start]; // Set left (and right) to the index where a[start] (pivot) belongs int left = lo; int right = start; assert left <= right; /* * Invariants: * pivot >= all in [lo, left). * pivot < all in [right, start). */ while (left < right) { int mid = (left + right) >>> 1; if (pivot.compareTo(a[mid]) < 0) right = mid; else left = mid + 1; } assert left == right; /* * The invariants still hold: pivot >= all in [lo, left) and * pivot < all in [left, start), so pivot belongs at left. Note * that if there are elements equal to pivot, left points to the * first slot after them -- that's why this sort is stable. * Slide elements over to make room for pivot. */ int n = start - left; // The number of elements to move // Switch is just an optimization for arraycopy in default case switch (n) { case 2: a[left + 2] = a[left + 1]; case 1: a[left + 1] = a[left]; break; default: System.arraycopy(a, left, a, left + 1, n); } a[left] = pivot; } }
while (left < right) { int mid = (left + right) >>> 1; if (pivot.compareTo(a[mid]) < 0) right = mid; else left = mid + 1; }
這個值是和已排序的數據的中間的數據進行比較，provot.compareTo（a[mid]）
注意看，上面的a[mid]是作為比較方法的參數。
當小於0，也就是值為-1時，是我們要插入的數據作為調用方，
小於0時，該數據插入到前面，
大於0時，數據插入到后面
思維慣性以為升序就是第一個元素比第二個元素小。obj1.compareTo(Object obj2)
即obj1=2是第一個元素，obj2=8是第二個元素
那么我們升序時，如果obj1小於obj2，返回值為-1，則會將obj2插入到obj1前面，，排序前【2， 8】這樣排序完后卻變成了，，【8, 2】
這跟我們想要的升序數據不一樣，
原因是java的二分法進行比較了是，，obj2.compareTo(obj1),,與我們想的剛好相反，
所以我們返回的值取反就可以變成升序了，
如這個消費類，,只給出部分代碼
public class ConsumInfo implements Comparable<ConsumInfo> { public double price;
public String name;
public Consuminfo(double price, String name){
this.price = price;
this.name = name;
} @Override public int compareTo(ConsumInfo o) { //首先比較price，如果price相同 if(price < o.price){ return -1; } if(price > o.price){ return 1; } return 0; } }
ConsumInfo consumInfo1 = new ConsumInfo("consumInfo1", 400.0); ConsumInfo consumInfo2 = new ConsumInfo("consumInfo2", 200.0);
List<ConsumInfo> list = new ArrayList<ConsumInfo>(); list.add(consumInfo1); list.add(consumInfo2); System.out.println("排序前："); for(ConsumInfo consumInfo : list ){ System.out.println(consumInfo); } Collections.sort(list);//排序 System.out.println("排序后：");//排序后 for(ConsumInfo consumInfo :list){ System.out.println(consumInfo); }
控制台輸出信息為：
排序前： ConsumInfo [name=consumInfo1, price=400.0] ConsumInfo [name=consumInfo2, price=200.0] 排序后： ConsumInfo [name=consumInfo2, price=200.0] ConsumInfo [name=consumInfo1, price=400.0]
上面是最簡單的兩個元素進行排序，
第一次，往已排序列表中插入第一個元素，即數組中只有一個已排好序的元素，a[0] = consumInfo1
第二次時，left為0，right為1，進入while循環中，
mid=0，privot=consumInfo2
即consumInfo2.comparTo(a[0])
當方法的返回值小於0時，consumInfo2會插入在consumInfo1之前，
大於0時，會在consumInfo1之后
進行比較時，consumInfo2.price<consumInfo1.price 返回值小於0，也就是consumInfo1的值比較大，插入在1之前