Java常用类(包装类 String StringBuffer StringBuilder Data Math Array System BigInteger BidDecimal)

青旅半醒 2024-03-31 14:05 29阅读 0赞

#### 文章目录 ####

*   *  包装类
     *   *   *  包装类和基本数据的转换
             *  String与Integer互转
     *  String类
     *   *   *  创建String对象的方式
             *  测试题
             *  字符串的特性
             *  String类的常用方法
     *  StringBuffer类
     *   *   *  String VS StringBuffer
             *  StringBuffer的构造器
     *  StringBuilder类
     *   *   *  String、 StringBuffer和StringBuilder的比较
             *  String、 StringBuffer和StringBuilder的效率测试
             *  String、 StringBuffer和StringBuilder的选择原则
     *  Math类
     *  Arrays类
     *   *   *  正常的排序
             *  定制排序, 重写Comparator
             *  普通的冒泡
             *  结合冒泡＋定制
             *  自定义类排序
     *  System类
     *  BigInteger类和BigDecimal类
     *  Date日期类、Calendar日历类以及新的日期LocalDate
     *   *   *  第一代日期类Date
             *  第二代日期类Calendar
             *  第三代日期类
     *  本章作业

### 包装类 ###

包装类的分类  
1.针对八种基本定义相应的引用类型一一包装类  
2.有了类的特点，就可以调用类中的方法。

![image-20221119170805199][]

##### 包装类和基本数据的转换 #####

演示包装类和基本数据类型的相互转换，这里以int和Integer演示。

1.  jdk5前的手动装箱和拆箱方式，装箱:基本类型->包装类型，反之，拆箱
2.  jdk5以后(含jdk5)的自动装箱和拆箱方式
3.  自动装箱底层调用的是`valueOf`方法，比如`Integer.valueOf()`
4.  其他包装类的用法类似

public class Integer02 {
        
        public static void main(String[] args) {
        
    		// jdk5以前是手动装箱和拆箱
            int n1 = 22;
            // 手动装箱 int-> Integer
            Integer integer = new Integer(n1);
            Integer integer1 = Integer.valueOf(n1);
            // 手动拆箱 Integer->int
            int i = integer.intValue();
    
            // jdk5以后就可以自动装箱和自动拆箱
            int n2 = 100;
            // 自动装箱 int->Integer
            Integer integer2 = n2;  // 底层使用的是 Integer.valueOf()
            // 自动拆箱 Integer->int
            int i2 = integer2;  // 底层使用的是 intValue()
        }
    }

![image-20221119204230420][]

##### String与Integer互转 #####

public class Exception02 {
        
        public static void main(String[] args) {
        
            // 包装类Integer -> String
            Integer i = 100;// 自动装箱 
            // 方式1
            String str1 = i + "";
            // 方式2
            String str2 = i.toString();
            // 方式3
            String str3 = String.valueOf(i);
    
            // String -> Integer
            String str4 = "123456";
            Integer i2 = Integer.parseInt(str4);// 使用到自动装箱
            Integer i3 = new Integer(str4);// 构造器
        }
    }

![image-20221119210140491][]

![image-20221119210449034][]

![image-20221119211622729][]

### String类 ###

1.  String对象用于保存字符串，也就是一组字符序列
2.  字符串常量对象是用双引号括起的字符序列。例如: “你好”、 “12.97”、 "boy"等
3.  字符串的字符使用Unicode字符编码，一个字符(不区分字母还是汉字)占两个字节。
4.  String类较常用构造器(其它看手册):

String s1 = new String(); 
    String s2 = new String(String original);
    String s3 = new String(char[] a);
    String s4 = new String(char[] a,int startIndex,int count)

![image-20221130121232538][]

Serializable 意味着可以在网络传输

Comparable 可以比较

##### 创建String对象的方式 #####

![image-20221130122022760][]

public class String01 {
        
        public static void main(String[] args) {
        
            // 方式1: 先从常量池查看是否有"hsp"数据空间，如果有，直接指向;
            // 如果没有则重新创建，然后指向。
            // s1最终指向的是常量池的空间地址
            String s1 = "hsp";
            // 方式二:先在堆中创建空间，里面维护了value属性，指向常量池的hsp空间。
            // 如果常量池没有"hsp"，重新创建，如果有，直接通过value指向。
            // 最终指向的是堆中的空间地址。
            String s2 = new String("hsp");
        }
    }

![image-20221130122818945][]

##### 测试题 #####

![image-20221130123133619][]

2) 测试题2
    public class String01 {
        
        public static void main(String[] args) {
        
            String a = "hsp";//指向常量池中的"hsp"
            String b = new String("hsp");//指向堆中对象, 堆的对象再指向常量"hsp"
            System.out.println(a.equals(b));//T, 内容相同
            System.out.println(a == b);//F
            System.out.println(a == b.intern()); //T, b.intern()方法返回常量池中的地址
            System.out.println(b == b.intern());//F
        }
    }

![image-20221130160148341][]

![image-20221130160507264][]

##### 字符串的特性 #####

1.  String是一个final类， 代表不可变的字符序列
2.  字符串是不可变的。一个字符串对象一旦被分配，其内容是不可变的.

以下语句创建了几个对象?画出内存布局图。

String s1 = "hello";
    s1 = "haha";

两个!

![image-20221130160817086][]

以下语句创建了几个对象

String a="hello"+"abc";

分析

一个! 编译器做一个优化，判断创建的常量池对象，是否有引用指向  
`String a = "hello"+"abc";` =》`String a = "helloabc";`

再来 以下语句创建了几个对象

String a="hello";
    String b="abc";
    String c=a+b;

在第三句话 打断点咱们来瞅瞅

首先新建了StringBuilder对象, 然后append “hello”, 然后append “abc”, 最后toString().

所以新建了三个对象

底层是StringBuilder sb = new StringBuilder(; sb.append(a);  
sb.append(b); sb是在堆中，并且append是在原来字符串的基础上追加的.

重要规则，

`String c1 = "ab" + "cd";` 常量相加，看的是池。

`String c1 = a+b;` 变量相加, 是在堆中

public class String01 {
        
        public static void main(String[] args) {
        
            String a = "hello"; //创建a对象
            String b = "abc";//创建 b对象
            //老韩解读
            //1. 先创建个StringBuilder sb = StringBuilder()
            //2.执行sb. append("hello");
            //3. sb.append("abc");
            //4. String c= sb.toString()
            //最后其实是c指向堆中的对象(String) value[] ->池中"helloabc"
            String c = a + b;
            String d = "helloabc";
            System.out.println(c == d);// 真还是假?是false
            String e = "hello" + "abc";// 直接看池，e指向常量池
            System.out.println(d == e);//真还是假?是true
        }
    }

##### String类的常用方法 #####

String类是保存字符串常量的。每次更新都需要重新开辟空间，效率较低，因此java设计者还提供了StringBuilder和StringBuffer来增强String的功能，并提高效率。

equals /区分大小写，判断内容是否相等  
equalslgnoreCase //忽略大小写的判断内容是否相等  
length //获取字符的个数，字符串的长度  
indexOf //获取字符在字符串中第1次出现的索引,索引从开始，如果找不到,返回-1  
lastIndexOf //获取字符在字符串中最后1次出现的索引,索引从0开始,如找不到,返回-1  
substring //截取指定范围的子串  
trim //去前后空格  
charAt //获取某索引处的字符，注意==不能使用Str\[index\]==这种方式.

### StringBuffer类 ###

java.lang.StringBuffer代表可变的字符序列，可以对字符串内容进行增删。  
很多方法与String相同，但StringBuffer是 可变长度的。  
StringBuffer是一个容器。

##### String VS StringBuffer #####

1.  String保存的是字符串常量，里面的值不能更改，每次String类的更新实际上就是更改地址，效率较低 //private final char value\[\];
2.  StringBuffer保存的是字符串变量，里面的值可以更改，每次StringBuffer的更新实际上可以更新内容，不用更新地址，效率较高  
    //char\[\] value; // 这个放在堆.

![image-20221130213006145][]

//1. StringBuffer 的直接父类是AbstractStringBuilder  
//2. StringBuffer 实现了Serializable, 即StringBuffer的对象可以串行化  
//3. 在父类中 AbstractStringBuilder 有属性char\[\] value, 不是final  
// 该vaLue数组存放字符串内容，引出存放在堆中的  
//4. StringBuffer 是一个final类， 不能被继承  
//5. 因为StringBuffer字符内容是存在char\[\] vaLue, 所有在变化(增加/删除) 不用每次都更换地址(即创建新对象), 所以效率高于String

##### StringBuffer的构造器 #####

![image-20221130213549019][]

●StringBuffer类常见方法

1)增append  
2)删delete(start,end)  
3)改replace(start,end,string)//将start-end间的内容替换掉,不含end  
4)查indexOf //查找子串在字符串第1次出现的索引,如果找不到返回-1  
5)插insert  
6)获取长度length

![image-20221130221430498][]

输入商品价格，要求打印效果示例，使用前面学习的方法完成:  
手机`123,564.59` //比如价格`3,456,789.88`

要求:价格的小数点前面每三位用逗号隔开，在输出。

public class String01 {
        
        public static void main(String[] args) {
        
            String price = "38976666.66";
            StringBuffer sb = new StringBuffer(price);//转成StringBuffer
            // 找到小数点的索引, 然后在该位置的前面每三位插入即可
            int i = sb.lastIndexOf(".");
            for (int j = i; j > 3; j -= 3) {
        
                sb.insert(j - 3, ',');
            }
            System.out.println(sb);
        }
    }

### StringBuilder类 ###

1)一个可变的字符序列。此类提供一个与StringBuffer兼容的API,但不保证同步(StringBuilder不是线程安全)。该类被设计用StringBuffer的一个简易替换，用在字符串缓冲区被单个线程使用的时候。如果可能，建议优先采用该类因为在大多数实现中，它比StringBuffer要快。  
2)在StringBuilder上的主要操作是append和insert方法，可重载这些方法，以接受任意类型的数据。

![image-20221130225217612][]

1.  StringBuilder 继承AbstractStringBuilder类
2.  实现了Serializable ,说明StringBuilder对象是可以串行化(对象可以网络传输，可以保存到文件)
3.  StringBuilder 是final类，不能被继承
4.  StringBuilder 对象字符序列仍然是存放在其父类AbstractStringBuilder的 char\[\] value ;  
    因此，字符序列是存在堆中
5.  StringBuilder 的方法，没有做互斥的处理，即没 有synchronized 关键字,因此在 单线程的情况下使用StringBuilder

##### String、 StringBuffer和StringBuilder的比较 #####

1.  StringBuilder和StringBuffer非常类似，均代表可变的字符序列，而且方法也一样
2.  String:不可变字符序列，效率低,但是复用率高。
3.  StringBuffer:可变字符序列、效率较高(增删)、线程安全，看源码
4.  StringBuilder:可变字符序列、效率最高、线程不安全
5.  String使用注意说明:  
    string s=“a”; //创建了一个字符串  
    s += “b”; //实际上原来的"a"字符串对象已经丢弃了，现在又产生了一个字符串s+“b” (也就是ab")。  
    如果多次执行这些改变串内容的操作，会导致大量副本字符串对象存留在内存中，降低效率。  
    如果这样的操作放到循环中，会极大影响程序的性能=>  
    结论:如果我们对String做大量修改，不要使用String

##### String、 StringBuffer和StringBuilder的效率测试 #####

public class String01 {
        
        public static void main(String[] args) {
        
            String text = "";
            long startTime = 0L;
            long endTime = 0L;
            StringBuffer buffer = new StringBuffer("");
            StringBuilder builder = new StringBuilder("");
            startTime = System.currentTimeMillis();
            for (int i = 0; i < 200000; i++) {
        
                buffer.append(String.valueOf(i));
            }
            endTime = System.currentTimeMillis();
            System.out.println("StringBuffer的执行时间: " + (endTime - startTime));
            startTime = System.currentTimeMillis();
            for (int i = 0; i < 200000; i++) {
        
                builder.append(String.valueOf(i));
            }
            endTime = System.currentTimeMillis();
            System.out.println("StringBuilder的执行时间: " + (endTime - startTime));
            startTime = System.currentTimeMillis();
            for (int i = 0; i < 200000; i++) {
        
                text = text + i;
            }
            endTime = System.currentTimeMillis();
            System.out.println("String的执行时间:" + (endTime - startTime));
        }
    }

> StringBuffer的执行时间: 23  
> StringBuilder的执行时间: 18  
> String的执行时间:28168

##### String、 StringBuffer和StringBuilder的选择原则 #####

使用的原则，结论:  
1.如果字符串存在大量的修改操作，一般使用StringBuffer或StringBuilder  
2.如果字符串存在大量的修改操作，并在单线程的情况，使用StringBuilder  
3.如果字符串存在大量的修改操作，并在多线程的情况，使用StringBuffer  
4.如果我们字符串很少修改，被多个对象引用，使用String, 比如配置信息等  
StringBuilder的方法使用和StringBuffer一样，不再说

### Math类 ###

1.  abs绝对值
2.  pow求幂
3.  ceil向上取整
4.  floor 向下取整
5.  round四舍五入
6.  sqrt求开方
7.  random求随机数
8.  max求两个数的最大值
9.  min求两个数的最小值

### Arrays类 ###

Arrays里面包含了一系列静态方法，用于管理或操作数组(比如排序和搜索)。

1 toString返回数组的字符串形式 `Arrays.toString(arr)`

2 sort排序(自然排序和定制排序) `Integer arr[] = {1, -1, 7, 0, 89};`

3 binarySearch通过分搜索法进行查找， 要求必须排好序  
`int index = Arrays.binarySearch(arr, 3);`

##### 正常的排序 #####

由于数组是引用类型, 所以排序后原来的数据也更改了顺序

import java.util.Arrays;
    
    public class String01 {
        
        public static void main(String[] args) {
        
            int[] arr = {
        1, -1, 8, 5, 99};
            Arrays.sort(arr);
            System.out.println(Arrays.toString(arr));
        }
    }

##### 定制排序, 重写Comparator #####

import java.util.Arrays;
    import java.util.Comparator;
    
    public class String01 {
        
        public static void main(String[] args) {
        
            Integer[] arr = {
        1, -1, 8, 5, 99};
            Arrays.sort(arr, new Comparator() {
        
                @Override
                public int compare(Object o1, Object o2) {
        
                    Integer i1 = (Integer) o1;
                    Integer i2 = (Integer) o2;
                    return i1 - i2;
                }
            });
            System.out.println(Arrays.toString(arr));
        }
    }

##### 普通的冒泡 #####

import java.util.Arrays;
    
    public class String01 {
        
        public static void bubble(int[] arr) {
        
            int tmp = 0;
            for (int i = 0; i < arr.length - 1; i++) {
        
                for (int j = 0; j < arr.length - 1 - i; j++) {
        
                    // 写个从小排到大的
                    if (arr[j] > arr[j + 1]) {
        
                        tmp = arr[j] ^ arr[j + 1];
                        arr[j] = tmp ^ arr[j];
                        arr[j + 1] = tmp ^ arr[j + 1];
                    }
                }
            }
        }
    
        public static void main(String[] args) {
        
            int[] arr = {
        1, -1, -99, 8, 5, 99};
            bubble(arr);
            System.out.println(Arrays.toString(arr));
        }
    }

##### 结合冒泡＋定制 #####

import java.util.Arrays;
    import java.util.Comparator;
    
    public class String01 {
        
        public static void bubble(int[] arr, Comparator c) {
        
            int tmp = 0;
            for (int i = 0; i < arr.length - 1; i++) {
        
                for (int j = 0; j < arr.length - 1 - i; j++) {
        
                    // 写个从小排到大的
                    if (c.compare(arr[j], arr[j + 1]) > 0) {
        
                        tmp = arr[j] ^ arr[j + 1];
                        arr[j] = tmp ^ arr[j];
                        arr[j + 1] = tmp ^ arr[j + 1];
                    }
                }
            }
        }
    
        public static void main(String[] args) {
        
            int[] arr = {
        1, -1, -99, 8, 5, 99};
            bubble(arr, new Comparator() {
        
                @Override
                public int compare(Object o1, Object o2) {
        
                    int i1 = (Integer) o1;
                    int i2 = (Integer) o2;
                    return i1 - i2;
                }
            });
            System.out.println(Arrays.toString(arr));
        }
    }

##### 自定义类排序 #####

案例:自定义Book类， 里面包含name和price,按price排序(从大到小)。要求使用两种方式排序,有一个Book\[\] books = 4本书对象.  
使用前面学习过的传递实现Comparator接口匿名内部类，也称为定制排序。

import java.util.Arrays;
    import java.util.Comparator;
    
    class Book {
        
        int price;
        String name;
    
        public Book(String name, int price) {
        
            this.price = price;
            this.name = name;
        }
    
        @Override
        public String toString() {
        
            return "Book{" +
                    "price=" + price +
                    ", name='" + name + '\'' +
                    '}';
        }
    }
    
    public class String01 {
        
        public static void main(String[] args) {
        
            Book[] books = new Book[4];
            books[0] = new Book("红楼梦", 100);
            books[1] = new Book("金瓶梅新", 90);
            books[2] = new Book("青年文摘20年", 5);
            books[3] = new Book("Java从入门到放弃", 300);
            Arrays.sort(books, new Comparator<Book>() {
        
                @Override
                public int compare(Book o1, Book o2) {
        
                    return o1.price - o2.price;
                }
            });
            System.out.println(Arrays.toString(books));
        }
    }

### System类 ###

1.  exit退出当前程序
2.  arraycopy :复制数组元素，比较适合底层调用，一般使用  
    Arrays.copyOf完成复制数组.  
    int\[\] src=\{1,2,3\};  
    int\[\] dest = new int\[3\];  
    System.arraycopy(src, 0, dest, 0, 3);
3.  currentTimeMillens:返回当前时间距离1970-1-1的毫秒数
4.  gc:运行垃圾回收机制System.gc();

### BigInteger类和BigDecimal类 ###

应用场景:

1.  BigInteger适合保存比较大的整型
2.  BigDecimal适合保存精度更高的浮点型(小数)

BigInteger和BigDecimal常见方法

1.  add 加
2.  subtract 减
3.  multiply 乘
4.  divide 除

### Date日期类、Calendar日历类以及新的日期LocalDate ###

##### 第一代日期类Date #####

1.  Date:精确到毫秒，代表特定的瞬间
2.  SimpleDateFormat: 格式和解析日期的类  
    SimpleDateFormat格式化和解析日期的具体类。它允许进行格式化(日期->文本)、解析(文本->日期)和规范化

![image-20221201180514199][]

##### 第二代日期类Calendar #####

第二代日期类，主要就是Calendar类(日历)。  
public abstract class Calendar extends Object implements Serializable,  
Cloneable, Comparable < Calendar >

Calendar类是个抽象类，它为特定瞬间与一组诸如YEAR、 MONTH、DAY OF MONTH、HOUR等历， 专之间的转换提供了一 些方法， 并为操作日历字段(例如获得下星期的日期)提供了一些方法。

![image-20221201211612384][]

##### 第三代日期类 #####

➢前面两代日期类的不足分析  
JDK 1.0中包含了一个java.util.Date类，但是它的大多数方法已经在JDK 1.1引入  
Calendar类之后被弃用了。而Calendar也存在问题是:  
1)可变性:像日期和时间这样的类应该是不可变的。  
2)偏移性: Date中的年份是从1900开始的，而月份都从0开始。  
3)格式化:格式化只对Date有用，Calendar则不行。  
4)此外，它们也不是线程安全的;不能处理闰秒等(每隔2天，多出1s)

➢第三代日期类常见方法

LocalDate(日期/年月日)、LocalTime(时间/时分秒)、 LocalDateTime(日期时间/年月日) JDK8加入

LocalDate只包含日期，可以获取日期字段  
LocalTime只包含时间，可以获取时间字段  
LocalDateTime包含日期+时间，可以获取日期和时间字段

1.  使用now()返回表示当前日期时间的对象
2.  使用DateTimeFormatter对象来进行格式化
3.  Instant时间戳 类似于Date, 提供了一系列和Date类转换的方式
4.  第三代日期类更多方法  
    LocalDate Time类  
    MonthDay类:检查重复事件  
    是否是闰年  
    增加日期的某个部分  
    使用plus方法测试增加时间的某个部分  
    使用minus方法测试查看一年前和一年后的日期

### 本章作业 ###

编程题  
(1)将字符串中指定部分进行反转。比如将"abcd( f"反转为" aedcbf"  
(2)编写方法public static String reverse(String str, int start , int end)搞定

public class String01 {
        
        public static String reverse(String str, int start, int end) {
        
            char[] chars = str.toCharArray();
            char tmp = ' ';
            for (int i = start, j = end; i < j; i++, j--) {
        
                tmp = chars[i];
                chars[i] = chars[j];
                chars[j] = tmp;
            }
            return new String(chars);
        }
    
        public static void main(String[] args) {
        
            String s = "dd01234ddd";
            System.out.println(reverse(s, 2, 6));
        }
    }

[image-20221119170805199]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/aa27c1c8a6604dee88078a1fff417777.png
[image-20221119204230420]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/526af9d4f11f4f7d87448d04b8e8dc39.png
[image-20221119210140491]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/ed63a069e0b84864a7c657140a9ab5e1.png
[image-20221119210449034]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/33b0feec541b4b6589457f2abbb10a62.png
[image-20221119211622729]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/a0b8af55a7ee4a269da9977e19321ac2.png
[image-20221130121232538]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/83638297bfa8409f900b7647fb3660cd.png
[image-20221130122022760]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/555c30a995de493aaaa1ac29bdad031a.png
[image-20221130122818945]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/865663167cf24545992969bb62cb295c.png
[image-20221130123133619]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/47f11cb6fd1b455b9ae2ea0c480b0927.png
[image-20221130160148341]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/edd0581be0cd469b8a61379a326f2c8b.png
[image-20221130160507264]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/605c24eef2f54084b7f1a65c8a774fe8.png
[image-20221130160817086]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/3bbff8c20771489eb4bec6317da89ece.png
[image-20221130213006145]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/82d99903cee7483fa84cc28cf039e3d7.png
[image-20221130213549019]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/fecfa8b664d44c9a979ac9ed09a6f493.png
[image-20221130221430498]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/616e9330c192419d9601e94db08bbf9a.png
[image-20221130225217612]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/bae82e54c91748b5831920412c2c075c.png
[image-20221201180514199]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/569dd4417c6d414fa72ff9654a5a8a24.png
[image-20221201211612384]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/ad772e4cc1504c3cbe64caa107da7c4f.png