06Java常用类1

Object类

API 的概述:

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

介绍

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

构造方法

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

要掌握的方法

  A: public String toString()

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

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

​ 如何重写呢?

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

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

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

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

​ 注意:

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

img

1
2
3
4
5
6
7
8
9
10
11
12
13
14
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):指示其他某个对象是否与此对象”相等”

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

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

​ 如何重写?

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

​ 最终还是自动生成。

img

要了解的方法

​ A: public int hashCode()

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

    img

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

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

​ 应用:反射。

    Class类的方法:

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

   img

​ C: protected void finalize()

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

​ D: protected Object clone()

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

img

注意

​ 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);

img

基本方法格式

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

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

img

要掌握的方法

​ A: public int nextInt()

​ B: public String nextLine()

img

注意

  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”; // 字符串常量

img

特点

​ A: 字符串是常量;它们的值在创建之后不能更改(字符串一旦被赋值,就不能改变。)

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

img

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

    String s = new String(“hello”);和 String s = “hello”;的区别?

img

练习

​ A: ==和equals()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
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: 字符串的拼接

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

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

    //通过反编译工具查看

1
2
3
4
5
6
7
8
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():判断字符串是否为空

img

    注意:

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

      String s = “”;

      String s = null;

img

获取功能

    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。

img

转换功能

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

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

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

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

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

1
2
3
4
5
6
7
8
9
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):把字符串拼接

img

其他功能

    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)

img

   自己写的compareTo方法:

img

String类的compareTo方法的源码解析:

img

练习

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

  B: 字符串遍历

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

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

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

  F: 字符串反转

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

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

img

练习B:字符串遍历

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
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:统计一个字符串中大写字母字符,小写字母字符,数字字符出现的次数。(不考虑其他字符)

img

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

img

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

img

练习F:字符串反转

  分析:

    A:键盘录入一个字符串

    B:定义一个新字符串

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

      a:length()和charAt()结合

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

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

  E:输出新串

img

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

img

StringBuffer类

介绍

​ 可变的字符序列。

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

构造方法

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

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

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

常用方法

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

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

img

常见功能

添加功能

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

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

img

删除功能

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

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

img

替换功能

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

img

反转功能

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

img

截取功能(注意返回值)

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

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

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

img

练习

  A:String和StringBuffer相互转换

  注意:不能把字符串的值直接赋值给StringBuffer,String和StringBuffer不能相互赋值

    String – StringBuffer

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

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

    StringBuffer – String

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

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

img

  B:字符串的拼接

img

  C:把字符串反转

img

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

img

String、StringBuilder、StringBuffer

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

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

img

一、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 作为形参问题

img

四、线程安全(多线程部分)

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

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

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

  安全:医院的网站,银行网站

  效率:新闻网站,论坛之类的

数组高级以及Arrays

排序

(参考 排序算法 )

​ A:冒泡排序

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

1
2
3
4
5
6
7
8
9
10
11
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索引。同理,其他的元素就可以排好。

1
2
3
4
5
6
7
8
9
10
11
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:基本查找

    针对数组无序的情况

1
2
3
4
5
6
7
8
9
10
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:二分查找(折半查找)

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
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) 二分查找

img

Arrays工具类的源码解析

  public static String toString(int[] a)

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

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

img

字符串按字符排序

(详见 排序算法 )

  举例:

    “edacbgf”

    得到结果

    “abcdefg”

包装类

定义

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

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

  byte Byte

  short Short

  int Integer

  long Long

  float Float

  double Double

  char Character

  boolean Boolean

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

装箱与拆箱

装箱

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

​ 自动装箱 基本类型 – 包装类类型(引用类型)

拆箱

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

​ 自动拆箱 包装类类型(引用类型)– 基本类型

自动装箱与拆箱

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
        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 类型时非常有用的其他一些常量和方法。

构造方法

1
2
3
4
5
6
7
8
9
10
11
         public Integer(int value)

        Integer i = new Integer(100);

     public Integer(String s)

        Integer i = new Integer("100");

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

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

成员方法

1
2
3
4
5
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、包装类、基本数据类型 的相互转换

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
        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. 进制转换(了解)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
        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的范围(即进制的范围)236
        为什么? 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之间,会直接从缓冲池里获取数据

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
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。

构造方法

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

成员方法

1
2
3
4
5
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): 把给定的字符转换为小写

案例

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
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 + "个");
}
}

弊端

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
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);
}
}

重载和自动拆装箱

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
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)对应的包装类进行了缓存,称为常量池。通过直接量赋值的包装类如果在此范围内,会直接使用常量池中的引用。

1
2
3
4
5
6
7
8
9
10
11
12
13
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
}
}