常用类第二篇-CSDN博客

本文链接：https://blog.csdn.net/weixin_56919864/article/details/130017364

String类/StringBuffer类/StringBuilder类

String类

字符串是由多个字符组成的一串数据(字符序列)的字符串常量,java中所有字

符串都是String类的实例.

public final class String
extends Object
implements Serializable, Comparable<String>（排序）, CharSequence

字符串: 一串字符, 一串字符页数由多个单个的字符组成的,只是给我们对外表示为一个整体的串.

底层还是一个一个的独立的字符

字符: 指的是一个单独的字符计算机中能够显示的所有符号都是一个个独立的,对应有一个编码表

java中所有字符串都是String类的对象 "abc" 就是一个String对象 java中的字符串不变; 它们的值在创建后不能被更改

String s1 = new String("abc");//abc 字符串对象地址是1001 s1+="def";// 1002字符串对象 abcdef 创建一个新的字符串对象,并把新数组填充到字符串对象中,并且把新对象地址赋值s1 s1+="gh"; //abcedfgh 1003

s1+="ijk"; //abcdefghijk 1004

创建字符串对象

1.String a1 = "ABC";

2.String a2 = new String("abc");

package com.ffyc.javaapi.stringDemo;
public class StringDemo1 {
    public static void main(String[] args) {
        /*
        The value is used for character storage. 
        private final char value[];
        */ 
        String s = "abc";
        //在内存中创建了一个String对象，创建后值就不可变
        String s1 = new String("abc");
        s1 +="def";
        s1 +="gh";
        s1 +="ijk"; 
        System.out.println(s1);
    }
}

package com.ffyc.javaapi.stringDemo;
public class StringDemo2 {
    public static void main(String[] args) {
        String s1 = "abc"; 
        String s2 = "abc"; 
        System.out.println(s1==s2);
        //true隐式的创建，先去字符串常量池中检测，有没有对应的字符串        //如果没有就会在字符串常量池中创建一个字符串对象
        //如果有直接将常量池的对象地址返回
        String s3 = new String("abc");
        String s4 = new String("abc");
        System.out.println(s3==s4);//false
        System.out.println(s3.equals(s4));//true 
    }
}

package com.ffyc.javaapi.stringDemo;
import java.util.Arrays;public class StringDemo3 {
    /*
    构造方法 
    String()  无参构造方法 
    String(String s)    有一个String类型参数 
    String(byte[] b)    把一个byte数组转为一个字符串  
    String(char c)      把一个char类型的数组转为字符串  
    String(StringBuffer sb) 
    String(StringBuilder sb) 
    getBytes()  把字符转为byte数组 
    toCharArray()   将字符串转为char数组
    */
    public static void main(String[] args) { 
        String s = new String();
        String s1 = new String("abc");
        byte [] bytes = "abc".getBytes();//编码  把字符转为byte数组 数字化传输 
        System.out.println(Arrays.toString(bytes)); 
        String s2 = new String(bytes);//解码  把byte数组转换为字符串
        System.out.println(s2);
        //排序  
        char[] chars = "bca".toCharArray();//将字符串转为数组
        Arrays.sort(chars);//以数组的形式进行操作 
        String s3 = new String(chars);//把char数组转为字符串
        System.out.println(s3);  
        System.out.println(String.valueOf(chars));
    }
}

package com.ffyc.javaapi.stringDemo;
public class StringDemo4 {  
    /*
    ● 判断功能
    boolean equals(Object obj)//判断内容是否相等
    boolean equalsIgnoreCase(String str)//不区分大小写 验证码
    boolean contains(String str)是否包含某一个指定的字符串 
    boolean isEmpty()是否为空  
    boolean startsWith(String prefix)是否以什么开头
    boolean endsWith(String suffix)是否以什么结尾   
    boolean comporeTo(String anotherString)比较字符串之间按照编码大小比较 
    */ 
    public static void main(String[] args) {
        String s1 = "abc";  
        System.out.println(s1.equals("abc")); 
        System.out.println(s1.equalsIgnoreCase("abC")); 
        System.out.println(s1.contains("bc")); 
        System.out.println(s1.isEmpty());     
        System.out.println(s1.startsWith("a")); 
        System.out.println(s1.endsWith("a"));   
        System.out.println("a".compareTo("b"));
    }
}

package com.ffyc.javaapi.stringDemo;
public class StringDemo5 {
    public static void main(String[] args) {  
        /* 
        获取功能   
        int length()获取长度  
        char charAt(int index)获取指定位置字符   
        int indexOf(String str)返回指定字符第一次出现的位置   
        int indexOf(String str,int fromIndex)返回从指定位置开始查找字符首次出现位置 
        String substring(int start)截取字符串，从指定位置开始到最后  
        String substring(int start,int end)截取字符串，从指定位置开始到指定位置结束  
        */  
        String s = "abcdefg"; 
        System.out.println(s.length());  
        System.out.println(s.charAt(0));  
        System.out.println(s.indexOf("b")); 
        int index = s.indexOf("c");    
        System.out.println(s.indexOf("c",index+1));  
        System.out.println(s.substring(2,6)); 
    }
}

package com.ffyc.javaapi.stringDemo;
import java.util.Arrays;public class StringDemo6 {
    public static void main(String[] args) {  
        /* 
        转换功能
        byte[] getBytes()将字符串转换为byte数组   
        char[] toCharArray()将字符串转换为char数组   
        static String valueOf(char[] chs)将char数组转化为字符串
        String toLowerCase()字符串中英文字母转换为小写       
        String toUpperCase()字符串中英文字母转换为大写   
        String concat(String str)将两个字符串连接返回新的字符串只能连接字符串   
        Stirng[] split(分割符);按照规则拆分字符串
        */ 
        String s = "abcDEF";  
        System.out.println(s.toLowerCase());   
        System.out.println(s.toUpperCase());
        String s1 = "cgef";     
        System.out.println(s.concat(s1));
        String s2 = "abc:def:efg:hij:ho";
        String[] aarray =  s2.split(":"); 
        System.out.println(Arrays.toString(aarray));  
    }
}

StringBuffer类/StringBuilder类

buffer缓冲

package com.ffyc.javaapi.stringDemo;
public class StringBufferDemo1 {
    public static void main(String[] args) {
        /*
        String对象的值是不可改变的，会产生问题经常拼接字符串时，会创建多个字符串对象，造成浪费  
        如果某些场景下，需要大量拼接字符串时我们可以使用StringBuffer 
        StringBuffer：线程安全的，可变的字符串  这个类的方法上加了synchronized(同步锁)关键字
        capacity容量 = 16  
        new StringBuffer（）默认容量为16 
        new StringBuffer（20）指定底层数组容量为20 
        new StringBuilder("abcd");容量等于内容长度加16
        char[] value;没有被final修饰可以改变 
        */
        StringBuilder s = new StringBuilder("abcd"); 
        s.append("efg");//没有创建新的StringBuffer和底层对象和数组  
        //当底层数组容量不够时会创建新的数组对象进行赋值 
        s.insert(1,"xx");//在指定的位置上插入字符串  
        System.out.println(s);  
        s.delete(1,5);//删除指定区间   
        s.replace(1,3,"AA");
        s.reverse();//反转字符串   
        System.out.println(s); 
        String s1 = s.substring(2);//截取时返回新的字符串原来字符串不变
    }
}

package com.ffyc.javaapi.stringDemo;
public class StringBuilderDemo1 {
    public static void main(String[] args) { 
        /* 
        StringBuilder：线程不安全的，可变的字符串 这个类的方法上没有加synchronized(同步锁)关键字多线程·不安全
        方法和StringBuffer基本一样  
        */ 
        StringBuilder s0 = new StringBuilder();
        s0.append("abc");
    }
}

不同点：StringBuffer是线程安全的

StringBuilder是线程不安全的

相同点：都是可变的字符串对象，底层都有一个char数组

char[] value;创建之初会创建一个指定容量的数组，增删改查都是在数组上操作

最终实现调用的都是AbstractStringBuilder父类中实现的方法

正则表达式

正则-->规则-->模式去匹配某个字符串，看字符串是否满足某种规则

可以通过正则表达式，来指定一个规则，用规则去匹配某个字符串，可以快速进行模式匹配

正则表达式 Regular Expression 在代码中简写为regex，regexp或者RE

可以使用一些特定的字符来指定规则，然后用规则去匹配字符串

学习正则表达式常用字符

package com.ffyc.javaapi.stringDemo;
public class StringDemo7 {
    /*
    使用字符串中的内容，去与指定的正则表达式匹配，成功true，否则false 
    s.matches("正则表达式"); 
    正则表达式常用特点字符 
    */ 
    public static void main(String[] args) {
        String s = "assdsds@1212.com";
        String c = "sdfghjkkkk";
        boolean res = s.matches("\\d");
        //"\\d"数字“\D”非数字        
        //？表示一次或一次也没有*表示零次或多次+表示1次或多次{n}固定的n位{n，}至少是n位{n，m}最少n位最大m位
        boolean a = s.matches("[1][3,5,7,8,9][0-9]{9}");
        System.out.println(res);   
        System.out.println(a);  
        boolean d = c.matches("[A-z]");//大小写字母 
        boolean e=s.matches("\\w+");//[a-z,A-Z,0-9] 
        boolean r = s.matches("[\\u4e00-\\u9fa5]+");//汉字 
        //邮箱  有字母数字  @qq/163/sina .com/com.cn 
        boolean q = s.matches("\\w{6,10}@\\w{2,6}\\.(com|com.cn)");
        //.可以表示任意格式所以需要转义 
        System.out.println(q); 
    }
}

Math类/Random类

Math

package com.ffyc.javaapi.MathDemo;
public class MathDemo1 {
    public static void main(String[] args) {
        /*
        Math类：提供了许多关于数学运算的方法，例如平方根，四舍五入，三角函数
        abs 绝对值  
        sqrt 平方根   
        pow(double a, double b) a的b次幂
        max(double a, double b)  
        min(double a, double b)
        random() 返回 0.0 到 1.0 的随机数
        long round(double a) double型的数据a转换为long型（四舍五入） 
        */  
        System.out.println(Math.PI); 
        System.out.println(Math.sqrt(9)); 
        System.out.println(Math.pow(2,3));//2的三次方 
        System.out.println(Math.random());//返回0-1之间的随机数 
        System.out.println(Math.round(5.4));//四舍五入
        System.out.println(Math.floor(5.9));//向下取整  
        System.out.println(Math.ceil(5.1));//向上取整  
        System.out.println(Math.max(2,5));
    }
}

Random类

package com.ffyc.javaapi.MathDemo;
import java.util.Random;
public class RandomDemo { 
    /*        Random 用来提供随机数的类     */
    public static void main(String[] args) { 
        Random random = new Random();
        System.out.println(random.nextInt());//返回int范围内的随机数
        System.out.println(random.nextLong());//返回Long范围内的随机数 
        //指定区间随机数 
        System.out.println(random.nextInt(10)+1);//0-9不包含10加一之后就是1-10了
    }
}

Date类/Calendar类/ SimpleDateFormat类

Calendar（日历）类

日历类提供了更多的关于日期操作的方法

package com.ffyc.javaapi.datelei;
import java.util.Calendar;
import java.util.GregorianCalendar;public class CalendarDemo {
    /* 
    输入一个日期（年月日），计算是当年的第几天  
    Calendar日历类，提供更为丰富的日历操作方法  
    */
    // 返回的是 Calendar这个抽象类的子类对象 
    //  Calendar calendar = Calendar.getInstance(); 
    //GregorianCalendar();创建子类对象 公历
    public static void main(String[] args) {
        //  
        Calendar calendar = Calendar.getInstance();
        Calendar calendar = new GregorianCalendar();
        System.out.println(calendar);       
        System.out.println(calendar.get(Calendar.YEAR)); 
        System.out.println(calendar.get(Calendar.DAY_OF_YEAR));
        System.out.println(calendar.get(Calendar.DAY_OF_WEEK));    }
}

Date类

获取系统当前时间

new Date（）；创建一个date对象，表示当前时间

getTime（）//返回的是1970.1.1 0:0:0至今（程序运行的时间）之间的毫秒差

package com.ffyc.javaapi.datelei;
import java.util.Date;
public class DateDemo { 
    public static void main(String[] args) { 
        /* 
        想知道此时程序运行时间 
        Date date = new Date();
        一个日期对象，就会包含我们程序运行那一刻的时间信息
        */
        Date date = new Date();
        System.out.println(date);
        System.out.println(date.getYear()+1900);
        System.out.println(date.getMonth()+1);   
        System.out.println(date.getDate());    
        System.out.println(date.getDay());   
        System.out.println(date.getHours()); 
        System.out.println(date.getMinutes());  
        System.out.println(date.getSeconds());   
        //返回的是1970.1.1 0:0:0至今（程序运行的时间）之间的毫秒差
        System.out.println(date.getTime());
    }
}

SimpleDateFormat类

简单的日期格式化

package com.ffyc.javaapi.datelei;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class SimpleDateFormatDemo {
    public static void main(String[] args) throws ParseException {
        /* 
        在前端需要显示时，需要把java中的date对象转为指定的字符串 
        */  
        //把日期对象转为指定格式的字符串 
        Date date = new Date();
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss E"); 
        String str = simpleDateFormat.format(date);
        System.out.println(str); 
        //把字符串转为指定日期对象 
        //从前端获取都是String，需要获取年，月非常麻烦 
        SimpleDateFormat c = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss E"); 
        Date p = c.parse(str); 
        System.out.println(date.getYear()+1900);
    }
}