JAVA 基础知识整理-09 Array, 常量的包装类，Integer类

1.Arrays类
static String toString(int[] a) 整数数组转字符串
static void sort(int[] a) 对整数数组进行排序(快速排序)
static int binarySearch(int[] a, int key) 对数组进行二分查找(必须是一个有序的数组）

import java.util.Arrays;

public class ArraysDemo {
public static void main(String[] args) {
	int[] it = {33,45,34,22,12,56};
	System.out.println(Arrays.toString(it));
	Arrays.sort(it);
	System.out.println(Arrays.toString(it));
}
}


输出：
[33, 45, 34, 22, 12, 56]
[12, 22, 33, 34, 45, 56]

static String toString(int[] a) 源代码：

    public static String toString(int[] a) {
        if (a == null)
            return "null";//判断是否为空（如果不做这一步，那么当传入的参数是null是就会报NullPointerException）
        int iMax = a.length - 1;
        if (iMax == -1)
            return "[]";//判断数组内容是否为空

        StringBuilder b = new StringBuilder();
        b.append('[');
        for (int i = 0; ; i++) {//中间不写代表true,表示条件一直成立
            b.append(a[i]);
            if (i == iMax)
                return b.append(']').toString();
            b.append(", ");
        }
    }

static int binarySearch(int[] a, int key) 源代码：

 public static int binarySearch(int[] a, int key) {
        return binarySearch0(a, 0, a.length, key);
    }
private static int binarySearch0(int[] a, int fromIndex, int toIndex,
                                     int key) {
        int low = fromIndex;
        int high = toIndex - 1;

        while (low <= high) {
            int mid = (low + high) >>> 1;//无符号右移1位，这里相当于(low + high)大于0，因此相当于(low + high)//2
            int midVal = a[mid];

            if (midVal < key)
                low = mid + 1;
            else if (midVal > key)
                high = mid - 1;
            else
                return mid; // key found
        }
        return -(low + 1);  // key not found.
    }

2. 基本类型的包装类

byte Byte
short Short
int Integer
long Long
float Float
double Double
char Character
boolean Boolean

3. Integer类

构造方法 :
Integer(int value)
Integer(String s) 注意此处的s内容必须是数字

常用方法：
static String toBinaryString(int i)
获取指定整数的二进制数 ， 范围类型为字符串
static String toHexString(int i)
获取指定整数的16进制数， 范围类型为字符串
static String toOctalString(int i)
获取指定整数的8进制数， 范围类型为字符串
static int parseInt(String s)
将字符串参数解析为带符号的十进制整数。
static int parseInt(String s, int radix)
将指定进制的字符串，转换成十进制的整数值，返回类型为int类型(范围2进制~36进制）
String toString()
将返回String类型的Integer值。
static String toString(int i)
返回指定整数的字符串形式。
static String toString(int i, int radix)
将指定整数转换成指定进制的值并返回其字符串形式。(范围2进制~36进制）
static Integer valueOf(int i)
返回一个 Integer指定的 int值的 Integer实例。
static Integer valueOf(String s)
返回一个 Integer对象，保存指定的值为 String 。
static Integer valueOf(String s, int radix)
返回一个 Integer对象，保存从指定的String中 String的值，当用第二个参数给出的基数进行解析时。

public static final int MIN_VALUE
的常量保持的最小值的 int可以具有，-2 ^31。
返回int的最小值
public static final int MAX_VALUE
持有最大值一个 int可以有2^ 31 -1。
返回int的最大值

	Integer i = new Integer("23");
	Integer ii = Integer.valueOf(100);
	String s = Integer.toString(23);
	String iis = ii.toString();
	System.out.println(i);
	System.out.println(ii);
	System.out.println(s);
	System.out.println(Integer.MAX_VALUE);
	System.out.println(Integer.MIN_VALUE);
	System.out.println(Integer.parseInt("100",2));
	System.out.println(Integer.toString(100,2));

输出：
23
100
23
2147483647
-2147483648
4
1100100

4.int 类型和String类型的相互转换
int 转为String：
1）String s = “”+number; 字符串拼接数字
2）String s = String.valueOf(number)
3）String s = Integer.toString(number)
4) Intger i = new Integer(number);String s = i.toString()

String 转为int:

1. int i = Integer.parseInt(s) 注此处的s内容必须是数字
2. Integer in = new Integer(s); int number = in.valueOf()

5. JDK5的自动装箱和拆箱

Integer i = 100 等价于 Integer i =Integer.valueOf(100);
i += 200 等价于 Integer.valueOf(i.intValue() + 200);

注意：针对-128到127之间的数据，做了一个数据缓冲池，如果数据是该范围的，那么会从缓冲池获取数据而并不创建新的空间。

Integer.valueOf(）源码：

    private static class IntegerCache {
        static final int low = -128;
        static final int high;
        static final Integer cache[];

        static {
            // high value may be configured by property
            int h = 127;
            String integerCacheHighPropValue =
                sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
            if (integerCacheHighPropValue != null) {
                int i = parseInt(integerCacheHighPropValue);
                i = Math.max(i, 127);
                // Maximum array size is Integer.MAX_VALUE
                h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
            }
            high = h;

            cache = new Integer[(high - low) + 1];
            int j = low;
            for(int k = 0; k < cache.length; k++)
                cache[k] = new Integer(j++);
        }

        private IntegerCache() {}
    }
 public static Integer valueOf(int i) {
        assert IntegerCache.high >= 127;
        if (i >= IntegerCache.low && i <= IntegerCache.high)//如果给的数值参数大于等于-128，且小于等于127，那么就不会创建新的空间
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }

Integer a2 = new Integer(128);
	Integer b2 = new Integer(128);
	System.out.println(a2 == b2);
	System.out.println(a2.equals(b2));
	
	Integer a3 = new Integer(127);
	Integer b3 = new Integer(127);
	System.out.println(a3 == b3);
	System.out.println(a3.equals(b3));
	
	Integer a = 128;
	Integer b = 128;
	System.out.println(a == b);
	System.out.println(a.equals(b));
	
	Integer a1 = 127;
	Integer b1 = 127;
	System.out.println(a1 == b1);
	System.out.println(a1.equals(b1))
输出：
false
true
false
true
false
true
true
true

6. Character类
Character类包装一个对象中的基本类型char的值。 类型为Character的对象包含一个单一字段，其类型为char 。

构造方法：
Character(char value)

常用方法：
static boolean isUpperCase(char ch)
确定指定的字符是否为大写字符。
static boolean isDigit(char ch)
确定指定的字符是否是数字。
static boolean isLowerCase(char ch)
确定指定的字符是否是小写字符。
static char toLowerCase(char ch)
使用UnicodeData文件中的大小写映射信息将字符参数转换为小写。
static char toUpperCase(char ch)
使用UnicodeData文件中的案例映射信息将字符参数转换为大写。