Java常用类

最新推荐文章于 2023-11-04 14:28:53 发布

Jeremy202109

最新推荐文章于 2023-11-04 14:28:53 发布

阅读量85

点赞数

分类专栏： Java 文章标签： java 字符串

本文链接：https://blog.csdn.net/jeremyl/article/details/112062048

版权

Java 专栏收录该内容

10 篇文章 0 订阅

订阅专栏

字符串相关的类

String 与char[]之间的转换：
String–>char[]: 调用String的toCharArray()
char[]–>String: String构造器

/*
* String,StringBuffer, StringBuilder异同
* String：不可变的字符序列；底层用char[]存储
* StringBuffer：可变的字符序列；线程安全的，效率低；底层用char[]存储
* StringBuilder：可变的字符序列；线程不安全，效率高；底层用char[]存储
*
* 问题1 ：StringBuffer虽然默认长度16，但是length重写了，只返回不为空的数目
* 问题2：扩容：如果要添加的数据底层装不下，默认情况下，扩容为原来的2倍+2，同时将原有数组复制到新数组
*
* 开发中建议用后面两个
* */

StringBuffer、StringBuilder常用方法:
增：append
删：delete(int start, int end)
改：setCharAt(int n ,char ch) / replace(int start, int end, String str)
查：charAt(int n)
插：insert(int offset, xxx)
长度：length()
遍历：for()+charAt() / toString()

字符串拼接方式赋值的对比

常量与常量拼接的结果在常量池。且常量池中不会存在相同内容的常量。
只要其中一个是变量，结果就在堆中
如果拼接的结果调用intern()方法，返回值就在常量池中。

算法题

模拟一个trim方法去除字符串两端的空格
将一个字符串进行反转。讲字符串中指定部分进行反转。

public class StringDemo {
    /*
    * 将一个字符串进行反转。讲字符串中指定部分进行反转。
    *
    * 方式一：转换为char[]
    * */
    public String reverse(String str,int startIndex, int endIndex){

        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);
    }

    //方式二：使用string拼接操作
    public String reverse1(String str,int startIndex,int endIndex){
        String reverseStr=str.substring(0,startIndex);
        for (int i = endIndex; i >= startIndex ; i--) {
            reverseStr+=str.charAt(i);
        }

        reverseStr+=str.substring(endIndex+1);
        return reverseStr;
    }

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

        //第一部分
        builder.append(str.substring(0,startIndex));

        //second
        for (int i = endIndex; i >=startIndex; i--) {
            builder.append(str.charAt(i));
        }

        //third
        builder.append(str.substring(endIndex+1));

        return builder.toString();
    }

}

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

public class StringDemo1 {
    /*
    * 获取一个字符串在另一个中出现的次数，
    * 比如ab在abkkcadkabkebfkabkskab
    * */


    /*
    * 获取subStr在mainStr中出现的次数
    * */
    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+subLength);
//            }

            //方式二：改进
            while ((index=mainStr.indexOf(subStr,index))!=-1){
                count++;
                index+=subLength;
            }
            return count;
        }else
            return 0;
    }


}

4. 获取两个字符串中最大相同子串

public class StringDemo2 {
    /*
    * 获取两个字符串中最大的相同子串
    * 提示：讲短的那个串进行长度依次递减的子串与较长的比较
    *         str1="abcwerthelloyuiodefabcdef",str2="cvhellobnm"
     * */

    public String getMaxSameString(String str1,String str2){
        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 minStr;
                }
            }
        }


        return null;
    }
}

日期

获取系统当前时间：System类中的currentTimeMillis()

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

java.util.Date类
java.sql.Date类

两个构造器的使用：
两个方法的使用：toString(): 显示当前的年月日等；getTime()：获取当前Date对象对应的毫秒数
java.sql.Date是数据库类型的变量

SimpleDateFormat类

package com.atguigu.java;

import org.junit.Test;

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

/**
 * jdk 8之前的日期时间api
 * 1. System类中的currentTimeMillis();
 * 2. java.util.Date和子类java.sql.Date
 * 3. SimpleDateFormat
 * 4. Calendar
 *
 * @create 2021-01-02 下午8:38
 */
public class DateTimeTest {
    /*
    * SimpleDateFormat的使用：SimpleDateFormat对日期Date类的格式化和解析
    *
    * 1. 两个操作
    * 1.1 格式化：日期--》字符串
    * 1.2 解析：字符串--》日期
    *
    * 2. SimpleDateFormat的实例化
    * */

    @Test
    public void testSimpleDateFormat() throws ParseException {
        //instance of SimpleDateFormat: default constructor
        SimpleDateFormat sdf=new SimpleDateFormat();

        //格式化：日期--》字符串
        Date date=new Date();
        System.out.println(date);

        String format = sdf.format(date);
        System.out.println(format);

        //解析：字符串--》日期 要求字符串必须符合SimpleDateFormat格式，不符合抛异常
        String str="2020-01-02 12:11:11";
//        Date date1 = sdf.parse(str);
//        System.out.println(date1);

        //***************************************
        SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
        Date date1=sdf1.parse(str);
        System.out.println(date1);
    }

    /*
    * 练习一：字符串"2020-09-08"转化为java.sql.Date
    *
    * 练习二："三天打鱼两天晒网"  从1990-01-01 问某天在干嘛
    *   总天数%5==1，2，3 打鱼
    *   总天数%5==0，4 晒网
    *
    *   总天数计算
    *   方式一：(date.getTime毫秒数相减 / (1000*60*60*24) )+1
    *   方式二：
    * */
    @Test
    public void testExer() throws ParseException {
        String birth="2020-09-08";

        SimpleDateFormat sdf1=new SimpleDateFormat("yyyy-MM-dd");
        Date date = sdf1.parse(birth);
        System.out.println(date);

        java.sql.Date birthDate=new java.sql.Date(date.getTime());
        System.out.println(birthDate);

    }

}

Calendar类

/*
    * Calendar日历类的使用
    *
    * */
    @Test
    public void testCalendar(){
        //1. 实例化
        //方式一：创建子类GregorianCalendar对象
        //方式二：调用其静态方法getInstance()
        Calendar calendar=Calendar.getInstance();

        //2. 常用方法
        //get()
        int day = calendar.get(Calendar.DAY_OF_MONTH);
        System.out.println(day);

        //set()
        calendar.set(Calendar.DAY_OF_MONTH,22);

        //add()
        calendar.add(Calendar.DAY_OF_MONTH,3);
        
        //getTime(): 日历类--》Date
        Date date = calendar.getTime();
        System.out.println(date);

        //setTime(): Date-->日历类
        Date date1=new Date();
        calendar.setTime(date1);
        System.out.println(date1);
    }

LocalDate, LocalTime, LocalDateTime

/*
    * LocalDate, LocalTime, LocalDateTime的使用
    * */
    @Test
    public void test1(){
        //now(): 获取当前日期，时间，日期➕时间
        LocalDate localDate = LocalDate.now();
        LocalTime localTime=LocalTime.now();
        LocalDateTime localDateTime=LocalDateTime.now();

        System.out.println(localDate);
        System.out.println(localTime);
        System.out.println(localDateTime);

        //of(): 指定年月日时分秒，没有偏移量
        LocalDateTime localDateTime1 = LocalDateTime.of(2020, 01, 2, 22, 36, 16);
        System.out.println(localDateTime1);

        //getXxx()
        System.out.println(localDate.getDayOfMonth());
        System.out.println(localDate.getMonthValue());

        //体现不可变性
        LocalDate localDate1 = localDate.withDayOfMonth(22);
        System.out.println(localDate);
        System.out.println(localDate1);



    }

DateTimeFormatter

 @Test
    public void test2(){
        //自定义格式，ofPattern("yyyy-MM-dd hh:mm:ss")
        DateTimeFormatter formatter=DateTimeFormatter.ofPattern("yyyy-MM-dd hh:mm:ss");

        //格式化
        String str=formatter.format(LocalDateTime.now());
        System.out.println(str);

        //解析
        TemporalAccessor accessor=formatter.parse("2020-01-03 04:52:30");
        System.out.println(accessor);
    }

比较器

自然排序：java.lang.Comparable
定制排序：java.util.Comparator

comparable
* 1. 像String，包装类等实现了Comparable接口，重写了compareTo()方法，给出了比较两个对象大小的方法
* 2. 像String，包装类重写了compareTo方法以后，从小到大排序
* 3. 重写compareTo()规则：
* 当前大于，返回正整数
* 当前小于，返回负整数
* 当前等于，返回0
* 4. 对于自定义类，需要排序，可以让自定义类实现Comparable接口，重写CompareTo方法

public class CompareTest {
    /*
    * Comparable接口举例
    * 1. 像String，包装类等实现了Comparable接口，重写了compareTo()方法，给出了比较两个对象大小的方法
    * 2. 像String，包装类重写了compareTo方法以后，从小到大排序
    * 3. 重写compareTo()规则：
    *   当前大于，返回正整数
    *   当前小于，返回负整数
    *   当前等于，返回0
    * 4. 对于自定义类，需要排序，可以让自定义类实现Comparable接口，重写CompareTo方法
    * */
    @Test
    public void test1(){
        String[] arr=new String[]{"AA","BB","CC","KK","MM","DD"};
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));
    }

    @Test
    public void test2(){
        Good[] arr=new Good[4];

        arr[0]=new Good("lianxiang",34);
        arr[1]=new Good("hp",21);
        arr[2]=new Good("imac",23);
        arr[3]=new Good("dell",30);

        Arrays.sort(arr);

        System.out.println(Arrays.toString(arr));
    }
}

public class Good implements Comparable{
    private String name;
    private double price;

    public Good(String name, double price) {
        this.name = name;
        this.price = price;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    @Override
    public String toString() {
        return "Good{" +
                "name='" + name + '\'' +
                ", price=" + price +
                '}';
    }


    @Override
    public int compareTo(Object o) {
        if (o instanceof Good){
            Good good=(Good)o;
            //方式一
            if (this.price>good.price){
                return 1;
            }else if (this.price<good.price){
                return -1;
            }else
                return 0;

            //方式二
//            return Double.compare(this.price,good.price);
        }
        throw new RuntimeException("传入的数据类型不一致");
    }
}

comparator

public void test4(){
        //指明商品比较大小的方式：按照产品名称从低到高排序，再按照价格从高到低排序
        Good[] arr=new Good[4];

        arr[0]=new Good("lianxiang",34);
        arr[1]=new Good("hp",21);
        arr[2]=new Good("imac",23);
        arr[3]=new Good("dell",30);

        Arrays.sort(arr, new Comparator<Good>() {
            @Override
            public int compare(Good o1, Good o2) {
                if (o1.getName().equals(o2.getName())){
                    return Double.compare(o1.getPrice(),o2.getPrice());
                }else {
                    return o1.getName().compareTo(o2.getName());
                }
            }
        });

        System.out.println(Arrays.toString(arr));
    }

Comparable是让对象类实现接口，Comparator临时给了一种排序方式

system类

代表系统，位于lang包
构造器是private的，无法实例化，变量方法是static
方法：
native long currentTimeMillis()
void exit(int status)
void gc()
String getProperty(String key)

math类

java.lang.Math提供一系列静态方法用于科学计算，方法一般返回double

Jeremy202109

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
Java常用类

字符串相关的类String 与char[]之间的转换：String–>char[]: 调用String的toCharArray()char[]–>String: String构造器/** String,StringBuffer, StringBuilder异同* String：不可变的字符序列；底层用char[]存储* StringBuffer：可变的字符序列；线程安全的，效率低；底层用char[]存储* StringBuilder：可变的字符序列；线程不安全，效率高；底层用ch
复制链接

扫一扫

专栏目录