一些java常用类笔记

一些Java常用类

字符串相关

String

• String是一个final类，代表不可变的字符序列
• 字符串是常量，值在创建后不能更改
• String对象的字符内容是存储在一个字符数组中的 char value[]

• String对象的创建

String str="hello";

String s1=new String();

String s2=new String(Stirng);

String s3=new String(char[]);

String s4=new String(char[] a,int startIndex,int count);

...

• String创建时使用字面量和new String()的区别

  • 使用字面量创建：字符串指向方法区中的字符串常量值
  • 使用new创建：字符串指向堆空间中开辟的实例存储位置

  

• 常用方法：

  • equalsIgnoreCase(String anotherString): 与equals相似，但忽略大小写
  • endsWith(String): 字符串是否以特定后缀结束
  • startsWith(String)：字符串是否以指定前缀开始
  • startsWith(String,int)：字符串从指定位置开始是否以指定前缀开始
  • contains(CharSwquence)：字符串是否包含指定的char值序列

StringBuffer、StringBuilder

• String、StringBuffer、StringBuilder异同：
  • String不可变的字符序列，StringBuffer、StringBuilder是可变的字符序列
  • StringBuffer线程安全的、效率偏低；StringBuilder线程不安全的、效率高
  • 都是使用char[]存放

算法题：

• 将一个字符串进行反转。将字符串中指定部分进行反转。比如“abcdefg”反转为”abfedcg”

public class StringDemo {

    /*
      方式一：转换为char[]
     */
    public String reverse(String str,int startIndex,int endIndex){

        if(str != null){
            char[] arr = str.toCharArray();
            for(int x = startIndex,y = endIndex;x < y;x++,y--){
                char temp = arr[x];
                arr[x] = arr[y];
                arr[y] = temp;
            }

            return new String(arr);
        }
        return null;
    }

    //方式二：使用String的拼接
    public String reverse1(String str,int startIndex,int endIndex){
        if(str != null){
            //第1部分
            String reverseStr = str.substring(0,startIndex);
            //第2部分
            for(int i = endIndex;i >= startIndex;i--){
                reverseStr += str.charAt(i);
            }
            //第3部分
            reverseStr += str.substring(endIndex + 1);

            return reverseStr;

        }
        return null;
    }
    //方式三：使用StringBuffer/StringBuilder替换String
    public String reverse2(String str,int startIndex,int endIndex){
        if(str != null){
            StringBuilder builder = new StringBuilder(str.length());

            //第1部分
            builder.append(str.substring(0,startIndex));
            //第2部分
            for(int i = endIndex;i >= startIndex;i--){

                builder.append(str.charAt(i));
            }
            //第3部分
            builder.append(str.substring(endIndex + 1));

            return builder.toString();
        }
        return null;

    }

    @Test
    public void testReverse(){
        String str = "abcdefg";
        String reverse = reverse2(str, 2, 5);
        System.out.println(reverse);
    }

}

• 获取一个字符串在另一个字符串中出现的次数。比如：获取“ab”在 “abkkcadkabkebfkaabkskab” 中出现的次数

public class StringDemo1 {
    /**
     * 获取subStr在mainStr中出现的次数
     * @param mainStr
     * @param subStr
     * @return
     */
    public int getCount(String mainStr,String subStr){
        int mainLength = mainStr.length();
        int subLength = subStr.length();
        int count = 0;
        int index = 0;
        if(mainLength >= subLength){
            //方式一：
//            while((index = mainStr.indexOf(subStr)) != -1){
//                count++;
//                mainStr = mainStr.substring(index + subStr.length());
//            }
            //方式二：对方式一的改进
            while((index = mainStr.indexOf(subStr,index)) != -1){
                count++;
                index += subLength;
            }

            return count;
        }else{
            return 0;
        }
    }

    @Test
    public void testGetCount(){
        String mainStr = "abkkcadkabkebfkaabkskab";
        String subStr = "ab";
        int count = getCount(mainStr, subStr);
        System.out.println(count);
    }
}

• 获取两个字符串中最大相同子串。比如：str1 = “abcwerthelloyuiodefabcdef”;str2 =“cvhellobnm”

  提示：将短的那个串进行长度依次递减的子串与较长的串比较。

public class StringDemo2 {
    //前提：两个字符串中只有一个最大相同子串
    public String getMaxSameString(String str1,String str2){
        if(str1 != null && str2 != null){
            String maxStr = (str1.length() >= str2.length())? str1 : str2;
            String minStr = (str1.length() < str2.length())? str1 : str2;
            int length = minStr.length();

            for(int i = 0;i < length;i++){
                for(int x = 0,y = length - i;y <= length;x++,y++){
                    String subStr = minStr.substring(x,y);
                    if(maxStr.contains(subStr)){
                        return subStr;
                    }

                }
            }

        }
        return null;
    }

    // 如果存在多个长度相同的最大相同子串
    // 此时先返回String[]，后面可以用集合中的ArrayList替换，较方便
    public String[] getMaxSameString1(String str1, String str2) {
        if (str1 != null && str2 != null) {
            StringBuffer sBuffer = new StringBuffer();
            String maxString = (str1.length() > str2.length()) ? str1 : str2;
            String minString = (str1.length() > str2.length()) ? str2 : str1;

            int len = minString.length();
            for (int i = 0; i < len; i++) {
                for (int x = 0, y = len - i; y <= len; x++, y++) {
                    String subString = minString.substring(x, y);
                    if (maxString.contains(subString)) {
                        sBuffer.append(subString + ",");
                    }
                }
//                System.out.println(sBuffer);
                if (sBuffer.length() != 0) {
                    break;
                }
            }
            String[] split = sBuffer.toString().replaceAll(",$", "").split("\\,");
            return split;
        }
        return null;
    }

    @Test
    public void testGetMaxSameString(){
        String str1 = "abcwerthello1yuiodefabcdef";
        String str2 = "cvhello1bnmabcdef";
        String[] maxSameStrings = getMaxSameString1(str1, str2);
        System.out.println(Arrays.toString(maxSameStrings));

    }

}

JDK8之前的时间API

• 计算世界时间的主要标准有：
  • UTC（Coordinated Universal Time）
  • GMT（Greenwich Mean Time）
  • CST（Central Stabdard Time）

System静态方法

提供currentTimeMillis()用来返回当前时间与1970年1月1日00:00:00之间以毫秒问单位的时间差，

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

Date类

• java.util.Date
  • 两个构造器：
    • new Date(); //当前时间
    • new Date(Long);//指定毫秒数的时间
• java.sql.Date
  • 对应数据库中日期类型的变量
  • new Date(Long);//指定毫秒数的时间
  • 将util.Date转为sql.Date的对象：
    • new Date(util.Date.getTime());

Calendar类

//实例化
Calendar.getInstance();
//或者使用其子类的构造器
GregorianCalendar g=new GregorianCalendar();
//方法
g.get(int field);//field是Calendar的静态属性，用来获取想要得到的时间信息
g.set(int field,int value);//设置时间
g.add(int field,int amount);//时间加上amount，比如现在是第10天，amount为3，那么最后时间为第13天
g.getTime();//获取日期
g.setTime(Date date);//设置日期

注：获取月份时，一月是0，十二月是11

获取日期时，周日是1，周六是7

SimpleDateFormat类

SimpleDateFormat format=new  SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
//字符串转日期类，必须是构造器创建实例时指定的格式
format.prase("2020-01-01 00:00:00");
//日期转字符串
format.format(new Date());

JDK8中新的时间API

LocalDate、LocalTime、LocalDateTime

• LocalDate本地日期 2020-01-01
• LocalTime本地时间 00:00:00.000
• LocalDateTime本地日期时间 2020-01-01 00:00:00.000

//实例化
LocalDateTime now = LocalDateTime.now();//现在时间
LocalDateTime now = LocalDateTime.now(ZoneId zone);//现在时间+时区
LocalDateTime now = LocalDateTime.of(...);//可设置年月等等
//方法
now.getDayOfMonth();//获取月份天数。。。
now.getDayOfYear();
now.getDayOfWeek();//获取星期几，返回值是星期的枚举值
now.getMonth();//获取月份，返回值是月份的枚举值
now.getMonthValue();//获得月份 1-12
now.getYear();//获得年份
now.getHour();
now.getMinute();
now.getSecond();
now.withDayOfMonth();//将月份天数修改为指定值并返回新对象
now.withDayOfYear();
now.withMonth();
now.withYear();

now.plusDays();//向对象添加几天..
...
now.minusMounths();//将对象减掉几月..
...

Instant

• 时间线上一个瞬时点，可用来记录为时间戳
• 只是简单的表示自1970年1月1日0时0分0秒（UTC）开始的秒数，精确到纳秒

Instant i=Instant.now();//实例化
Instant i=Instant.ofEpochMilli(long e);//实例化,返回1970年1月1日0时0分0秒加上指定毫秒数e后的时间

i.atOffset(ZoneOffset offset);//结合及时的偏移创建一个OffsetDateTime
i.toEpochMilli();//返回时间戳

DateTimeFormatter

类似于SimpleDateFormat

//实例化
DateTimeFormatter basicIsoDate = DateTimeFormatter.ISO_LOCAL_DATE_TIME;

DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofLocalizedDate(FormatStyle.LONG);

DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
//日期转字符串
dateTimeFormatter.format();
//字符串转日期
dateTimeFormatter.prase();

其他

Java比较器

Comparable接口

//需要实现compareTo方法
@Override
public int compareTo(StringTest o) {
    return 0;
}

//排序
Collection.sort(...)

Comparator接口

//需要实现compare方法
@Override
public int compare(StringTest o1, StringTest o2) {
    return 0;
}
//排序
Collection.sort(...)

System类

Math类

BigInteger与BigDecimal