Java 常用类

1. 字符串常用类

　　String类的构造函数：

　　　　String()；

　　　　String(byte[]);

　　　　String(byte[],offset,length);

　　　　String(char[],offset,length);

public class StringTest01{
    public static void main(String[] args){
        String s1 = "abc";
        String s2 = new String("abc");
        System.out.println(s1 + " " + s2);
        
        byte[] bytes = {97,98,99}; //97->a,98->b,99->100
        String s3 = new String(bytes);
        String s4 = new String(bytes,1,2);
        System.out.println(s3 + " " + s4);
        
        char[] chars = {'你','说','呢'};
        String s5 = new String(chars);
        String s6 = new String(chars,1,2);
        System.out.println(s5 + " " + s6);
        
    }
}

　　a. 字符串是不可变对象（public final class String），被final修饰，不能被继承；

　　b. 字符串保存在方法区中的“字符串常量池”中，因为字符串使用频繁，这样方便使用；

　　 String s2 = "abc";　　//在栈中保存了字符串s2的内存地址，在方法区字符串常量池中保存了abc，s2指向abc；

　　　String s3 = new String("abc"); //在栈中保存了字符串s3的内存地址指向堆，堆中创建了对象，保存内存地址指向字符串常量池，字符串保存在方法区的字符串常量池中；

　　字符串的常用方法：

public class StringTest02{
    public static void main(String[] args){
        //1. charAt()  返回字符串指定索引位置的字符
        char c = "abc".charAt(2);
        System.out.println(c);  //c
        
        //2. compareTo()  字符串首比较，相等返回0，前面大返回1，后面大返回-1
        System.out.println("abc".compareTo("abc"));  //0
        System.out.println("abc".compareTo("bdf"));  //-1
        System.out.println("bdf".compareTo("ace"));  //1  首字符比较出结果就可以
        
        //3. contains()  前面字符串是否包含后面字符串
        System.out.println("hello world".contains("world"));  //true
        System.out.println("hello world".contains("ord"));  //false
        
        //4. endsWith()  是否已指定字符串结尾
        System.out.println("helloworld.java".endsWith(".java"));  //true
        System.out.println("helloworld.java".endsWith(".text"));  //false
        System.out.println("helloworld.java".endsWith(".a"));  //false
        
        //5. equals() 判断字符串是否相等
        System.out.println("abc".equals("abc"));  //true
        
        //6. equalsIgnoreCase()  判断字符串是否相等忽略大小写
        System.out.println("abc".equalsIgnoreCase("AbC"));  //true
        
        //7. getBytes()  返回字符对应的ASCII码
        byte[] b1 = "abcdf".getBytes();
        for(int i=0; i<b1.length; i++){
            System.out.print(b1[i] + " ");    //97 98 99 100 102
        }
        
        //8. indexOf()  返回字符串初次出现位置的索引
        System.out.println("helloworld.javapythonjava".indexOf("java"));  //11
        
        //9. isEmpty()  判断字符串是否为空
        System.out.println("".isEmpty());  //true
        System.out.println("ABC".isEmpty());  //false
        
        //10. length()  获取字符串长度
        System.out.println("".length());  //0
        System.out.println("abc".length());  //3
        
        //11. lastIndexOf() 返回字符串最后一次出现位置的索引
        System.out.println("helloworld.javapythonjava".lastIndexOf("java"));  //21
        
        //12. replace() 字符串替换，返回新字符串
        String str1 = "helloworld".replace("world","java");  
        System.out.println(str1);
        
        //13 split() 字符串分割，返回字符串数组
        String[] str2 = "2021-11-08".split("-");
        for(int i=0; i< str2.length; i++){
            System.out.print(str2[i] + " ");
        }
        
        //14 startsWith() 判断字符串是否以指定字符串开始
        System.out.println("www.baidu.com".startsWith("www"));  //true
        System.out.println("www.baidu.com".startsWith("wwws"));  //false
        
        //15 substring() 字符串截取
        System.out.println("www.baidu.com".substring(4));  //baidu.com
        System.out.println("www.baidu.com".substring(4,9));  //baidu  左开右闭
        
        //16 toCharArray() 转换为字符数组
        char[] c1 = "牛气冲天".toCharArray();
        for(int i=0;i<c1.length;i++){
            System.out.print(c1[i] + " ");  //牛 气 冲 天
        }
        
        //17 toLowerCase()  toUpperCase()  字符串小写转换，字符串大写转换
        System.out.println("abcdABCDedf".toLowerCase());  //abcdabcdedf
        System.out.println("abcdABCDedf".toUpperCase());  //ABCDABCDEDF
        
        //18 trim()  去掉字符串前后空格
        System.out.println("  hello world ".trim());  //hello world
        
        //19 valueOf()  静态方法，类名调用，转换为字符串
        String str3 = String.valueOf(100);  //100
        System.out.print(str3);
    }
}

　　字符串拼接：

　　　　a. 使用“+”，使用加号拼接需要频繁创建对象，效率低；

　　　　b. 使用StringBuffer，默认创建一个16字节容量的数组，也可以指定容量大小；

　　　　c. 使用StringBuilder，和StringBuffer使用方法相同，区别：StringBuffer中的方法都是synchronized修饰，表示在多线程环境下可以安全使用，而StringBuilder的方法没有被synchronized修饰，表示在多线程场景下使用不安全；

public class StringTest03{
    public static void main(String[] args){
        String s1 = "abc" + "bac";
        System.out.println(s1);
        
        StringBuffer sb = new StringBuffer();  //默认创建一个容量是16的byte[]
        sb.append(100);
        sb.append(3.14);
        sb.append("adfda");
        sb.append(true);
        System.out.println(sb);
        
        StringBuffer sb1 = new StringBuffer(100);  //可以指定容量大小
        sb1.append(200);
        sb1.append(3.11);
        sb1.append("ad");
        System.out.println(sb1);
        
        StringBuilder sb2 = new StringBuilder();
        sb2.append("eeee");
        sb2.append(300);
        sb2.append(3.22);
        System.out.println(sb2);
    }
}

2. 包装类

　　包装类的常用方法

public class IntegerTest07 {
    public static void main(String[] args) {
        int x = Integer.parseInt("123");   //parseInt  静态方法
        System.out.println(x);

        float f = Float.parseFloat("2.1");  //parseFloat
        System.out.println(f+1);

        double d = Double.parseDouble("3.14");  //parseDouble
        System.out.println(d);

        String binaryString = Integer.toBinaryString(6);  //十进制转换为二进制字符串
        System.out.println(binaryString);   //"110"

        String hexString = Integer.toHexString(16);  //十进制转换为16进制字符串
        System.out.println(hexString);   //"10"

        String octalString = Integer.toOctalString(8);  //十进制转换为八进制字符串
        System.out.println(octalString); // "10"

        Integer integer = Integer.valueOf(100);
        System.out.println(integer);  //100

        Integer integer1 = Integer.valueOf("100");
        System.out.println(integer1);

    }
}

  Integer int String 之间的类型转换

public class IntegerTest08 {
    public static void main(String[] args) {
        //String -->int
        int i = Integer.parseInt("123");
        //int -->String
        String s = i + "";
        System.out.println(i + "    " +  s);

        //int --> Integer
        Integer integer = 100;
        //Integer --> int
        int y = integer;
        System.out.println(integer + "    " +  y);

        //String --> Integer
        Integer integer1 = Integer.valueOf("100");
        //Integer --> String
        String s1 = String.valueOf(integer1);
        System.out.println(integer1 + "    " +  s1);
    }
}

3. 日期类

　　String转换为Date，使用parse()

　　Date转换为String，使用format()

public class DateTest01 {
    public static void main(String[] args) throws Exception{
        Date nowtime = new Date();
        //System.out.println(nowtime);    //获取系统当前时间

        //Date转换为String
        SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS a E");
        String nowtimestr = sdf1.format(nowtime);
        System.out.println(nowtimestr);  //输出指定格式的日期

        //String转换为Date
        String nowtimestr1 = "2021-02-15 19:17:00 300";
        SimpleDateFormat sdf2 = new SimpleDateFormat("yy-MM-dd HH:mm:ss SSS");
        Date nowtime1 = sdf2.parse(nowtimestr1);
        System.out.println(nowtime1);
    }
}

  currentTimeMillis()方法可以计算方法的耗时
　示例1：

public class DateTest02 {
    public static void main(String[] args) {
        long currentTime = System.currentTimeMillis();   //获取从1970年开始到现在时间的毫秒数
        System.out.println(currentTime);
        long begin = System.currentTimeMillis();
        print();    //计算执行方法所需要的时间
        long end = System.currentTimeMillis();
        System.out.println("执行print()方法所需要的时间："+ (end - begin) + " 毫秒");
    }


    public static void print(){
        for (int i = 0; i < 1000; i++) {
            System.out.println("i == " + i);
        }
    }
}

　　示例2：

public class DateTest03 {
    public static void main(String[] args) {
        Date time = new Date(1);   //参数单位：毫秒 ， 添加参数表示从1970年开始经历毫秒后的时间
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");
        String timeStr = sdf.format(time);
        System.out.println(timeStr);   //1970-01-01 08:00:00 001  北京时差

        Date yesterday = new Date(System.currentTimeMillis() - 24*60*60*1000);
        String yesterdayStr = sdf.format(yesterday);
        System.out.println(yesterdayStr);  //2021-02-14 20:17:31 494 获取昨天现在的时间

        Date tomorrow = new Date(System.currentTimeMillis() + 24 * 60 * 60 * 1000);
        String tomorrowStr = sdf.format(tomorrow);
        System.out.println(tomorrowStr);   //2021-02-16 20:19:14 355 获取明天现在的时间
    }
}

4. 数字格式化：

　　DecimalFormat 数字格式化

　　　　#：表示任意数字

　　　　,：表示千分位

　　　　.: 表示小数点位

　　　　0: 表示不够补0

public class DecimalFormatTest01 {
    public static void main(String[] args) {
        DecimalFormat df = new DecimalFormat("###,###.##");
        String str1 = df.format(1234.5678);
        System.out.println(str1);  //1,234.57

        DecimalFormat df1 = new DecimalFormat("###,###.0000");
        String str2 = df1.format(1234.56);
        System.out.println(str2);  //1,234.5600
    }
}

　　BigDecimal：高精度计算，主要用于财务类的计算中

public class DecimalFormatTest02 {
    public static void main(String[] args) {
        BigDecimal bg1 = new BigDecimal(100);
        BigDecimal bg2 = new BigDecimal(200);
        BigDecimal bg3 = bg1.add(bg2);
        BigDecimal bg4 = bg2.divide(bg1);
        System.out.println(bg3);
        System.out.println(bg4);
    }
}

5. 枚举类型

　　当返回值有两种类型时，可以使用boolean类型

　　当返回值有三种或三种以上类型时，可以使用枚举类型，枚举也是一种引用数据类型，枚举中的值可以看作常量

public class EnumTest01{
    public static void main(String[] args){
        Result r = divide(10,0);
        System.out.println(r == Result.SUCCESS? "计算成功":"计算失败");
    }
    
    public static Result divide(int a, int b){
        try{
            int c = a / b;
            return Result.SUCCESS;
        }catch(Exception e){
            e.printStackTrace();
            return Result.FAILED;
        }
    }
}

enum Result{
    SUCCESS,FAILED
}

6. 生成随机数

　　Random

public class RandomTest01 {
    public static void main(String[] args) {
        Random random = new Random();
        int i = random.nextInt();   //产生一个int范围内的随机数
        System.out.println(i);

        int j = random.nextInt(101);   //产生[0-101)范围内的随机数，不包括101
        System.out.println(j);
    }
}

　　生成5个不重复的随机数放到数组中

public class RandomTest02 {
    public static void main(String[] args) {
        int[] arr = new int[5];
        for (int i = 0; i < arr.length; i++) {     //先把数组中的元素都置为-1,因为可能生成随机数0
            arr[i] = -1;
        }
        Random random = new Random();
        int index = 0;
        while (index < arr.length){
            int num = random.nextInt(5);
            if(!contains(arr,num)){
                arr[index++] = num;    //只有不包含的情况才把num放到数组中，同时index+1；
            }
        }
        for (int i = 0; i < arr.length; i++) {    //数组的遍历
            System.out.println(arr[i]);
        }
    }

    /**
     * 判读数组中是否包含随机生成的数
     * @param arr
     * @param key
     * @return
     */
    public static boolean contains(int[] arr, int key){
        for (int i = 0; i < arr.length; i++) {
            if(arr[i] == key){
                return true;
            }
        }
        return false;
    }
}