Java语法基础学习DayEighteen（常用类）

一、String类

1.特点

String代表不可变的字符序列，底层用char[]存放。

String是final的。

2.内存解析

3.常用方法

int length()

char charAt(int index):返回指定位置的字符

boolean equals(Object obj)：比较字符串的内容是否相等

int compareTo(String anotherString)：对字符串内容按字典顺序进行大小比较，当前对象比参数大返回正整数，反之返回负整数，相等返回0。

int indexOf(String s)：返回S在字符串中首次出现的位置,没有返回-1

int indexOf(String s, int startpoint)：返回s从字符串的startpoint的位置开始首次出现的位置。

int lastIndexOf(String s)：返回s在字符串中最后一次出现的位置

boolean startsWith(String prefix)：测试此字符串从指定索引开始的子字符串是否以指定前缀开始。

boolean endsWith(String prefix)：测试此字符串是否以指定的后缀结束。

boolean regionMatches(int firstStart,String other,int otherStart,int len)：测试两个字符串区域是否相等。

String substring(int startpoint)：返回一个新的字符串，它是此字符串的一个子字符串。

String substring(int start, int end)

String replace(char oldChar, char newChar)：返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。

String replaceAll(String old , String new)：使用给定的new替换此字符串所有匹配给定的正则表达式的子字符串。

String trim()：返回字符串的副本，忽略前导空白和尾部空白，中间的空格不变。

String concat(String str)：将指定字符串连接到此字符串的结尾。

String[] split(String regex)：根据给定正则表达式的匹配拆分此字符串。

题目1

    //模拟一个trim方法，去除字符串两端的空格
    public static String myTrim(String str){
        int start = ;
        int end = str.length() - ;
        while(start < end && str.charAt(start) == " "){
            start++;
        }
        while(start < end && str.charAt(end) == " "){
            end--;
        }
        return str.subString(start,end + );
    }

题目2

public class Test{
    public static void main(String[] args){
        String str = "abcdefg";
        String str1 = reverseString(str,,);
        System.out.println(str1);//输出abedcfg
        String str2 = reverseString2(str,,);
        System.out.println(str2);//输出abedcfg
    }
    //将一个字符串进行反转，将字符串中指定部分进行反转，比如将“abcdefg”反转为“abfedcg”
    public static String reverseString(String str, int start, int end){
        char[] c = str.toCharArray();//字符串--->字符数组
        return reverseArray(c,start,end);
    }
    public static String reverseArray(char[] c, int start, int end){
        for(int i = start,j = end;i < j; i++,j--){
            char temp = c[i];
            c[i] = c[j];
            c[j] = temp;
        }
        return new String(c);//字符数组--->字符串
    }
    //字符串的反转方法二,可使用StringBuffer继续优化
    public static String reverseString2(String str, int start, int end){
        String str1 = str.substring(,start);
        for(int i = end;i >= start;i--){
            char c = str.charAt(i);
            str1 += c;
        }
        str1 = str1.concat(str.substring(end+));
        return str1;
    }
}

题目3

public class Test{
    public static void main(String[] args){
        String str1 = "abdasdvabdfab";
        String str2 = "ab";
        System.out.println(getTime(str1,str2));//输出3
    }
    //返回一个字符串在另一个字符串中出现的次数,即str2在str1中出现次数
    public static int getTime(String str1, String str2){
        int count = ;
        int index;
        while((index = str1.indexOf(str2)) != -){
            count++;
            str1 = str1.substring(index+str2.length());
        }
        return count;
    }
}

题目4

import java.util.ArrayList;
import java.util.List;
public class Test{
    public static void main(String[] args){
        String str1 = "freghelloyujkuy";
        String str2 = "freghsdwhellodf";
        System.out.println(getMaxSubstring(str1,str2));//输出[fregh,hello]
    }
    //返回两个字符串中最大相同子串
    public static List<String> getMaxSubstring(String str1, String str2){
        List<String> list = new ArrayList<>();
        String longStr,shortStr;
        if(str1.length() < str2.length()){
            longStr = str2;
            shortStr = str1;
        }else{
            longStr = str1;
            shortStr = str2;
        }
        int len = shortStr.length();
        for(int i = ; i < len; i++){//i相当于短字符串截去字符的个数
            for(int x =  , y = len-i;y <= len;x++,y++){//把截取到的子串区间逐步往后挪
                String str = str2.substring(x,y);
                if(longStr.indexOf(str) != -){
                    list.add(str);
                }
            }
            if(list.size() != ){
                return list;
            }
        }
        return null;
    }
}

题目5

import java.util.Arrays;
public class Test{
    public static void main(String[] args){
        String str = "gbsdxizame";
        System.out.println(sort(str));//输出abdegimsxz
    }
    //对字符串中的字符按自然顺序排序
    public static String sort(String str){
        char[] c = str.toCharArray();
        Arrays.sort(c);
        return new String(c);
    }
}

4.字符串与基本数据类型、字节数组、字符数组之间的转换

　　字符串与基本数据类型、包装类的相互转换：

        //调用相应包装类的parseXxx(String str)方法
        int i = Integer.parseInt(str1);
        //调用String类的重载的valueOf()方法
        String str2 = String.valueOf(i);

　　字符串与字节数组的相互转换：

        String str1 = "abc123";
        //调用String类的getBytes()方法
        byte[] b = str1.getBytes();
        //调用String类的构造器
        String str2 = new String(b);

　　字符串与字符数组的相互转换：

        String str1 = "abc123中国人";
        //调用String类的toCharArray()方法
        char[] c = str1.toCharArray();
        //调用String类的构造器
        String str2 = new String(c);

二、StringBuffer类

1.概述

　　java.lang.StringBuffer代表可变的字符序列，可以在原有的基础上对字符串内容进行增删。

2.和String的区别

　　String对象对应的字符序列的容量和存放内容的长度是一致的，因此两个String对象相加会创建另外一个字符序列去存放新的String，因为容量不够。

　　而StringBuffer对象对应的字符序列有一个初始的容量，所以可以往容量未满的StringBuffer对象添加内容，所以说StringBuffer是可变的字符序列。

3.常用方法

StringBuffer append(Xxx x)：将 Xxx 参数的字符串表示形式追加到此序列

StringBuffer insert(int index, Xxx x)：将Xxx 参数的字符串表示形式在index位置插入到此序列中。

StringBuffer reverse()：将此字符序列用其反转形式取代。

StringBuffer delete(int startIndex, int endIndex)：移除此序列的子字符串中的字符。

void setCharAt(int index, char ch)：将给定索引处的字符设置为 ch。

StringBuffer replace(int start, int end, String str)：使用给定 String 中的字符替换此序列的子字符串中的字符。

int indexOf(String str)：返回第一次出现的指定子字符串在该字符串中的索引。

char charAt(int index)：返回此序列中指定索引处的 char 值。

String substring(int start , int end)：返回一个新的 String，它包含此序列当前所包含的字符子序列。

三、StringBuilder类

1.概述

　　可变的字符序列，是jdk5.0新加入的，线程不安全，效率要高于StringBuffer

2.效率对比

　　StringBuilder > StringBuffer > String

四、与时间有关的类

1.java.lang.System类

　　System类提供的public static long currentTimeMillis()用来返回当前时间与1970年1月1日0时0分0秒之间以毫秒为单位的时间差。

　　此方法适用于计算时间差。

2.java.util.Date类

　　表示特定的瞬间，精确到毫秒，不易于国际化

　　常用方法：

　　　　Date()、Date(long date)：构造方法，获取本地当前时间。

　　　　getTime()：返回自1970年1月1日0时0分0秒 GMT 以来此Date对象表示的毫秒数。

　　　　toString()：把Date对象转换成String形式

　　代码：

        Date d1 = new Date();
        System.out.println(d1.toString());//Fri Mar 22 17:17:06 CST 2019
        System.out.println(d1.getTime());//
        Date d2 = new Date(d1.getTime());
        System.out.println(d2);//Fri Mar 22 17:17:06 CST 2019

3.java.text.SimpleDateFormat类

　　是一个不与语言环境有关的方式来格式化和解析日期的具体类，易于国际化。

　　格式化：(日期 - - -> 文本)调用String format(Date date)方法格式化时间对象date

　　解析：（文本 - - -> 日期）调用Date parse(String source)方法从给定字符串的开始解析文本，以生成一个日期。

　　代码：

        //不带参格式化
        SimpleDateFormat sdf = new SimpleDateFormat();
        String date1 = sdf.format(new Date());
        System.out.println(date1);//19-3-22 下午5:48
        //带参格式化
        SimpleDateFormat sdf1 = new SimpleDateFormat("EEE, d MMM yyyy HH:mm:ss Z");
        String date2 = sdf1.format(new Date());
        System.out.println(date2);//星期五, 22 三月 2019 17:48:59 +0800
        //解析
        Date d1 = sdf.parse(date1);//注意格式要匹配，比如这里的参数不能是date2
        System.out.println(d1);//Fri Mar 22 17:48:00 CST 2019

        Date d2 = sdf1.parse(date2);//这里的参数不能是date1
        System.out.println(d2);//Fri Mar 22 17:48:59 CST 2019

　　例题：”三天打渔，两天晒网“，问从1990-01-01开始以上循环，XXXX-XX-XX这一天是在打渔还是在晒网？

import java.util.Date;
import java.text.SimpleDateFormat;
import java.text.ParseException;
public class Test{
    public static void main(String[] args) throws Exception{
        String date1 = "1990-01-01";
        String date2 = "1990-01-04";
        int dates = getDays(date1,date2);
        if(dates %  == ||dates %  == ){
            System.out.println("这一天在晒网");
        }else{
            System.out.println("这一天在打渔");
        }
    }
    //返回从XXXX-XX-XX到1990-01-01的天数
    public static int getDays(String date1, String date2) throws ParseException{
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        Date d1 = sdf.parse(date1);
        Date d2 = sdf.parse(date2);
        long milliTime = d2.getTime()-d1.getTime();
        return (int)milliTime/// + ;
    }
}

4.java.util.Calendar类

　　Calendar是一个抽象基类，主要用于完成日期字段之间互相操作的功能

　　get()/add()/set()/Date getTime()/setTime(Date d)示例：

    public static void main(String[] args) throws Exception{
        Calendar c = Calendar.getInstance();//实例化方法:getInstance()
        int day = c.get(Calendar.DAY_OF_MONTH);//获取当前时间是本月的第几天
        System.out.println(day);//

        c.add(Calendar.DAY_OF_MONTH, -);//给对象c的DAY_OF_MONTH加-2天
        day = c.get(Calendar.DAY_OF_MONTH);
        System.out.println(day);//

        c.set(Calendar.DAY_OF_MONTH,);
        Date d = c.getTime();//返回一个Date对象，时间为c的时间。
        System.out.println(d);//Tue Mar 26 19:12:35 CST 2019
    }
    

五、Math类（详见API）

六、BigInteger类

　　数字范围比Integer类的数字范围大得多，可以支持任意精度的整数。

七、BigDecimal类

　　用于天文、商业计算等要求数字精度比较高的地方，支持任意精度的定点数。