韩顺平零基础30天学会Java【章11 常用类】

P460～P498

包装类


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

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

jdk5前手动装箱和拆箱，装箱：基本类型→包装类型，反之拆箱
jdk5以后，自动装箱和拆箱
自动装箱底层调用的是valueOf方法，比如Integer.valueOf()

int n1=10;
//手动装箱
Integer integer = new Integer(n1);
Integer integer1 = Integer.valueOf(n1);
//手动拆箱
int i = integer.intValue();

int n2=20;
//自动装箱
Integer integer2 = n2;//底层使用的是Integer.valueOf
//自动拆箱
int n3 = integer2;

包装类转String

Integer i =100;
//方法1
String str1 = i+"";
//方法2
String str2 = i.toString();
//方法3
String str3 = String.valueOf(i);

String转包装类

String str = "12345";
Integer i2 = Interger.paseInt(str);//自动装箱
Integer i3 = new Integer(str);//构造器

Integer类和Character类常用方法

Integer.MIN_VALUE;//-2147483648
Integer.MAX_VALUE;//2147483647

Character.isDigit('a');//是否为数字
Character.isLetter('a');//是否为字母
Character.isUpperCase('a');//是否大写
Character.isLowerCase('a');//是否小写

Character.isWhitespace('a');
Character.toUpperCase('a');
Character.toLowerCase('A');

Integer创建机制，WrapperExercise01.java

Integer i =new Integer(1);
Integer j =new Integer(1);
System.out.println(i==j);//false，两个new出来的对象，所以不是

Integer m =1;//底层 Integer.valueOf(1)
Integer n =1;//底层 Integer.valueOf(1)
System.out.println(m==n);//true，

Integer x = 128;
Integer y = 128;
System.out.println(x==y);//false

low：-128，high：127

    public static Integer valueOf(int i) {
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }

String类，String01.java

public class String01 {
    public static void main(String[] args) {
        String name = "jack";
        final char value[] = {'a','b','c'};
        System.out.println(value[2]); //c
        value[2]='h'; //可以改final修饰的数组中的元素 
        System.out.println(value[2]); //h
        
        final char v2[] = {'a','b','c'};
//        value =v2; //final不能改变value地址
        String a = "hello";
        String b ="abc";
        String c = a+b;
    }
}

String对象用于保存字符串，也就是一组字符序列
字符串常量对象是用双引号括起来的字符序列
字符串的字符使用Unicode字符编码，一个字符占两个字节
String类有很多构造器，较常用构造方法
1. String s1 = new String();
2. String s2 = new String(String original);
3. String s3 = new String(char[] a);
4. String s4 = new String(char[] a, int startIndex, int count);
5. String s5 = new String(byte[] a);
The value is used for character storage.
字符串的本质仍然是个char[]数组，private final char value[];
value[]一旦赋值就不能修改，地址不能修改，但是单个字符的内容是可以变化的

public final class String implements java.io.Serializable,
 Comparable<String>, CharSequence

Serializable：串行化，可以在网络上传输
Comparable：该对象可以相互比较大小
final：不能被其他类继承

String对象的创建方式

直接赋值：String s1 = “abc”;
1. 先从常量池中查看是否有"abc"数据空间，如果有，则直接指向
2. 如果没有则重新创建，然后指向
3. s1最终指向的是常量池的空间地址
调用构造器：String s2 = new String(“abc”);
1. 先在堆中创建空间，里面维护了value属性，指向常量池中abc
2. 如果常量池没有abc，重新创建，如果有，直接通过value指向
3. s2最终指向的是堆中的空间地址

字符串的特点

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

String a =“hello”+"abc"创建了几个对象？1个

优化等价于 String a = “helloabc”

String类常见方法

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

equals，区分大小写，判断内容是否相等
equalsIgnoreCase，忽略大小写的判断内容是否相等
length，获取字符的个数，字符串的长度
indexOf，获取字符在字符串中第1次出现的索引，索引从0开始，找不到返回-1
lastIndexOf，获取字符在字符串中最后1次出现的索引，索引从0开始，找不到返回-1
substring，截取指定范围的子串
- substring(6)，从索引6开始截取后面所有的内容
- substring(0,5)，从索引0开始，截取到索引(5-1)位置
trim，去前后空格
charAt，获取某索引处的字符，注意不能使用Str[index]这种方式
toUpperCase
toLowerCase
concat，拼接字符串
replace
split
compareTo，实现Comparable接口中的方法
- 两个字符串长度相同，内容相同，返回0
- 长度相同或不相同，在比较时当出现不相同，可以区分大小，返回ch1-ch2
- 两个字符串长度不同，如果前面的部分都相同，返回str1.len-str2.len
toCharArray
format

占位符：%s字符串，%d整数，%.2f四舍五入保留两位小数，%c字符

String name = "gl";
int age = 20;
double score = 98.5/3;
char gender = '男';
String info = "名字:"+name+" 年龄:"+age+" 分数:"+score+" 性别:"+gender;
String info2 = String.format("名字:%s 年龄:%d 分数:%.2f 性别:%c",name,age,score,gender);
System.out.println(info);
System.out.println(info2);

StringBuffer类,StringBuffer01.java

public class StringBuffer01 {
    public static void main(String[] args) {
//        public final class StringBuffer
//                extends AbstractStringBuilder
//                implements java.io.Serializable, CharSequence
//        1.StringBuffer的直接父类是AbstractStringBuilder
//        2.StringBuffer实现了Serializable，可以串行化
//        3.在父类AbstractStringBuilder中有属性 char[] value，不是final
//        该value数组存放字符串内容，因此是存放在堆中
//        4.StringBuffer是一个final类，不能继承
        StringBuffer stringBuffer = new StringBuffer();
    }
}

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

String vs StringBuffer

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

StringBuffer构造器

StringBuffer()，构造不带字符的字符串缓冲区，初始容量16字符
StringBuffer(CharSequence seq)，包含与指定seq相同字符
StringBuffer(int capacity)，不带字符，但具有指定容量的字符串缓冲区
StringBuffer(String str)，初始化为指定字符串内容

String和StringBuffer相互转换，StringAndStringBuffer.java

public class StringAndStringBuffer {
    public static void main(String[] args) {
//        String->StringBuffer
        String s = "hello";
        StringBuffer b1 = new StringBuffer(s);
        StringBuffer b2 = new StringBuffer();
        b2.append(s);
        System.out.println(b1);
        System.out.println(b2);
//        StringBuffer->String
        String s1 = b1.toString();
        String s2 = new String(b1);
    }
}

StringBuffer类常用方法

append，增
delete，删
replace(start,end,string)，改，将start～end之间的内容替换掉，不含end
indexOf，返回子串在字符串第一次出现的索引
insert，插入
length

练习，StringBufferExercise.java

输入商品名称和商品价格，要求打印效果示例，使用前面学习的方法完成

要求：价格的小数点前面每三位用逗号隔开

商品名商品价格

手机 123,564.59

import java.util.Scanner;
public class StringBufferExercise {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String name=scanner.next();
        String price=scanner.next();

        StringBuffer pricestr = new StringBuffer(price);
        int point=pricestr.indexOf(".")-3;
        int temp=0;
        while(point>0){
            pricestr.insert(point,",");
            point-=3;
        }
        System.out.println("商品名\t商品价格");
        System.out.println(name+"\t\t"+pricestr);
    }
}

StringBuilder类

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

public final class StringBuilder
    extends AbstractStringBuilder
    implements java.io.Serializable, CharSequence
//Serializable，StringBuilder可串行化
//final，不能被继承
//对象字符序列存放在父类char[] value;中，因此字符序列在堆中
//方法没有做互斥处理，即没有synchronized关键字，在单线程下使用

String vs StringBuffer vs StringBuild

StringBuilder和StringBuffer非常类似，均代表可变的字符序列，而且方法也一样
String：不可变字符序列，效率低，但复用率高
StringBuffer：可变字符序列，效率较高（增删），线程安全
StringBuilder：可变字符序列，效率最高，线程不安全
String注意事项：如果要对String做大量的修改，不要用String

String s = "a"; //创建了一个字符串
s += "b";
//实际上原来的"a"字符串对象已经丢弃了，又产生一个字符串s+"b"，也就是"ab"
//如果多次执行这些改变串内容的操作，会导致大量副本字符串对象留在内存中，降低效率
//如果这样的操作放在循环中，会极大影响程序的性能

Math类

常用方法：

abs：绝对值
pow：求幂
ceil：向上取整
floor：向下取整
round：四舍五入
sqrt：开方
random：求随机数
max
min

Arrays类

常用方法

toString，返回数组的字符串形式，Arrays.toString(arr)
sort排序，
binarySearch，通过二分法进行查找，必须排好序
copyOf，数组元素复制
fill，数组元素填充
equals，比较两个数组元素是否完全一致
asList，将一组值转换为list

System类

常用方法

exit，退出当前程序
arraycopy：复制数组元素，适合底层调用，一般用Arrays.copyOf
currentTimeMillens，返回当前时间距离1970-1-1的毫秒数
gc：运行垃圾回收机制

BigInteger和BigDecimal类

应用场景：

BigInteger适合保存比较大的整型
BigDecimal适合保存精度更高的浮点型
在进行加减乘除时，需要使用对应的方法，不能直接加减乘除

日期类

第一代日期类，Date01.java

Date：精确到毫秒，代表特定的瞬间
SimpleDateFormat：格式和解析日期的类

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class Date01 {
    public static void main(String[] args) throws ParseException {
        Date date1 = new Date();
        Date date2 = new Date(9234567);
        System.out.println(date1.getTime());

        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 hh:mm:ss E" );
        String format = sdf.format(date1);
        System.out.println(format);
        //String转对应的Date
        String s ="1996年01月01日 10:20:30 星期一";
        Date parse = sdf.parse(s);
        System.out.println(parse); //Mon Jan 01 10:20:30 CST 1996
        System.out.println(sdf.format(parse)); //1996年01月01日 10:20:30 周一
    }
}

第二代日期类，Calendar01.java

Calendar类

public abstract class Calendar implements Serializable, Cloneable, Comparable {

import java.util.Calendar;

public class Calendar01 {
    public static void main(String[] args) {
        Calendar c = Calendar.getInstance();//创建日历类对象
        System.out.println(c);
        //获取日历对象的某个日历字段
        System.out.println("年"+c.get(Calendar.YEAR));
        System.out.println("月"+c.get(Calendar.MONTH)+1);
        System.out.println("日"+c.get(Calendar.DAY_OF_MONTH));
        System.out.println("小时"+c.get(Calendar.HOUR));
        System.out.println("分钟"+c.get(Calendar.MINUTE));
        System.out.println("秒"+c.get(Calendar.SECOND));
    }
}

第三代日期类，LocalDateTime01.java

LocalDate：日期，年月日

LocalTime：时间，时分秒

LocalDateTime：日期+时间

import java.time.LocalDateTime;

public class LocalDateTime01 {
    public static void main(String[] args) {
        LocalDateTime now = LocalDateTime.now();
        System.out.println(now);
        System.out.println(now.getMonth()); //AUGUST
        System.out.println(now.getMonthValue()); //8
    }
}

DateTimeFormatter格式日期类

DateTimeFormat dtf = DateTimeFormatter.ofPattern(格式)

String str = dtf.format(日期对象);