Java常用Api

郑*杰

已于 2022-11-06 17:29:17 修改

阅读量153

点赞数

CC 4.0 BY-SA版权

分类专栏： java 文章标签： java 前端算法

于 2022-10-13 21:34:07 首次发布

本文链接：https://blog.youkuaiyun.com/qq_34577961/article/details/127310072

java 专栏收录该内容

22 篇文章

订阅专栏

本文详细介绍了Java中的String类操作、ArrayList使用技巧、数组处理方法、对象的toString及equals方法重写、StringBuilder使用、BigDecimal运算、日期时间处理及正则表达式应用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

String类常用方法

package javabean;

import java.util.*;

public class RemoveRangeOfArrayList extends ArrayList {
    public static void main(String[] args) {
        String test = "abcde";
        System.out.println("长度："+test.length());
        System.out.println("获取指定位置上某个字符："+test.charAt(1));
        System.out.println("返回的是'a'在字符串中第一次出现的位置,不存在返回-1："+test.indexOf("a"));
        System.out.println("从2指定位置开始，获取'a'在字符串中出现的位置："+test.indexOf("a",2));
        System.out.println("返回的是a在字符串中最后一次出现的位置："+test.lastIndexOf("a",2));
        System.out.println("判断是否包含："+test.contains("a"));
        System.out.println("判断是否为空："+test.isEmpty());
        System.out.println("判断是否以'a'开头："+test.startsWith("a"));
        System.out.println("判断是否以'a'结尾："+test.endsWith("a"));
        System.out.println("判断是否值相等："+test.equals("a"));
        System.out.println("判断是否值相等,忽略大小写："+test.equalsIgnoreCase("a"));
        System.out.println("转成字符数组："+test.toCharArray());
        System.out.println("替换指定字符："+test.replace("a","b"));
        System.out.println("分割："+test.split("a"));
        System.out.println("从第3位截取都最后："+test.substring(2));
        System.out.println("截取3到4位："+test.substring(2,3));
        System.out.println("大写："+test.toUpperCase());
        System.out.println("小写："+test.toLowerCase());
        System.out.println("左右空格去除："+test.trim());
        String s = "-100";
        int num = Integer.valueOf(s);
        System.out.println("转数字"+ num);

    }

}

ArrayList常用api

package ArrayList_UtilityClass;

import java.util.ArrayList;


public class ArrayListTest {
    public static void main(String[] args) {

        ArrayList<String> arrList = new ArrayList<String>();
        // 将指定元素添加到此列表的末尾
        arrList.add("A");
        arrList.add("B");
        arrList.add("D");

        

        // 将指定元素插入到列表中的指定位置(位置从1开始，下标从0开始)
        arrList.add(3, "C");

        // 将另一个集合(列表)中的所有元素添加至当前列表
        ArrayList<String> numList = new ArrayList<>();
        numList.add("10086"); 
        numList.add("10010"); 
        numList.add("10000"); 
        arrList.addAll(numList);

        // 将另一个集合(列表)中的所有元素添加至当前列表的指定位置
        arrList.addAll(0, numList);

        
        // 判断列表中是否包含某个值
        System.out.println("当前列表是否包含10086：" + arrList.contains("10086"));


        // 获取列表中指定位置的值
        String statement = arrList.get(3);

        // 返回列表中首次出现指定元素的下标，未找到则返回-1
        int indexA = arrList.indexOf("A");

        // 返回列表中最后一次出现指定元素的下标，未找到则返回-1
        int index_6 = arrList.lastIndexOf("10086");


        // 判断列表是否为空
        boolean emptyFlag = arrList.isEmpty();


        // 删除列表中指定下标处的元素
        String remove_3 = arrList.remove(3);

        // 删除列表中首次出现的某个元素
        boolean removeFlag = arrList.remove("10086");


        // 删除集合中的所有元素
        boolean removeAllFlag = arrList.removeAll(arrList);



        // 用指定元素代替指定位置上的元素
        arrList.set(2, "S"); // 将下标为2的值替换成S


        // 获取此列表的长度(规格)
        System.out.println("当前列表的长度为：" + arrList.size());


        // 将列表中的元素存入数组
        Object[] objArr = arrList.toArray();


    }
}

//删除指定范围
import java.util.*;
public class RemoveRangeOfArrayList extends ArrayList {
    public static void main(String[] args) {
        RemoveRangeOfArrayList arr_l = new RemoveRangeOfArrayList();
        arr_l.add("C");
        arr_l.add("C++");
        arr_l.add("JAVA");
        arr_l.add("DOTNET");
        arr_l.add("PHP");
        System.out.println("ArrayList Elements :" + arr_l);
        arr_l.removeRange(2, 4);
        System.out.println("arr_l.removeRange(2,4) : " + arr_l);
    }

}

Arrays

public class Test2 {
    public static void main(String[] args) {
        int[] arr = {2,33,3,6,8,111};
        System.out.println("打印数组："+ Arrays.toString(arr));
        Arrays.sort(arr);
        System.out.println("数组排序,默认升序："+ Arrays.toString(arr));
        System.out.println("二分查找,返回下标，前提要先排序好："+ Arrays.binarySearch(arr,33));
    }
}

public class Test2 {
    public static void main(String[] args) {
        Integer[] arr = {2,33,3,6,8,111};
        Arrays.sort(arr, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2-o1; //负整数表示降序
            }
        });
        System.out.println(Arrays.toString(arr));

       //其他引用类型的排序，可自定义
        Student[] st = new Student[3];
        st[0] = new Student("小明",23,167.5);
        st[1] = new Student("小明1",24,177.5);
        st[2] = new Student("小明2",25,197.5);
        Arrays.sort(st, new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                return Double.compare(o1.getHeight(),o2.getHeight());
            }
        });
        System.out.println(Arrays.toString(st));

    }
}

object.toString()


public class Test {
    public static void main(String[] args) {
        People p = new People("小明",10,"男");
        System.out.println(p.toString()); //toString()可不写
    }
}



class People{
    private String name;
    private int age;
    private String sex;

    public People(String name, int age, String sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
    }

    // 所有类都会默认继承object类，toString默认是打印类的地址，地址的是无意义的，因此目的是为了给子类重写
    @Override
    public String toString() {
        return "People{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", sex='" + sex + '\'' +
                '}';
    }
}

打印结果：
People{name='小明', age=10, sex='男'}

object.equals()

object.equals() //默认比较的是两个对象的地址，正常需求是比较内容是否相同，因此子类需要equeals方法

import java.util.Objects;

public class Test {
    public static void main(String[] args) {
        People p = new People("小明",10,"男");
        People p2 = new People("小明",10,"男");
        System.out.println(p.equals(p2));
        System.out.println(p== p2);
    }
}



class People{
    private String name;
    private int age;
    private String sex;

    public People(String name, int age, String sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        People people = (People) o;
        return age == people.age && Objects.equals(name, people.name) && Objects.equals(sex, people.sex);
    }
}

Objects.equals


public class Test2 {
    public static void main(String[] args) {
        String s = "abc";
        String s1 = "abc";
        System.out.println(s.equals(s1)); // 如果s是null则抛异常
        System.out.println(Objects.equals(s, s1)); // 更安全，如果s是null则返回false
    }
}

StringBuilder

public class StringBuilderDemo {
    public static void main(String[] args) {
        StringBuilder a = new StringBuilder();
        a.append("1").append('a').append("b").append(false).append(2.4);
        System.out.println("可拼接任意类型数据 "+ a);
        a.reverse();
        System.out.println("数据反转" + a);
        String b = a.toString(); //拼接数据后，最终应该要把他转成string类型，因为一般定义字符串都是如此，方便其他人接收数据
    }
}

BigDecimal

public class StringBuilderDemo {
    public static void main(String[] args) {
        BigDecimal a = BigDecimal.valueOf(10);
        BigDecimal b = BigDecimal.valueOf(3);
        BigDecimal d = a.add(b);
        BigDecimal e = a.subtract(b);
        BigDecimal f = a.multiply(b);
        BigDecimal h = a.divide(b,2, RoundingMode.HALF_UP);//除不尽保留两位,四舍五入
        BigDecimal h = a.divide(b,2, RoundingMode.CEILING);//向上取整"
        BigDecimal h = a.divide(b,2, RoundingMode.DOWN);//向下取整
        System.out.println(d);
        System.out.println(e);
        System.out.println(f);
        System.out.println(h);


    }
}

时间日期


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

public class StringBuilderDemo {
    public static void main(String[] args) throws ParseException {
        Date time = new Date();
        System.out.println("当前时间"+ time.getTime());
        long time2 = System.currentTimeMillis();
        System.out.println("当前时间"+ time2);
        Date time3 = new Date(time2);
        System.out.println("当前时间"+ time3);
        time.setTime(time2);
        System.out.println("当前时间"+ time);
        SimpleDateFormat time4 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss EEE a");
        String time5 = time4.format(time);
        System.out.println("格式化后的时间"+time5);
        ///////////*************************////////////////////
        SimpleDateFormat deifneFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String parseTime = "2022-10-23 14:43:11"; //解析字附串格式的时间，先定义好格式，否则会报错
        Date newParseTime1 = deifneFormat.parse(parseTime);
        System.out.println("解析后的时间"+newParseTime1);
        Long afterTime = newParseTime1.getTime() + 1000;
        String newafterTime = deifneFormat.format(afterTime);
        System.out.println("增加后的时间"+newafterTime);
    }
}

public class StringBuilderDemo {
    public static void main(String[] args) throws ParseException {
        Calendar cal = Calendar.getInstance();
        System.out.println("直接打印，可查找filed的值"+ cal);
        System.out.println("年份"+ cal.get(Calendar.YEAR));
        System.out.println("本月第几天"+ cal.get(Calendar.DAY_OF_MONTH));
        System.out.println("本月第几周"+ cal.get(Calendar.WEEK_OF_MONTH));
    }
}

正则表达

public class Test2 {
    public static void main(String[] args) {
        String rs = "来学习Java,电话020-43422424，或者联系邮箱" +
                "itcast@itcast.cn,电话18762832633，0203232323" +
                "邮箱bozai@itcast.cn, 400-100-3233,4001003232";
        //需求:从上面的内容中爬取出电话号码和邮箱。
        // 1、定义爬取规则，字符串形式
        String regex = "(\\w{1,30}@[a-zA-Z0-9]{2,20}(\\.[a-zA-Z0-9]{2,20}){1,2})|" +
                        "(1[3-9]\\d)" +
                        "|(0\\d{2,6}-?\\d{5,20})|" +
                        "(400-?\\d{3,9}-?\\d{3,9})";
        // 2、把这个爬取规则编译成匹配对象。
        Pattern pattern = Pattern.compile(regex);
        // 3、得到一个内容匹配器对象
        Matcher matcher = pattern.matcher(rs);
        // 4、开始找了
        while (matcher.find()) {
            String rs1 = matcher.group();
            System.out.println(rs1);

        }
    }
}