常用类

包装类

包装类的分类：
针对八种基本定义相应的引用类型-包装类；有了类的特点，就可以调用类中的方法
注：后六种的父类是Number，前两种是独立的，父类是Object

基本数据类型包装类
boolean Boolean
char Character
byte Byte
short Short
int Integer
long Long
float Float
double Double

基本数据类型	包装类
boolean	Boolean
char	Character
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double

包装类和基本数据类型的转换：
(1)jdk5 前的手动装箱和拆箱方式，装箱：基本类型 -> 包装类型，反之，拆箱
(2)jdk5 以后(含jdk5)的自动装箱和拆箱方式
(3)自动装箱底层调用的是 valueOf 方法，比如 Integer.valueOf()

public class Integer1 {
    public static void main(String[] args) {
        //手动装箱
        int n1 = 100;
        Integer integer = new Integer(n1);
        Integer integer1 = Integer.valueOf(n1);
        //手动拆箱
        int i = integer.intValue();
        
        //自动装箱
        int n2 = 200;
        Integer integer2 = n2;//在底层使用了valueOf()
        //自动拆箱
        int n3 = integer2;//在底层使用了intValue()
    }
}

包装类型和String类型的相互转换：

public class WrapperVSString {
    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->包装类
        String str4 = "1234";
        //方式1
        Integer i2 = Integer.parseInt(str4);
        //方式2
        Integer i3 = new Integer(str4);
    }
}

包装类常用方法：

方法	作用
Integer.MIN_VALUE	返回最小值
Integer.MAX_VALUE	返回最大值
Character.isDigit(‘a’)	判断是不是数字
Character.isletter(‘a’)	判断是不是字母
Character.isUpperCase(‘a’)	判断是不是大写
Character.isLowerCase(‘a’)	判断是不是小写
Character.isWhitespace(‘a’)	判断是不是空格
Character.toUpperCase(‘a’)	转成大写
Character.toLowerCase(‘A’)	转成小写

练习：
下面代码输出什么

public class WrapperExercise1 {
    public static void main(String[] args) {
        Integer i = new Integer(1);
        Integer j = new Integer(1);
        System.out.println(i == j);//false,相当于创建两个对象

        Integer m = 1;
        Integer n = 1;
        System.out.println(m == n);//true

        Integer x = 128;
        Integer y = 128;
        System.out.println(x == y);//false
        //范围-128~127，超过范围就new Integer()
    }
}

下面代码输出什么

public class WrapperExercise2 {
    public static void main(String[] args) {
        Integer i1 = new Integer(127);
        Integer i2 = new Integer(127);
        System.out.println(i1 == i2);//F
        
        Integer i3 = new Integer(128);
        Integer i4 = new Integer(128);
        System.out.println(i3 == i4);//F
        
        Integer i5 = 127;
        Integer i6 = 127;
        System.out.println(i5 == i6);//T
        
        Integer i7 = 128;
        Integer i8 = 128;
        System.out.println(i7 == i8);//F
        
        Integer i9 = 127;
        Integer i10 = new Integer(127);;
        System.out.println(i9 == i10);//F
        
        Integer i11 = 127;
        int i12 = 127;
        System.out.println(i11 == i12);//T
        //只要有基本数据类型，判断的是值是否相同
        
        Integer i13 = 128;
        int i14 = 128;
        System.out.println(i13 == i14);//T
    }
}

String类

String：
(1)String 类实现了接口 Serializable。使 String 可以串行化，可以在网络传输，实现了接口 Comparable，使 String 对象可以比较大小
(2)String 是 final 类，不能被其它的类继承
(3)String 有属性 private final char value[]，用于存放字符串内容
(4)一定要注意：value 是一个 final 类型，不能指向新的地址，即地址不可修改，但是单个字符内容(即value[0]…)是可以修改
(5)String 对象用于保存字符串，也就是一组字符序列
(6)字符串的字符使用 Unicode 字符编码，一个字符(不区分字母还是汉字)占两个字节
(7)字符串常量对象是用双引号括起的字符序列
(8) String 类常用的构造器：
```
String s1 = new String() 
String s2 = new String(String original) 
String s3 = new String(char[] a) 
String s4 = new String(char[],int startIndex, int count) 
String s5 = new String(byte[] b)
```
两种创建 String 对象的区别：
(1)直接赋值：String s = “123”
先从常量池查看是否有"123"数据空间，如果有，直接指向；如果没有则重新创建，然后指向。s最终指向的是常量池的空间地址
(2)调用构造器：String s2 = new String(“123”)
先在堆中创建空间，里面维护了value属性，指向常量池的123空间，如果常量池没有"123"，重新创建，如果有，直接通过value指向，最终指向的是堆中的空间地址

练习：

public class StringExercise1 {
    public static void main(String[] args) {
        String a = "abc";
        String b = "abc";
        System.out.println(a.equals(b));//T
        System.out.println(a == b);//T

        String c = new String("abc");
        String d = new String("abc");
        System.out.println(c.equals(d));//T
        System.out.println(c == d);//F

        String e = "abc";
        String f = new String("abc");
        System.out.println(e.equals(f));//T
        System.out.println(e == f);//F
        System.out.println(e == f.intern());//T
        System.out.println(f == f.intern());//F
        //如果池包含，inter方法返回来自池的字符串，否则返回对此String对象的引用
        //即以上f.inter()返回的是常量池的地址

        Person p1 = new Person();
        p1.name = "abc";
        Person p2 = new Person();
        p2.name = "abc";
        System.out.println(p1.name.equals(p2.name));//T
        System.out.println(p1.name == p2.name);//T
        System.out.println(p1.name == "abc");//T
    }
}

class Person{
    String name;
}

public class StringExercise2 {
    String str = new String("jack");
    final char[] ch = {'j','a','v','a'};
    public void change(String str,char ch[]){
        str = "java";
        ch[0] = 'h';
    }

    public static void main(String[] args) {
        StringExercise2 ex = new StringExercise2();
        ex.change(ex.str,ex.ch);
        System.out.print(ex.str + " and ");
        System.out.println(ex.ch);
    }
}

//输出 jack and hava

//创建了几个对象？

String s = "hello";
s = "haha";//创建了2个对象

String a = "hello" + "abc";//创建了1个

String a = "hello";
String b = "abc";
String c = a + b;//创建了3个

String类常用方法

名称	功能
equals	区分大小写，判断内容是否相等
equalsIgnoreCase	忽略大小写的判断内容是否相等
length	获取字符的个数，字符串的长度
indexOf	获取字符在字符串中第一次出现的索引，索引从0开始，如果找不到。返回-1
lastIndexOf	获取字符在字符串中最后1次出现的索引，索引从0开始，如找不到，返回-1
substring	截取指定范围的子串
trim	去前后空格
charAt	获取某索引处的字符，注意不能使用Str[index]这种方式
toUpperCase	转成大写
toLowerCase	转成小写
concat	拼接
replace	替换字符串中的字符
split	分割字符串,对于某些分割字符，我们需要转义比如\| \\等
compareTo	比较两个字符串的大小，前者-后者
toCharArray	转换成字符数组
format	格式字符串，%s，%d，%c，%f

StringBuffer 类：
(1) java.lang.StringBuffer 代表可变的字符序列，可以对字符串内容进行删改
(2)很多方法与 String 相同，但 StringBuffer 是可变长度的
(3) StringBuffer 是一个容器
注：
(1) StringBuffer 的直接父类是 AbstractStringBuilder
(2) StringBuffer 实现了 Serializable，即 StringBuffer 的对象可以串行化
(3)在父类中 AbstracStringBuilder 有属性 char[] value，不是 final，该 value 数组存放字符串内容
(4) StringBuffer 是一个 final 类，不能被继承
String VS StringBuffer：
(1) String 保存的是字符串常量，里面的值不能更改，每次 String 类的更新实际上就是更改地址，效率较低
(2) StringBuffer 保存的是字符串变量，里面的值可以更改，每次 StringBuffer 的更新实际上可以更新内容，不用每次更新地址，效率较高**(注：放在堆)**

StringBuffer构造器的使用

public class StringBuffer1 {
    public static void main(String[] args) {
        //1.创建一个大小为16的char[]，用于存放字符内容
        StringBuffer stringBuffer1 = new StringBuffer();
        //2.指定char[]大小
        StringBuffer stringBuffer2 = new StringBuffer(100);
        //3.直接放一个字符串
        StringBuffer stringBuffer3 = new StringBuffer("abc");
    }
}

String与StringBuffer转换

public class StringBuffer2 {
    public static void main(String[] args) {
        //String -> StringBuffer
        String str = "hello tom";
        //方式1：返回的才是StringBuffer对象，对str没影响，str还是String类型
        StringBuffer stringBuffer = new StringBuffer(str);
        //方式2：使用append方法
        StringBuffer stringBuffer1 = new StringBuffer();
        stringBuffer1 = stringBuffer1.append(str);
        
        //StringBuffer -> String 
        StringBuffer stringBuffer2 = new StringBuffer("abc");
        //方式1：使用StringBuffer提供的toString方法
        String s = stringBuffer2.toString();
        //方式2
        String s1 = new String(stringBuffer2);
    }
}

StringBuffer类常见方法

名称功能
append 增
delete(start,end) 删
replace(start,end,string) 改
indexOf 查
insert 插
length 获取长度
StringBuilder类:
(1)一个可变的字符序列，此类提供一个与 StringBuffer 兼容的API，但不保证同步(StringBuilder不是线程安全)，该类被设计用作StringBuffer 的一个简易替换，用在字符串缓冲区被单个线程使用的时候，如果可能(在单线程)，建议优先采用该类，因为在大多数实现中，它比 StringBuffer 要快
(2)在StringBuilder上的主要操作是 append 和 insert 方法，可重载这些方法，以接受任意类型的数据
(3)StringBuilder 和 StringBuffer 的常用方法是一样的
String VS StringBuffer VS StringBuilder：
(1)StringBuilder 和 StringBuffer 非常类似，均可代表可变的字符序列，而且方法也一样
(2)String：不可变字符序列，效率低，但是复用率高
(3)StringBuffer：可变字符序列、效率较高、线程安全
(4)StringBuilder：可变字符序列、效率最高、线程不安全
(5)String使用注意事项：
String s = “a”;//创建了一个字符串
s += “b”;//实际上就是原来的a字符串对象已经丢弃了，又产生了一个字符串ab，如果多次执行这些改变串内容的操作，会导致大量副本字符串对象存留在内存中，降低效率，如果这样的操作放到循环中，会极大影响程序的性能，所以，如果我们需要对 String 做大量修改，不要使用 String
String、StringBuffer、StringBuilder的选择：
(1)如果字符串存在大量的修改操作，一般使用StringBuffer或Stringbuilder
(2)如果字符串存在大量的修改操作，并在单线程的情况，使用StringBuilder
(3)如果字符串存在大量的修改操作，并在多线程的情况，使用StringBuffer
(4)如果我们字符串很少修改，被多个对象引用，使用String，比如配置信息等

名称	功能
append	增
delete(start,end)	删
replace(start,end,string)	改
indexOf	查
insert	插
length	获取长度

Math类

Math类常用方法

名称	功能
abs	绝对值
pow	求幂
ceil	向上取整，返回double类型
floor	向下取整，返回double类型
round	四舍五入，返回int类型
sqrt	求开方
random	求随机数
max	求两个数的最大值
min	求两个数的最小值

举例：返回2-7之间的数

public class Random {
    public static void main(String[] args) {
        //random返回的是0<= x < 1之间的一个随机小数
        for (int i = 0; i < 10; i++) {
            System.out.println((int) (2 + Math.random() * (7 - 2 + 1)));
        }
    }
}

Arrays类

Arrays类常见方法

名称	功能
toString	返回数组的字符串形式
sort	排序(自然排序和定制排序)
binarySearch	二分搜索法进行查找，前提是数组有序，如果数组中不存在该元素，返回-(low+1)
copyOf	数组元素复制
fill	数组元素的填充
equals	比较两个数组元素内容是否完全一致
asList	将一组值，转换成list

System类

System类方法

名称	功能
exit	退出当前程序
arraycopy	复制数组元素，比较适合底层调用，一般使用 Arrays.copyOf 完成复制数组
currentTimeMillis	返回当前时间距离1970-1-1的毫秒数
gc	运行垃圾回收机制

大数处理

大数处理方案：
(1)BigInteger适合保存比较大的整型
(2)BigDecimal适合保存精度更高的浮点数
BigInteger、BigDecimal

可以使用静态的 valueOf 方法可以将普通的数值转换为大数
```
BigInteger a = BigInteger.valueOf(100);
```
还有一些常量：BigInteger.ZERO、BigInteger.ONE、BigInteger.TEN、Java9之后增加了 BigInteger.TWO

注意，不能使用算数运算符来处理大数，而是需要使用 add 和 multiply 方法
```
BigInteger c = a.add(b);//c = a + b
BigInteger d = c.multiply(b.add(BigInteger.valueOf(2)));//d = c * (b + 2)
```

日期类

第一代日期类，Date类：
(1)Date：精确到毫秒，代表特定的瞬间
(2)SimpleDateFormat：格式和解析日期的类 SimpleDateFormat 格式化和解析日期的具体类，它允许进行格式化(日期 -> 文本)、解析(文本 -> 日期)和规范化
第二代日期类，Calendar类：
Calendar 类是一个抽象类，并且构造器是 private，可以通过 getInstance() 获取实例，它为特定瞬间与一组诸如YEAR、MONTH、DAY_OF_MONTH、HOUR等日历字段之间的转换提供了一些方法，并为操作日历字段(例如获得下星期的日期)提供了一些方法
第三代日期类常见方法：
(1)LocalDate(年月日)、LocalTime(时分秒)、LocalDateTime
(2)DateTimeFormatter 格式日期类
(3)Instant 时间戳

【Java基础学习笔记】常用类

目录

常用类

包装类

String类

Math类

Arrays类

System类

大数处理

日期类