06Java常用类1

Object类

API 的概述：

​ 应用程序接口，包括为开发Java程序而预定义的类和接口。简而言之，就是JDK提供给我们的一些提高编程效率的java类。

介绍

​ Object是类层次结构的根类，所有的类都直接或者间接的继承自Object类。

构造方法

​ Object类的构造方法有一个，并且是无参构造，因为子类构造方法会默认访问父类的无参构造方法。

要掌握的方法

　　A: public String toString()

​ 返回对象的字符串表示，默认是由类的全路径+‘@’+哈希值的十六进制表示。

​ 这个表示其实是没有意义的，一般子类都会重写该方法（toString()方法）。

​ 如何重写呢?

​ 把该类的所有成员变量值组成返回即可。

​ 重写的最终版方案就是自动生成toString()方法。

​ Integer类下的一个静态方法：

​ public static String toHexString(int i)：把一个整数转成一个十六进制表示的字符串

​ 注意：

​ 直接输出一个对象的名称，其实就是调用该对象的toString()方法。

class Student {
	private String name;
	private int age;
	// get and set方法省略
	@Override
	public String toString() {
		return "Student [name=" + name + ", age=" + age + "]";
	}
//    @Override
//    public String toString() {
//        // return super.toString();
//        return "姓名:" + name + ",年龄:" + age;
//    }
}

　　B: public boolean equals(Object obj)：指示其他某个对象是否与此对象”相等”

​ 比较两个对象是否相同。默认情况下，比较的是地址值是否相同。

​ 而比较地址值是没有意义的，所以，一般子类也会重写该方法。

​ 如何重写？

​ 一般都是用来比较对象的成员变量值是否相同

​ 最终还是自动生成。

要了解的方法

​ A: public int hashCode()

​ 返回对象的哈希码值。由Object类定义的hashCode方法确实会针对不同的对象返回不同的整数。（这一般是通过将该对象的内部地址转换成一个整数来实现的，但是Java编程语言不需要这种实现技巧。）请阅读API。

　　　　

​ B: public final Class<?> getClass()

​ 返回此 Object 的运行时类（返回对象的字节码文件对象）。

​ 应用：反射。

　　　　Class类的方法：

　　　　　　public String getName() 以String的形式返回此Class对象所表示的实体

　　　

​ C: protected void finalize()

​ 用于垃圾回收，在不确定的时间

​ D: protected Object clone()

​ 可以实现对象的克隆，包括成员变量的数据复制，但是它和两个引用指向同一个对象是有区别的。

注意

​ A: 直接输出一个对象名称，其实默认调用了该对象的toString()方法。

​ B: 面试题

　　　　==和equals()的区别?

　　　　1、==

　　　　　　基本类型：比较的是值是否相同

　　　　　　引用类型：比较的是地址值是否相同

　　　　2、equals()

　　　　　　只能比较引用类型。默认情况下，比较的是地址值是否相同。

　　　　　　但是，我们可以根据自己的需要重写该方法。

Scanner类

介绍

​ 在JDK5以后出现的用于键盘录入数据的类。

构造方法

​ A: System.in

​ 它其实是标准的输入流，对应于键盘录入

​ B: 构造方法

​ InputStream in = System.in;

​ Scanner(InputStream in)

​ C: 常用的格式

​ Scanner sc = new Scanner(System.in);

基本方法格式

​ A:hasNextXxx() 判断是否是某种类型的

​ B:nextXxx() 返回某种类型的元素

要掌握的方法

​ A: public int nextInt()

​ B: public String nextLine()

注意

　　A:同一个Scanner对象，先获取数值，再获取字符串会出现一个小问题。

​ 解决方案：

​ a:重新定义一个Scanner对象

​ b:把所有的数据都用字符串获取，然后再进行相应的转换

String类

String 和 CharSequence

　　String 继承于CharSequence，也就是说String也是CharSequence类型。

　　CharSequence是一个接口，它只包括length(), charAt(int index), subSequence(int start, int end)这几个API接口。除了String实现了CharSequence之外，StringBuffer和StringBuilder也实现了CharSequence接口。

　　需要说明的是，CharSequence就是字符序列，String, StringBuilder和StringBuffer本质上都是通过字符数组实现的！

介绍

​ String 代表字符串，Java 程序中的所有字符串字面值（如 “abc” ）都作为此类的实例实现。

​ 它是多个字符组成的一串数据。

​ 它可以和字符数组进行相互转换。

构造方法

　　A: public String()：空构造

　　B: public String(byte[] bytes)：把字节数组转换成字符串

　　C: public String(byte[] bytes,int offset,int length)把字节数组的指定部分转换成字符串

　　D: public String(char[] value)：把字符数组转换成字符串

　　E: public String(char[] value,int offset,int count)：把字符数组的指定部分转换成字符串

　　F: public String(String original)：把字符串常量转换成字符串

　　下面的这一个虽然不是构造方法，但是结果也是一个字符串对象

　　G: String s = “hello”; // 字符串常量

特点

​ A: 字符串是常量；它们的值在创建之后不能更改（字符串一旦被赋值，就不能改变。）

​ 注意：这里指的是字符串的内容不能改变，而不是引用不能改变。

​ B: 字面值作为字符串对象和通过构造方法创建对象的不同

　　　　String s = new String(“hello”)；和 String s = “hello”；的区别？

练习

​ A: ==和equals()

String s1 = new String("hello");
String s2 = new String("hello");
System.out.println(s1 == s2); // false
System.out.println(s1.equals(s2)); // true

String s3 = new String("hello");
String s4 = "hello";
System.out.println(s3 == s4); // false
System.out.println(s3.equals(s4)); // true

String s5 = "hello";
String s6 = "hello";
System.out.println(s5 == s6); // true
System.out.println(s5.equals(s6)); // true

​ B: 字符串的拼接

　　　　**字符串如果是变量相加，先开空间，再拼接。

　　　　**字符串如果是常量相加，是先加，然后在常量池找，如果有就直接返回，否则，就创建。

　　　　//通过反编译工具查看

String s1 = "hello";
String s2 = "world";
String s3 = "helloworld";

System.out.println(s3 == s1 + s2); // false 2个字符串做拼接，因为它是变量，所以先开空间再拼接。
System.out.println(s3.equals((s1 + s2))); // true
System.out.println(s3 == "hello" + "world"); // true 因为它是常量，先加后找，没有就创建。
System.out.println(s3.equals("hello" + "world")); // true

常见功能

判断功能

​ boolean equals(Object obj)：比较字符串的内容是否相同，区分大小写

　　　　boolean equalsIgnoreCase(String str)：比较字符串的内容是否相同，忽略大小写

　　　　boolean contains(String str)：判断大串中是否包含小串（连一起的）

　　　　boolean startsWith(String str)：判断字符串是否以某个指定的字符串开头

　　　　boolean endsWith(String str)：判断字符串是否以某个指定的字符串结尾

　　　　boolean isEmpty()：判断字符串是否为空

　　　　注意：

　　　　　　字符串内容为空和字符串对象为空：

　　　　　　String s = “”;

　　　　　　String s = null;

获取功能

　　　　int length()：获取字符串的长度

　　　　char charAt(int index)：获取指定索引位置的字符

　　　　int indexOf(int ch)：返回指定 字符 在此字符串中第一次出现处的索引，不存在返回-1。

　　　　　　为什么这里是int类型，而不是char类型?

　　　　　　原因是：’a’和97其实都可以代表’a’

　　　　int indexOf(String str)：返回指定 字符串 在此字符串中第一次出现处的索引，不存在返回-1。

　　　　int indexOf(int ch,int fromIndex)：返回指定 字符 在此字符串中从指定索引位置后第一次出现处的索引，不存在返回-1。

　　　　int indexOf(String str,int fromIndex)：返回指定 字符串 在此字符串中从指定索引位置后第一次出现处的索引，不存在返回-1。

　　　　String substring(int beginIndex)：返回一个新的字符串，它是此字符串的一个子字符串。该子字符串从指定索引处的字符开始，直到此字符串末尾。

　　　　String substring(int beginIndex, int endIndex)：返回一个新字符串，它是此字符串的一个子字符串。该子字符串从指定的 beginIndex 处开始，直到索引 endIndex - 1 处的字符。因此，该子字符串的长度为 endIndex-beginIndex。

转换功能

　　　　byte[] getBytes()：把字符串转换为字节数组。输出的是对应的ASCII码值，可强转成char类型。

　　　　　　之前讲过通过构造方法可以把字节数组转换成字符串，说明字节数组和字符串可以相互转换。

　　　　char[] toCharArray()：把字符串转换为字符数组。

　　　　　　之前讲过通过构造方法可以把字符数组转换成字符串，说明字符数组和字符串可以相互转换。

　　　　static String valueOf(char[] chs)：把字符数组转换成字符串。通过静态方法转换（比通过构造方法转换的要好，推荐使用）

public class StringDemo {
	public static void main(String[] args) {
		char[] chArray = { 'A', 'B', 'C' };
		String str1 = String.valueOf(chArray);
		System.out.println(str1); // ABC
		String str2 = new String(chArray);
		System.out.println(str2); // ABC
	}
}

　　　　static String valueOf(int i)：把int类型的数据转换成字符串

　　　　　　注意：String类的valueOf方法可以把任意类型的数据转换成字符串 ，详情查看API

　　　　String toLowerCase()：把字符串转成小写，产生了一个新的串，字符串本身不变。

　　　　String toUpperCase()：把字符串转成大写，产生了一个新的串，字符串本身不变。

　　　　String concat(String str)：把字符串拼接

其他功能

　　　　a: 替换功能

　　　　　　String replace(char oldChar,char newChar)

　　　　　　String replace(CharSequence target, CharSequence replacement) //String replace(String old,String new)

　　　　　　　　例如，用 “b” 替换字符串 “aaa” 中的 “aa” 将生成 “ba” 而不是 “ab”。

　　　　b: 去空格功能

　　　　　　String trim(): 返回：此字符串移除了前导和尾部空白的副本；如果没有前导和尾部空白，则返回此字符串。

　　　　c: 按字典比较功能

　　　　　　int compareTo(String str) // 该比较基于字符串中各个字符的 Unicode 值

　　　　　　int compareToIgnoreCase(String str)

　　 自己写的compareTo方法：

​ String类的compareTo方法的源码解析：

练习

　　A: 模拟用户登录，登录成功后开始猜数游戏

　　B: 字符串遍历

　　C: 统计字符串中大写，小写及数字字符的个数

　　D: 把字符串的首字母转成大写，其他小写

　　E: 把int数组拼接成一个指定格式的字符串

　　F: 字符串反转

　　G: 统计大串中小串出现的次数

练习A：模拟用户登录，登录成功后开始猜数游戏

练习B：字符串遍历

public class StringDemo {
    public static void main(String[] args) {
        String str = "HelloWord";
        // 方法一
        for (int i = 0; i < str.length(); i++) {
            char ch = str.charAt(i);
            System.out.print(ch + " ");
        }
        System.out.println();

        // 方法二
        byte[] byArray = str.getBytes();
        for (int i = 0; i < str.length(); i++) {
            System.out.print((char) byArray[i] + " ");
        }
        System.out.println();
        System.out.println(byArray.length);

        // 方法三
        char[] chArray = str.toCharArray();
        for (int i = 0; i < str.length(); i++) {
            System.out.print(chArray[i] + " ");
        }
        System.out.println();
        System.out.println(chArray.length);
    }
}

练习C：统计一个字符串中大写字母字符，小写字母字符，数字字符出现的次数。(不考虑其他字符)

练习D：把字符串的首字母转成大写，其他小写

练习E：把int数组拼接成一个指定格式的字符串

练习F：字符串反转

　　分析：

　　　　A:键盘录入一个字符串

　　　　B:定义一个新字符串

　　　　C:倒着遍历字符串，得到每一个字符

　　　　　　a:length()和charAt()结合

　　　　　　b:把字符串转成字符数组

　　D:用新字符串把每一个字符拼接起来

　　E:输出新串

练习G：统计大串中小串出现的次数

StringBuffer类

介绍

​ 可变的字符序列。

​ 用字符串做拼接，比较耗时并且也耗内存，而这种拼接操作又是比较常见的，为了解决这个问题，Java就提供了一个字符串缓冲区类 StringBuffer 供我们使用。

构造方法

　　A: public StringBuffer()：无参构造方法。构造一个其中不带字符的字符串缓冲区，其初始容量为 16 个字符。

　　B: public StringBuffer(int capacity)：构造一个不带字符，但具有指定初始容量的字符串缓冲区。

　　C: public StringBuffer(String str)：构造一个字符串缓冲区，并将其内容初始化为指定的字符串内容。

常用方法

　　public int capacity()：返回当前容量。容量是新插入字符可用的存储量，超过此容量将重新分配。理论值

　　public int length()：返回长度（字符数）。实际值

常见功能

添加功能

　　　　public StringBuffer append(String str)：不光是String类型，可以把任意类型的数据添加到字符串缓冲区里面。返回：此对象的一个引用。

　　　　public StringBuffer insert(int offset, String str)：按顺序将 String 参数中的字符插入此序列中的指定位置，将该位置处原来的字符向后移，此序列将增加该参数的长度。如果 str 为 null，则向此序列中追加 4 个字符 “null”。返回：此对象的一个引用。

删除功能

　　　　public StringBuffer deleteCharAt(int index): 移除此序列指定位置的 char。此序列将缩短一个 char。返回：此对象。

　　　　public StringBuffer delete(int start,int end):移除此序列的子字符串中的字符。该子字符串从指定的 start 处开始，一直到索引 end - 1 处的字符，*如果不存在这种字符，则一直到序列尾部。*如果 start 等于 end，则不发生任何更改。返回：此对象。

替换功能

　　　　public StringBuffer replace(int start,int end,String str)：使用给定 String 中的字符替换此序列的子字符串中的字符。该子字符串从指定的 start 处开始，一直到索引 end - 1 处的字符，如果不存在这种字符，则一直到序列尾部。先将子字符串中的字符移除，然后将指定的 String 插入 start。（如果需要，序列将延长以适应指定的字符串。）返回：此对象。

反转功能

　　　　public StringBuffer reverse()：返回：此对象的一个引用。

截取功能（注意返回值）

　　　　public String substring(int start)：截取字符串，始于指定索引处的字符，一直到此字符串末尾。返回：新的字符串。

　　　　public String substring(int start,int end)：截取字符串，从指定的 start 处开始，一直到索引 end - 1 处的字符。返回：新的字符串。

　　　　public void trimToSize()：尝试减少用于字符序列的存储空间。如果缓冲区大于保存当前字符序列所需的存储空间，则将重新调整其大小，以便更好地利用存储空间。调用此方法可能会影响后续调用 capacity() 方法时返回的值。

练习

　　A:String和StringBuffer相互转换

　　注意：不能把字符串的值直接赋值给StringBuffer，String和StringBuffer不能相互赋值。

　　　　String – StringBuffer

　　　　　　方式1：通过StringBuffer的构造方法

　　　　　　方式2：通过StringBuffer的append()方法

　　　　StringBuffer – String

　　　　　　方式1: 通过String的构造方法public String(StringBuffer buffer)

　　　　　　方式2：通过StringBuffer的toString()方法

　　B:字符串的拼接

　　C:把字符串反转

　　D:判断一个字符串是否对称

String、StringBuilder、StringBuffer

　　StringBuilder 和 StringBuffer都是可变的字符序列。它们都继承于AbstractStringBuilder，实现了CharSequence接口。

　　但是，StringBuilder是非线程安全的，而StringBuffer是线程安全的。

一、java.lang.String 类：JAVA中不可变的字符序列。

　　i. 每次对String的修改都会产生新的String对象。如果需要大量修改字符串时，不建议使用String类。

　　ii. String是final的类。

　　iii. String重写了Object类的equals()，用于判断字符串的内容是否相等（区分大小写）。

　　iv. String的方法不会改变自身的内容。

iv. String的方法不会改变自身的内容。

二、java.lang.StringBuffer 类与 java.lang.StringBuilder 类

　　i. JAVA中可变的字符序列。

　　ii. StringBuffer是线程安全的(线程同步的) 数据安全 — 同步 — 效率低

　　iii. StringBuilder是线程不安全的(线程不同步的) 数据不安全 — 不同步 — 效率高一些

　　iv. 每次对StringBuffer与StringBuilder的修改不会产生新的对象，工作中如果需要大量的修改字符串时，建议使用StringBuffer或StringBuilder。

　　v. StringBuffer与StringBuilder的方法会改变自身的内容。

　　vi. StringBuffer与StringBuilder没有重写Object类中的equals()，所以不能使用equals()比较StringBuffer与StringBuilder的内容是否相等。

三、比较

　　　　StringBuffer：同步的，数据安全，效率低。

　　　　StringBuilder：不同步的，数据不安全，效率高。

　　1.String,StringBuffer,StringBuilder的区别

　　　　A:String是内容不可变的，而StringBuffer,StringBuilder都是内容可变的。

　　　　B:StringBuffer是同步的，数据安全,效率低;StringBuilder是不同步的,数据不安全,效率高

　　2.StringBuffer和数组的区别?

　　　　二者都可以看出是一个容器，装其他的数据。

　　　　但是呢,StringBuffer的数据最终是一个字符串数据。

　　　　而数组可以放置多种数据，但必须是同一种数据类型的。

　　3.注意

　　　　String 和 StringBuffer 作为形参问题

四、线程安全（多线程部分）

　　安全 – 同步 – 数据是安全的

　　不安全 – 不同步 – 效率高一些

　　安全和效率问题是永远困扰我们的问题。

　　安全：医院的网站，银行网站

　　效率：新闻网站，论坛之类的

数组高级以及Arrays

排序

（参考 排序算法 ）

​ A:冒泡排序

​ 相邻元素两两比较，大的往后放，第一次完毕，最大值出现在了最大索引处。同理，其他的元素就可以排好。

public static void bubbleSort(int[] arr) {
    for (int x = 0; x < arr.length - 1; x++) {
        for (int y = 0; y < arr.length - 1 - x; y++) {
            if (arr[y] > arr[y + 1]) {
                int temp = arr[y];
                arr[y] = arr[y + 1];
                arr[y + 1] = temp;
            }
        }
    }
}

​ B:选择排序

​ 把0索引的元素，和索引1以后的元素都进行比较，第一次完毕，最小值出现在了0索引。同理，其他的元素就可以排好。

public static void selectSort(int[] arr) {
    for (int x = 0; x < arr.length - 1; x++) {
        for (int y = x + 1; y < arr.length; y++) {
            if (arr[y] < arr[x]) {
                int temp = arr[x];
                arr[x] = arr[y];
                arr[y] = temp;
            }
        }
    }
}

查找

（参考 二分查找 ）

　　A:基本查找

　　　　针对数组无序的情况

public static int getIndex(int[] arr, int value) {
    int index = -1;
    for (int x = 0; x < arr.length; x++) {
        if (arr[x] == value) {
            index = x;
            break;
        }
    }
    return index;
}

　　B:二分查找(折半查找)

　　　　针对数组有序的情况(千万不要先排序，在查找)

public static int binarySearch(int[] arr, int value) {
    int min = 0;
    int max = arr.length - 1;
    int mid = (min + max) / 2;
    while (arr[mid] != value) {
        if (arr[mid] > value) {
            max = mid - 1;
        } else if (arr[mid] < value) {
            min = mid + 1;
        }
        if (min > max) {
            return -1;
        }
        mid = (min + max) / 2;
    }
    return mid;
}

Arrays工具类

　　A. 是针对数组进行操作的工具类。包括排序和查找等功能。（此类包含用来操作数组（比如排序和搜索）的各种方法。此类还包含一个允许将数组作为列表来查看的静态工厂。）

　　B. 要掌握的方法（以下只是部分方法）

　　　　　　public static String toString(int[] a) 把数组转成字符串

　　　　　　public static void sort(int[] a) 对数组进行排序

　　　　　　public static int binarySearch(int[] a,int key) 二分查找

Arrays工具类的源码解析

　　public static String toString(int[] a)

　　public static void sort(int[] a) 底层是快速排序，感兴趣自己看。

　　public static int binarySearch(int[] a,int key)

字符串按字符排序

（详见 排序算法 ）

　　举例：

　　　　“edacbgf”

　　　　得到结果

　　　　“abcdefg”

包装类

定义

包装类的作用：基本类型不是类，所以无法获得类的基本特性，无法参与转型、泛型、集合、反射等过程，包装类的出现就是为了弥补这个缺陷。

为了对基本类型的数据进行更多的操作，将 基本数据类型 封装成类，并在类中定义一些功能，这个类就是 包装类(8个)。

　　byte Byte

　　short Short

　　int Integer

　　long Long

　　float Float

　　double Double

　　char Character

　　boolean Boolean

常见的操作之一：用于基本数据类型与字符串之间的转换。

装箱与拆箱

装箱

​ 将 基本数据类型 转换为 包装类类型。

​ 自动装箱 基本类型 – 包装类类型（引用类型）

拆箱

​ 将 包装类类型 转换为 基本数据类型。

​ 自动拆箱 包装类类型（引用类型）– 基本类型

自动装箱与拆箱

从JDK1.5开始可以自动装箱与拆箱。所以下面是正确的：

　　　　　　　　Integer num1 = 100;
　　　　　　　　int num2 = new Integer(100);

　　　　　　把下面的这个代码理解即可：

　　　　　　　　Integer num = 100;
　　　　　　　　num += 200;
　　　　　　　　System.out.println("num:" + num);

　　　　　　通过*反编译*后的代码：

　　　　　　　　Integer num = Integer.valueOf(100); // 自动装箱
　　　　　　　　num = Integer.valueOf(num.intValue() + 200); // 自动拆箱，再自动装箱
　　　　　　　　System.out.println((new StringBuilder("num:")).append(num).toString()); // 我们用 + 号做的拼接，其本质是调用append()方法。因为用 + 号做拼接内存占用空间比较大，字符串拼接浪费很多空间，所以在底层自动做了转换。

　　　　　　需要注意：
　　　　　　　　在使用时，Integer num = null;上面的代码就会出现NullPointerException。因为num为空引用无法调用方法。

Integer

　　Integer 类在对象中包装了一个基本类型 int 的值。Integer 类型的对象包含一个 int 类型的字段。

　　此外，该类提供了多个方法，能在 int 类型和 String 类型之间互相转换，还提供了处理 int 类型时非常有用的其他一些常量和方法。

构造方法

　　　　     public Integer(int value)

　　　　　　　　Integer i = new Integer(100);

　　　　     public Integer(String s)

　　　　　　　　Integer i = new Integer("100");

　　　　　　注意：这里的字符串必须是由数字字符组成

　　　　　　　　　　抛出： NumberFormatException - 如果 String 不包含可解析的整数。

成员方法

public static final int MAX_VALUE
    System.out.println(Integer.MAX_VALUE);// 2147483647

public static final int MIN_VALUE
    System.out.println(Integer.MIN_VALUE);// -2147483648

​ A. String、包装类、基本数据类型 的相互转换

　　　　　　　　public int intValue()
　　　　　　　　public static int parseInt(String s)
　　　　　　　　public static String toString(int i)
　　　　　　　　public static Integer valueOf(int i)
　　　　　　　　public static Integer valueOf(String s)

　　　　　　    String – 包装类	//将String转换为包装类，使用包装类的valueOf()
　　　　　　　　　　String s = "100";
　　　　　　　　　　Integer num1 = Integer.valueOf(s);
　　　　　　　　　　Double num2 = Double.valueOf(s);

　　　　　　    String – int	  //将String转换为基本数据类型,使用对应包装类的parseXXX()即可
　　　　　　　　　　String str = "100";
　　　　　　　　1).    int num1 = new Integer(str).intValue();
　　　　　　　　2).    int num2 = Integer.parseInt(str); //推荐，*记住很重要*
　　　　　　　　3).    double num3 = Double.parseDouble(str)

　　　　　　    int – String
　　　　　　　　　　int value = 100;
　　　　　　　　1).    String s1 = "" + value;
　　　　　　　　2).    String s2 = String.valueOf(value); //推荐，它可以将任意类型转换成字符串
　　　　　　　　3).    String s3 = new Integer(value).toString();
　　　　　　　　4).    String s4 = Integer.valueOf(value).toString();
　　　　　　　　5).    String s5 = Integer.toString(value);

​ B. 进制转换（了解）

　　　　　　　　public static String toBinaryString(int i)
　　　　　　　　public static String toOctalString(int i)
　　　　　　　　public static String toHexString(int i)
　　　　　　　　public static String toString(int i, int radix)
　　　　　　　　public static int parseInt(String s, int radix)

　　　　　　    常用的基本进制转换：
　　　　　　　　public static String toBinaryString(int i)
　　　　　　　　　　System.out.println(Integer.toBinaryString(100));// 1100100
　　　　　　　　public static String toOctalString(int i)
　　　　　　　　　　System.out.println(Integer.toOctalString(100));// 144
　　　　　　　　public static String toHexString(int i)
　　　　　　　　　　System.out.println(Integer.toHexString(100));// 64

　　　　　　    十进制转其他进制：
　　　　　　　　public static String toString(int i, int radix) ：radix的范围（即进制的范围）2 – 36
　　　　　　　　为什么？ 0,...9,a...z 一共36个
　　　　　　　　　　System.out.println(Integer.toString(100, 2).toUpperCase());// 1100100
　　　　　　　　　　System.out.println(Integer.toString(100, 8).toUpperCase());// 144
　　　　　　　　　　System.out.println(Integer.toString(100, 16).toUpperCase());// 64
　　　　　　　　　　System.out.println(Integer.toString(100, 1).toUpperCase());// 100
　　　　　　　　　　System.out.println(Integer.toString(100, 37).toUpperCase());// 100

　　　　　　    其他进制转十进制：
　　　　　　　　public static int parseInt(String s, int radix)
　　　　　　　　System.out.println(Integer.parseInt("1100100", 2));// 100
　　　　　　　　System.out.println(Integer.parseInt("144", 8));// 100
　　　　　　　　System.out.println(Integer.parseInt("64", 16));// 100

　　　　　　　　System.out.println(Integer.parseInt("100", 10));// 100
　　　　　　　　System.out.println(Integer.parseInt("100", 2));// 4
　　　　　　　　System.out.println(Integer.parseInt("100", 8));// 64
　　　　　　　　System.out.println(Integer.parseInt("100", 16));// 256
 
　　　　　　　　System.out.println(Integer.parseInt("123", 2)); //抛出：NumberFormatException - 如果 String 不包含可解析的 int。

案例

​ -128到127之间的数据缓冲池问题

​ 注意：Integer的数据直接赋值，如果在-128到127之间，会直接从缓冲池里获取数据

public class IntegerDemo {
    public static void main(String[] args) {
        Integer i1 = new Integer(127);
        Integer i2 = new Integer(127);
        System.out.println(i1 == i2); // false
        System.out.println(i1.equals(i2)); // true
        Integer i3 = new Integer(128);
        Integer i4 = new Integer(128);
        System.out.println(i3 == i4); // false
        System.out.println(i3.equals(i4)); // true
        Integer i5 = 128;
        Integer i6 = 128;
        System.out.println(i5 == i6); // false
        System.out.println(i5.equals(i6)); // true
        Integer i7 = 127;
        Integer i8 = 127;
        System.out.println(i7 == i8); // true
        System.out.println(i7.equals(i8)); // true
        // 通过查看源码，我们就知道了，针对-128到127之间的数据，做了一个数据缓冲池，如果数据是该范围内的，每次并不创建新的空间
        // Integer ii = Integer.valueOf(127);
    }
}

Character(了解)

​ Character 类在对象中包装一个基本类型 char 的值。Character 类型的对象包含类型为 char 的单个字段。

​ 此外，该类提供了几种方法，以确定字符的类别（小写字母，数字，等等），并将字符从大写转换成小写，反之亦然。

​ 字符信息基于 Unicode 标准，版本 4.0。

构造方法

public Character(char value)
    Character ch = new Character((char) 97);
    Character ch = new Character('a');
    System.out.println("ch:" + ch);//ch:a -- 说明重写了toString()方法。

成员方法

A.    public static boolean isUpperCase(char ch)：    判断给定的字符是否是大写
B.    public static boolean isLowerCase(char ch)：    判断给定的字符是否是小写
C.    public static boolean isDigit(char ch)：        判断给定的字符是否是数字字符
D.    public static char toUpperCase(char ch)：    	 把给定的字符转换为大写
E.    public static char toLowerCase(char ch)：    	 把给定的字符转换为小写

案例

​ 统计字符串中大写，小写及数字字符出现的次数

public class IntegerDemo {
    public static void main(String[] args) {
        // 定义三个统计变量。
        int bigCount = 0;
        int smallCount = 0;
        int numberCount = 0;
        // 键盘录入一个字符串。
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串：");
        String line = sc.nextLine();
        // 把字符串转换为字符数组。
        char[] chs = line.toCharArray();
        // 历字符数组获取到每一个字符
        for (int x = 0; x < chs.length; x++) {
            char ch = chs[x];
            // 判断该字符
            if (Character.isUpperCase(ch)) {
                bigCount++;
            } else if (Character.isLowerCase(ch)) {
                smallCount++;
            } else if (Character.isDigit(ch)) {
                numberCount++;
            }
        }
        // 输出结果即可
        System.out.println("大写字母：" + bigCount + "个");
        System.out.println("小写字母：" + smallCount + "个");
        System.out.println("数字字符：" + numberCount + "个");
    }
}

弊端

包装类的弊端，不断地拆装箱会引发性能问题：

public class Test {
    public static void main(String[] args) {
        Integer sum1 = 1;

        StopWatch stopWatch = new StopWatch();
        stopWatch.start();
        for (int i = 0; i < 1000000000; i++) {
            sum1 += 1; // Integer.valueOf(sum1.intValue() + i);
        }
        stopWatch.stop();
        System.out.println(stopWatch.getTotal(TimeUnit.MILLISECONDS)); // 当 sum1 为int类型时，只需要1毫秒
        System.out.println(sum1);
    }
}

重载和自动拆装箱

有更匹配的重载方法时，不自动拆装箱

public class Test {
    public static void main(String[] args) {
        fun(new Integer(3)); // Param is a Integer!
        fun(3); // Param is a int!
    }

    static void fun(Integer i) {
        System.out.println("Param is a Integer!");
    }

    static void fun(int i) {
        System.out.println("Param is a int!");
    }
}

常量池

注意：包装类的比较必须使用equals()， ‘==’ 比较的是两个引用是否指向一个对象。

包装类的创建很浪费性能，因此Java对简单的数字（-128~127）对应的包装类进行了缓存，称为常量池。通过直接量赋值的包装类如果在此范围内，会直接使用常量池中的引用。

public class Test {
    public static void main(String[] args) {
        Integer i1 = 200;
        Integer i2 = 200;
        Integer i3 = 100;
        Integer i4 = 100;
        Integer i5 = new Integer(100);

        System.out.println(i1 == i2); // false
        System.out.println(i3 == i4); // true
        System.out.println(i3 == i5); // false
    }
}