常用类

1.包装类

把八大基本数据类型封装到一个类中（包装类），并提供属性和方法。让我们更加方便的操作基本数据类型。但包装类的出现并不是为了取代基本数据类型，也取代不了。

包装类位于java.lang包中。

Number 类

Number数值类型是byte、double、float、int、long 和 short类的抽象父类，提供把包装类转化成基本数据类型的方法(xxxValue)。

为了编程的方便还是引入了基本数据类型，但是为了能够将这些基本数据类型当成对象操作，Java为每一个基本数据类型都引入了对应的包装类型（wrapper class），int的包装类就是Integer，从Java 5开始引入了自动装箱/拆箱机制，使得二者可以相互转换。

1 基本数据类型: boolean，char，byte，short，int，long，float，double
2 封装类类型：Boolean，Character，Byte，Short，Integer，Long，Float，Double

2.Interger

Interger 是int基本数据类型的包装类，在Integer内部封装了一个final int value的属性。

2.1常用方法

[1] 构造方法

 1 public static void main(String[] args) {
 2         // 【1】Integer 属性
 3         //System.out.println(Integer.MAX_VALUE);
 4         //System.out.println(Integer.MIN_VALUE);
 5         
 6         // 【2】构造方法
 7         int a = 10;
 8         String bStr = "20";
 9         Integer i1 = new Integer(a);
10         // 可能抛出NumberFormatException异常
11         Integer i2 = new Integer(bStr);
12         System.out.println(i1.toString());
13         System.out.println(i2.toString());
14     }

[2] int<->Integer<->string

 1 public static void main(String[] args) {
 2         
 3         // int->Integer
 4         Integer i1 = new Integer(10);
 5         Integer i2 = Integer.valueOf(20);
 6         
 7         // Integer->int
 8         int a = i1.intValue();
 9         
10         // String->Integer
11         Integer i3 = new Integer("30");
12         Integer i4 = Integer.valueOf("40");
13         
14         //Integer->String
15         System.out.println(i3.toString());
16         
17         
18         // String->int
19         int b = Integer.parseInt("50");
20         
21         // int->String
22         String str = Integer.toString(10);
23         //String str2 = Integer.toString(8, 2);
24         //System.out.println(str2);
25     }

【3】comparaber接口

comparaber表示具有比较的能力，对象可以用来比较大小，此接口强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序。

Comparable 定义了a.compareTo(b),返回值表示

a.compareTo(b)	返回值	排序
a < b	负整数	升序
a = b	0	相等
a > b	正整数	降序

【2】Integer的比较

Integer i2 = new Integer(20);
Integer i3 = new Integer(10);
        
System.out.println(i2.equals(i3));
System.out.println(i2.compareTo(i3));

2.2自动装箱和自动拆箱

自动装箱

integer i = 10；

自动拆箱

i++；//因为i自动转换成int类型，所以可以进行自加1的运算

 1 public static void main(String[] args) {
 2         
 3         // Integer i1 = new Integer(10);
 4         // 自动装箱
 5         Integer i2 = 20; // i2 = new Integer(20);
 6         System.out.println(i2.toString());
 7         
 8         // 自动拆箱
 9         Integer i3 = new Integer(30);
10         int a = i3; // i3.intValue();
11     }

注意:

[1]自动装箱和自动拆箱是jdk1.5

[2]不要过于频繁的使用拆装箱操作

2. 3.其他基本数据类型的包装类和integer的使用方法基本相同

3.String

3.1字符串的本质

String类代表字符串。java 程序中的所有字符串字面值（如"abc"）都作为此类的对象。

字符串本质上是一个字符数组，它们的值在创建之后不能更改，所以我们认为字符串是常量。可以把字符串看成是字符数组的包装类，内部声明一个private finaly char value[ ];

因为String对象是不可以变得，所以可以共享（通常我们把固定不变得东西设置为静态常量，这样方便我们访问。）

通过字面量创建的字符串分配在常量区。

3.2String的常用方法

【1】构造方法

 1 public static void main(String[] args) {
 2         // 在堆区初始化一个空字符串
 3         String str1 = new String();
 4         
 5         // 通过一个字节数组构建一个字符串
 6         byte[] bytes = {97,98,99};
 7         // 通过使用平台的默认字符集解码指定的 byte 数组
 8         // System.out.println(Charset.defaultCharset());
 9         String str2 = new String(bytes);
10         System.out.println(str2);
11         
12         byte[] byte2 = {-42,-48};
13         String str3 = null;
14         try {
15             // 使用指定的字符集对字节序列进行解码
16             str3 = new String(byte2,"GBK");
17         } catch (UnsupportedEncodingException e) {
18             e.printStackTrace();
19         }
20         System.out.println(str3);
21         
22         // 需求:对一个utf-8的字节序列进行解码
23         byte[] byte3 = {-28,-72,-83,-28,-72,-83};
24         try {
25             // sssString str4 = new String(byte3, "UTF-8");
26             String str4 = new String(byte3,0,3, "UTF-8");
27             System.out.println("str4:"+str4);
28         } catch (UnsupportedEncodingException e) {
29             e.printStackTrace();
30         }
31         
32         // 通过字符数组构建字符串
33         char[] c1 = {'a','b','c','中','国'};
34         // String str5 = new String(c1);
35         String str5 = new String(c1,0,3);
36         System.out.println(str5);
37         
38         String str6 = new String("abc");
39         String str7 = "abc";
40         System.out.println(str6 == str7);
41         
42     }

【2】字符串的比较

 1 public static void main(String[] args) {
 2         // 【3】字符串比较
 3         String str1 = "abc";
 4         String str2 = "Abc";
 5         
 6         System.out.println(str1.compareTo(str2));
 7         // 忽略大小写比较
 8         System.out.println(str1.compareToIgnoreCase(str2));
 9         
10         // 需求:请输入验证码
11         /*String validCode = "a4Df";
12         System.out.println("请输入验证码:"+validCode);
13         Scanner sc = new Scanner(System.in);
14         String inputStr = sc.next();
15         
16         if(inputStr.compareToIgnoreCase(validCode) == 0) {
17             System.out.println("验证码正确");
18         }else {
19             System.out.println("验证码错误");
20         }*/
21         
22         System.out.println(str1.contentEquals(str2));
23         System.out.println(str1.equals(str2));
24         System.out.println(str1.equalsIgnoreCase(str2));
25     }

compareTo、equals 比较内容是否相等，compareToIgnoreCase、equalsIgnoreCase忽略大小写比较内容是否相等，contentEquals可以是String与stringbuffer及StringBuilder比较。

charSequence接口把字符串看成是一个可读序列，提供了charAt（inddex）获取指定索引处的字符；length() 字符数组或者字符串的长度。

【3】查找、搜索字符串

public static void main(String[] args) {
        // 【3】查找、搜索字符串中是否包含其他子串
        String str1 = "hello world";
        
        // 是否包含子串
        System.out.println(str1.contains("world"));
        
        System.out.println(str1.startsWith("he"));
        System.out.println(str1.endsWith("world"));
        System.out.println(str1.startsWith("ll", 2));
    
        // 需求:判断一个文件是否是png图片
        String fileName = "logo.png";
        if(fileName.endsWith(".png")) {
            System.out.println(fileName+"是一张图片");
        }
        
        
        // 查找字符串
        String str2 = "hello world hello";
        // 从左向右查找字符'o'第一次出现的位置,找到返回索引，没找到返回-1
        System.out.println(str2.indexOf('t'));
        System.out.println(str2.indexOf('o',5));
        // 从左向右查找字符串“ll”第一次出现的位置,找到返回索引，没找到返回-1
        System.out.println(str2.indexOf("ll"));
        System.out.println(str2.indexOf("ll",5));
        
        // 从右向左查找字符'o'第一次出现的位置,找到返回索引，没找到返回-1
        System.out.println(str2.lastIndexOf('o'));
        // lastIndex(char,fromIndex)
        // lastIndex(string);
        // lastIndex(string,fromIndex);
    }

【4】格式化字符串（fomat）

通过站位符（以%开始）格式化字符串。

%d	格式化整形
%f	格式化浮点型
%.nf	格式化浮点型四舍五入保留n为小数，
%c	格式化字符
%s	格式化字符串

1 public class Test06 {
2     public static void main(String[] args) {
3         int a = 15;
4         int b = 3;
5         float price = 19.7598f;
6         System.out.println(String.format("%d / %d = %d", a,b,(a/b)));
7         System.out.println(String.format("%.2f", price)); //保留两位小数，按照四舍五入
8     }
9 }

【5】把字符串按指定的编码集编码成对应的byte[];

 1 //        String str3 = "abc";
 2         String str3 = "中国";        
 3         // 使用默认的字符集（GBK）
 4         byte[] byte1 = str3.getBytes();
 5         System.out.println(Arrays.toString(byte1));
 6         
 7         
 8         //String str4 = "abc";
 9         String str4 = "中国";    
10         // 使用utf8编码
11         byte[] bytes2 = str4.getBytes("UTF-8");
12         System.out.println(Arrays.toString(bytes2));

【6】替换字符串

 1 public static void main(String[] args)  {
 2         
 3         String str1 = "hello,world";
 4         String newStr1 = str1.replace('o', '8');
 5         System.out.println(newStr1);
 6         
 7         String newStr2 = str1.replace("ll", "");
 8         System.out.println(newStr2);
 9         
10         // 需求:186-1234-2234
11         String str3 = "186-1234-2234";
12         System.out.println(str3.replace("-", ""));
13         
14         // 正则表达式专门用于验证字符串是否符合特定的格式。
15         String str4 = "6764";
16         // 验证str4是否输入的是一串数字
17         boolean r = str4.matches("\d+");
18         System.out.println(r);
19         
20         // 需求:abc123te23daf去掉数字
21         String str5 = "abc123te23daf";
22 //        String newStr5 = str5.replaceAll("\d+", "");
23         String newStr5 = str5.replaceFirst("\d+", "");
24         System.out.println(newStr5);
25         
26     }

【7】拆分字符串

 1 public static void main(String[] args)  {
 2         
 3         //【7】 根据指定字符串拆分字符串
 4         String str1 = "abc-123";
 5         String[] arr = str1.split("-");
 6         System.out.println(Arrays.toString(arr));
 7         
 8         // 需求:请快速构建一个26个小写英文字母的数组
 9         String str2= "abcdefghijklmnopqrstuvwxyz";
10         String[] arr2 = str2.split("");        
11         System.out.println(Arrays.toString(arr2));
12         
13         // 根据正则拆分字符串
14         String str3 = "abc123ta12asd";
15         String[] arr3 = str3.split("\d+");
16         System.out.println(Arrays.toString(arr3));
17         
18         
19         // 需求:请获取一个文件的文件名
20         String fileName = "logo.png";
21         String[] arr4 = fileName.split("\.");
22         System.out.println(Arrays.toString(arr4));
23         
24     }

【8】求子串及大小写转换。

 1 public static void main(String[] args)  {
 2         
 3         //【8】 求子串
 4         String str1 = "abc123";
 5         // fromIndex:开始位置，endInde 结束的位置 
 6         // 含头不含尾
 7         String sub1 = str1.substring(0, 3);
 8         System.out.println(sub1);
 9         
10         String sub2 = str1.substring(3);
11         System.out.println(sub2);
12         
13         
14         // 【9】大小写转换
15         String str3 = "Abc";
16         System.out.println(str3.toUpperCase());
17         System.out.println(str3.toLowerCase());
18         
19     }

【9】其他方法

 1 public static void main(String[] args)  {
 2         
 3         // 去掉前导空格和后导空格
 4         String str1 = "  abc   ";
 5         String newStr1 = str1.trim();
 6         System.out.println(str1.length());
 7         
 8         // 获取字符串的字符数组
 9         char[] arr = str1.toCharArray();
10         System.out.println(Arrays.toString(arr));
11         
12         
13         // 把其他数据类型转化为字符串
14         String str2 = String.valueOf(10);
15         System.out.println(str2);
16     }

4.Stringbuffer

StringBuffer是字符的可变容器。可以在程序运行过程中向容器中添加、删除、修改字符。

StringBuffer 本质上是一个字符数组的包装类，并提供了很多方法向这个字符数组中添加、删除、修改字符。

StringBuffer 是线程安全的

4.1 StringBuffer工作原理

StringBuffer 内部维护了一个字符数组，默认字符数组的长度是16.当开发者向这个字符数组中添加元素时，如果有额外空间，直接添加到数组中，如果没有额外空间，StringBuffer内部自动拓容，拓容规则:当前容量*2+2,根据拓容的新空间，复制当前的数组内容到新数组中。

 1 public static void main(String[] args) {
 2         
 3         StringBuffer sb = new StringBuffer();
 4         sb.append("a");
 5         sb.append("b");
 6         System.out.println(sb.capacity());
 7         
 8         sb.append("1234567890ABCD");
 9         sb.append('x');
10         System.out.println(sb);
11         System.out.println(sb.capacity());
12         
13         // 未来如果确定不再向sb中添加字符，
14         // 优化内部的数组到指定的长度
15         sb.trimToSize();
16         System.out.println(sb.capacity());
17     }

4.2常用方法

 1 package cn.sxt03.string02;
 2 
 3 public class Test01 {
 4     public static void main(String[] args) {
 5         
 6         StringBuffer sb1 = new StringBuffer();
 7         // 【1】添加
 8         sb1.append("hello");
 9         sb1.append('d');
10         
11         // 返回字符串的长度
12         System.out.println(sb1.length());
13         // 返回容器的大小
14         System.out.println(sb1.capacity());
15         
16         // 【2】删除
17         //System.out.println(sb1);
18         //sb1.delete(0, 5);
19         //System.out.println(sb1);
20         
21         // 【3】insert(index,t) 在指定位置index添加t
22         sb1.insert(0, "123");
23         System.out.println(sb1);
24         
25         // 【4】修改
26         sb1.setCharAt(0, 'A');
27         System.out.println(sb1);
28         
29         // 【5】setLength
30         sb1.setLength(0); // 清空容器内容
31         sb1.append("中国");
32         System.out.println(sb1);
33     }
34 }

5.StringBuilder

StringBuffer 是线程安全的，执行效率低，JDK1.0

StringBuiler 就是为了缓解执行效率低而产生的，但线程不安全。JDK 1.5