Java常用类（String、StringBuffer、StringBuilder、日期、随机数、枚举）

五. 常用类

java.lang.String类

1. java中双引号括起来的字符串不可变
2. 双引号括起来的字符串都是直接存储在方法区的“字符串常量池”中的（字符串在实际开发中使用频繁，为了提高执行效率）

public class Test01 {
    public static void main(String[] args) {
        //下面两行代码表示在字符串常量池中创建了3个字符串对象
        String s1 = "abc";
        //使用字符串常量池中已有的"abc"，创建"xy"，合并后创建"abcxy"
        String s2 = "abc" + "xy";

        //栈main方法->堆String对象->方法区字符串常量池"xy"
        String s3 = new String("xy");

		//以下两行代码共创建了三个对象：字符创常量池中的"heisenberg"对象、堆内存中两个对象
        String s4 = "heisenberg";
        String s5 = "heisenberg";		//"heisenberg"已经存在
        System.out.println(s4 == s5);       //true，两变量保存内存地址相同
        
        String s6 = new String("heisenberg");		//s6、s7指向对象不同
        String s7 = new String("heisenberg");		//两对象保存地址相同
        System.out.println(s6 == s7);       //false
        System.out.println(s6.equals(s7));      //true
    }
}

• 常用构造方法

//String(byte[] bytes)方法：将数组中元素转换为ASCII码对应字符
byte[] bytes = {97,98,99};		//97：a、98：b、99：c
String s = new String(bytes);
System.out.println(s);		//输出abc

//String(byet[] byets,int offset,int length)方法：(字节数组，起始下标，长度)
//将byte数组中的一部分转换成字符串
String s2 = new String(bytes,1,2);
System.out.println(s2);		//输出bc

//String(char[] value)方法：将char数组全部转换成字符串
char[] value = {'E','l','s','o','n'};
String s3 = new String(value);
System.out.println(s3);		//输出Elson

//String(char[] value,int offset,int count)方法：(字符数组，起始下标，长度)
String s4 = new String(value,2,3);
System.out.println(s4);		//输出son

• 方法

1. char charAt(int index)方法（掌握）

char c = "中国人".charAt(1);		//"中国人"是一个String对象
System.out.println(c);		//输出下标为1的元素'国'

2. int compareTo(String anotherString)方法（了解）

   用前面字符串的元素和后面字符串元素（ASC码）依次比较，直到分出大小

int result1 = "abc".compareTo("abc");
System.out.println(result1);        //等于0，前后相同
int result2 = "abc".compareTo("abd");
System.out.println(result2);        //-1（小于0），前小后大
int result3 = "abc".compareTo("abb");
System.out.println(result3);        //1（大于0），前大后小

3. boolean contains(CharSequence s)方法（掌握）

   判断前面字符串中是否包含后面字符串，String的父接口就是：CharSequence

System.out.println("heisenberg".contains("berg"));		//true
System.out.println("http://".contains("https"));		//false

4. boolean endsWith(String suffix)方法（掌握）

   判断当前字符串是否以某字符串结尾

System.out.println("hello.java".endsWith(".java"));		//true
System.out.println("hello.java".endsWith(".txt"));		//false

5. boolean equals(Object anObject)方法（掌握）

   比较两个字符串是否相等

6. boolean equalsIgnoreCase(String anotherString)方法（掌握）

   判断两字符串是否相等，忽略大小写

System.out.println("ABc".equalsIgnoreCase("abC"));		//true

7. byte[] getBytes()方法（掌握）

   将字符串对象转换成字节数组

byte[] bytes = "abcd".getBytes();
for (int i = 0; i < bytes.length; i++) {
	System.out.println(bytes[i]);		//输出97 98 99 100
}

8. int indexOf(String str)方法（掌握）

   获得某个子字符串在当前字符串中第一次出现处的索引（下标）

System.out.println("oraclejavaSQLjavaSQL".indexOf("java"));		//6

9. boolean isEmpty()方法（掌握）

   判断某个字符串是否为空字符串

String s = "";
System.out.println(s.isEmpty());		//true
s = "heisenberg";
System.out.println(s.isEmpty());		//false
s = null;		//空指针异常

10. int length()方法（掌握）

    判断数组长度是length属性，判断字符串长度是length()方法

System.out.println("heisenberg".length());		//输出10

11. int lastIndexOf(String str)方法（掌握）

    获得某个子字符串在当前字符串中最后一次出现处的索引（下标）

System.out.println("oraclejavaSQLjavaSQL".lastIndexOf("java"));		//13

12. String replace(CharSequence target, CharSequence replacement)方法（掌握）

    替换

String news = "http://realheisenberg.github.io".replace("p:","ps:");
System.out.println(news);		//输出https://realheisenberg.github.io
String str1 = "haisanbarg".replace("a","e");
System.out.println(str1);		//输出heisenberg

13. String[] split(String regex)方法（掌握）

    拆分字符串

String[] ymd = "1998-01-22".split("-");		//以"-"为分隔符进行拆分
for (int i = 0; i < ymd.length; i++) {
	System.out.print(ymd[i]);		//输出19980122
}

14. boolean startsWith(String prefix)方法（掌握）

    判断某个字符串是否以某子字符串开始

System.out.println("realheisenberg".startsWith("real"));		//true

15. String substring(int beginIndex)方法（掌握）

16. String substring(int beginIndex, int endIndex)方法（掌握）

    截取字符串（包括起始索引，不包括结束索引，左闭右开）

System.out.println("realheisenberg".substring(4));		//heisenberg
System.out.println("realheisenberg".substring(4,10));		//heisen

17. char[] toCharArray()方法（掌握）

    将字符串转换成char数组

char[] chars = "我是中国人".toCharArray();
for (int i = 0; i < chars.length; i++) {
	System.out.println(chars[i]);
}

18. String toLowerCase()方法（掌握）

19. String toUpperCase()方法（掌握）

    转换为小/大写

System.out.println("HEIsenBERG".toLowerCase());		//输出heisenberg
System.out.println("HEIsenBERG".toUpperCase());		//输出HEISENBERG

20. String trim()方法（掌握）

    去除字符串前后空白（中间的不去）

System.out.println("   hello  world   ".trim());		//输出hello  world

21. String.valueOf()方法（掌握）

    静态方法，将非字符串数据转换为字符串数据

String s1 = String.valueOf(true);		//将布尔类型转换为字符串
String s2 = String.valueOf(3.14);		//将double类型转换为String类型

//class User{}
class User{
	public String toString() {
		return "hello";
	}
}
String s3 = String.valueOf(new User());		//调用对象toString()方法
//重写User的toString()方法前输出内存地址
System.out.println(s3);		//重写后输出hello

• System.out.println()方法输出引用执行原理：调用String.valueOf()方法 -> toString()方法。所以输出的任何内容都是字符串形式

StringBuffer：字符串缓冲区

• 使用“+”拼接创建新字符串会浪费方法区内存

• StringBuffer()构造方法创建一个容量为16byte[] 数组（字符串缓冲对象）

• append()方法：拼接字符串

StringBuffer s = new StringBuffer();
s.append("abc");
s.append('d');
s.append(123);
s.append(3.14);
System.out.println(s);		//输出abcd1233.14

• StringBuffer性能优化：创建时尽可能给定一个初始化容量（大一些），减少底层扩容次数

  StringBuffer(int capacity)方法

StringBuffer sb = newStringBuffer(10);		//指定初始化容量
sb.append("real");
sb.append("heisenberg");
System.out.println(sb);		//realheisenberg

• StringBuilder

• StringBuilder和StringBuffer的区别：

  StringBuffer中的方法都有synchronized关键字修饰，在多线程环境下是安全的

  StringBuilder中的方法都没有synchronized关键字修饰，是非线程安全的

StringBuilder sb = new StringBuilder();
sb.append("real");		//与StringBuffer用法相同
sb.append("heisenberg");

• String为什么不可变：

  String类中有一个final修饰的byte[]数组，因为数组创建后长度不可变，且被final修饰的引用指向某对象后无法再指向其他对象

• StringBuffer/StringBuilder为什么可变：

  StringBuffer/StringBuilder内部实际上是一个byte[]数组，这个数组没有被final修饰，初始容量为16，存满后调用数组拷贝方法System.arrayCopy()进行扩容

包装类

• java中为8种基本数据类型对应准备了8种包装类型，包装类型属于引用数据类型，父类是Object

public class IntegerTest01 {
    public static void main(String[] args) {
        MyInt mi = new MyInt(20);
        doSome(mi);
    }

    public static void doSome(Object obj){		//无法传递基本数据类型
        System.out.println(obj);
    }
}

public class MyInt {		//实际开发中不需要自己写
    int i;
    public MyInt(int i) {
        this.i = i;
    }
    public String toString() {
        return String.valueOf(i);
    }
}

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

• Number是一个抽象类，无法实例化对象

  byte byteValue()方法：以byte形式返回指定数值
  abstract double doubleValue()方法：以double形式返回指定数值
  abstract float floatValue()方法：以float形式返回指定数值
  abstract int intValue()方法：以int形式返回指定数值
  abstract long longValue()方法：以long形式返回指定数值
  short shortValue()方法：以short形式返回指定数值

public class IntegerTest02 {
    public static void main(String[] args) {
        Integer i = new Integer(20);		//基本数据类型转换为引用数据类型（装箱）
        float f = i.floatValue();		//引用数据类型转换为基本数据类型（拆箱）
        System.out.println(f);		//输出20.0
    }
}

• Integer类的构造方法：Integer(int)、Integer(String)

Integer x = new Integer(100);		//将100转换为Integer包装类（int -> Integer）
Integer y = new Integer("123");		//String -> Integer
Double d1 = new Double(3.14);		//其他类型同理
Double d2 = new Double("1.41");

Integer x = new Integer("字符串");		//编译通过
System.out.println(x);		//运行报错：NumberFormatException，数字格式化异常

• Integer类的属性：MAX_VALUE（int型数据最大值）、MIN_VALUE（int型数据最小值）

System.out.println("int类型数据最大值：" + Integer.MAX_VALUE);		//2147483647
System.out.println("int类型数据最小值：" + Integer.MIN_VALUE);		//-2147483648
System.out.println("byte类型数据最大值：" + Byte.MAX_VALUE);		//127
System.out.println("byte类型数据最小值:" + Byte.MIN_VALUE);		//-128

• JDK1.5之后支持自动装箱和自动拆箱

Integer x = 100;		//自动装箱：int类型自动转换为Integer
int y = x;		//自动拆箱：Integer自动转换为int
System.out.println(x + 1);		//输出101，"+"两边要求是基本数据类型数字，自动拆箱

//"=="不涉及自动拆箱，只有加减乘除会
//java中将[-128,127]的所有包装对象提前创建好，放在方法区的”整数型常量池“中，使用时不需要new
//Integer类加载时会初始化整数型常量池256个对象
Integer a = 127;
Integer b = 127;
System.out.println(a == b);        //输出true，a和b中保存的内存地址相同

Integer a = 128;
Integer b = 128;
System.out.println(a == b);        //输出false，创建了两个Integer对象

• xx池：cache，是缓存机制，效率高

• Integer类的方法：

1. static int parseInt(String s)方法（重点）

   静态方法，将String类型参数转换为int类型（将网页上输入的字符串内容转换为int类型存储在数据库中）

int i = Integer.parseInt("123");
System.out.println(i + 100);		//123 + 100 = 223

int j = Integer.parseInt("abc");		//数字格式化异常

double d = Double.parseDouble("3.14");
System.out.println(d + 1);		//4.140000000000001（精度问题）

2. static String toBinaryString(int i)方法：转换为二进制（了解）
   static String toOctalString(int i)方法：转换为八进制
   static String toHexString(int i)方法：转换为十六进制

String s1 = Integer.toBinaryString(3);		//11
String s2 = Integer.toOctalString(9);		//11
String s3 = Integer.toHexString(16);		//10

3. static Integer valueOf(int i)方法：静态，int类型转换为Integer（了解）
   static Integer valueOf(String s)方法：String类型转换为Integer

Integer i1 = Integer.valueOf(20);
Integer i2 = Integer.valueOf("80");

• Object类中的toString()方法：调用toHexString()方法

public String toString() {
	return getClass().getName() + "@" + Integer.toHexString(hashCode());
}

• String int Integer之间相互转换

//String --> int
int i = Integer.valueOf(20);
System.out.println(i + 1);		//21

//int --> String
String s = String.valueOf(50);
System.out.println(s + 1);      //501
String s0 = 50 + "";

//int --> Integer
Integer x = 100;        //自动装箱

//Integer --> int
int y = x;      //自动拆箱

//String --> Integer
Integer ii = Integer.valueOf("128");

//Integer --> String
String ss = String.valueOf(ii);

java中对日期的处理

• java.util.Date类的无参构造方法可以获得当前时间

import java.util.Date;		//需要import

public class DateTest01 {
    public static void main(String[] args) {
        Date now = new Date();
        System.out.println(now);		//Fri Dec 11 20:20:06 CST 2020
    }
}

• java.text.SimpleDateFormat类可以格式化日期

• SimpleDateFormat(String pattern)构造方法：

  yyyy：年（4位） MM：月（2位） dd：日

  HH：时 mm：分 ss：秒 SSS：毫秒（3位）

  （日期格式中，除了y M d H m s S字符外可以随意设置字符）

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

public class DateTest01 {
    public static void main(String[] args) {
        Date now = new Date();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");
        /*也可以写成("yyyy年MM月dd日 HH时mm分ss秒 SSS毫秒")、
        ("dd/MM/yyyy")... */
        String nows = sdf.format(now);		//调用format(date)方法，转换为String
        System.out.println(nows);		//2020-12-11 21:22:11 080
    }
}

• 日期字符串转换为Date类型：

public static void main(String[] args) throws ParseException {
	String time = "2020-12-11 21:46:30 256";
	//SimpleDateFormat格式必须和字符串相同，否则报错：ParseException
	SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");
	Date dateTime = sdf1.parse(time);
	System.out.println(dateTime);		//Fri Dec 11 21:46:30 CST 2020
}

• System.currentTimeMillis()方法：获取自1970年1月1日00:00:00 000到当前时间的总毫秒数

long nowTimeMillis = System.currentTimeMillis();
System.out.println(nowTimeMillis);

long begin = System.currentTimeMillis();		//程序开始时间
for (int i = 0; i < 1000; i++) {
	System.out.println(i);
}
long end = System.currentTimeMillis();		//结束时间
System.out.println("耗时：" + (end - begin));		//耗时16毫秒

• 总结System类的相关属性和方法：

  System.out 【out是System类的静态变量】
  System.out.println() 【ptintln()方法属于PrintStream类】
  System.gc() 【建议启动垃圾回收器】
  System.currentTimeMillis() 【获取自1970.1.1到当前时间的毫秒数】
  System.exit(0) 【退出JVM】

• 构造方法Date(long date)

  传递一个毫秒数，得到一个Date类型数据（1970-1-1 0:0:0 + date）

Date time = new Date(1);
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");
String s1 = sdf.format(time);
System.out.println(s1);     //1970-01-01 08:00:00 001（东8区）
//获取昨天此时
Date time1 = new Date(System.currentTimeMillis() - 24*60*60*1000);
String s2 = sdf.format(time1);
System.out.println(s2);     //2020-12-11 14:04:00 064

• java.text.DecimalFormat类可以格式化数字

  #代表数字 ,代表千分位 .代表小数点 0表示不够时补0

DecimalFormat df = new DecimalFormat("###,###.##");	//加入千分位，保留两位小数
String s = df.format(1234.56);
System.out.println(s);		//1,234.56
String s0 = df.format(1234.567);
System.out.println(s0);		//1,234.57

DecimalFormat df1 = new DecimalFormat("###,###.0000");	//保留四位小数，不够补0
String ss = df1.format(1234.56);
System.out.println(ss);		//1,234.5600

• java.math.BigDecimal类

  BigDecimal属于大数据，不属于基本数据类型，是SUN提供的一个类，用在财务软件中。精度比double高

import java.math.BigDecimal;		//导包

public class BigDecimal01 {
    public static void main(String[] args) {
        BigDecimal x1 = new BigDecimal(100);
        BigDecimal x2 = new BigDecimal(200);
        BigDecimal x3 = x1.add(x2);		//引用数据类型，不能直接x1 + x2
        System.out.println(x3);		//输出300，toString()方法已重写
        BigDecimal x4 = x2.divide(x1);
        System.out.println(x4);		//2
    }
}

java.util.Random类

Random r = new Random();		//创建随机数对象
int x1 = r.nextInt();		//随机产生int类型取值范围内的数字
System.out.println(x1);

int x2 = r.nextInt(21);		//产生[0,20]之间的随机整数，不能产生21
System.out.println(x2);

• 产生五个不重复的[0,100]随机数，放在数组中

Random r = new Random();
int[] array = {-1,-1,-1,-1,-1};		//防止array[0]==0
array[0] = r.nextInt(101);		//
for (int i = 1; i < array.length; i++) {
	array[i] = r.nextInt(101);
	while (true) {
		for (int j = 0; j < i; j++) {
			if (array[i] == array[j]){
				array[i] = r.nextInt(101);
			}
		}break;
	}
}

枚举

• 枚举是一种引用数据类型，编译后生成class文件，枚举中每一个值可以看做常量
• 枚举类型语法：enum 枚举类型名{枚举值1, 枚举值2, …}
• 结果只有两种时建议使用布尔类型；结果超过两种且可以一一列举的，建议使用枚举类型

public class EnumTest01 {
    public static void main(String[] args) {
        Return r = divide(10,0);
        System.out.println(r == Return.SUCCESS? "计算成功": "计算失败");
    }

    public static Return divide(int a,int b){
        try{
            int c = a / b;
            return Return.SUCCESS;
        }catch(Exception e){		//异常
            return Return.FAIL;
        }
    }
}

public enum Return {
    SUCCESS, FAIL
}