常见API

已于 2024-07-05 16:32:38 修改
阅读量352 收藏 6
点赞数 4
文章标签： java 开发语言
于 2024-06-18 14:23:36 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shane12396/article/details/139755385
版权

什么是API

Object类

equals方法的面试题

浅克隆

将对象本身开辟一个新的空间,对象中引用类型属性不会开辟新的空间(比如入参是数组,字符串)

需求:通过stu1这个对象,开辟一个新的对象空间,复制原来对象的属性值.  克隆

 深克隆

将对象本身开辟一个新的空间,对象中的引用类型属性,也会开辟新的空间存储

因为方法重写默认是潜克隆,需要手动重写

Objects 

注意:

1.使用字符串直接调用equals弊端:如果这个字符串对象是null,那么代码就会报空指针异常

String s1="null";
String s2="刘亦菲";

boolean b=s1.equals(s2);
//报空指针异常

2.防止报空指针异常推荐使用

boolean  b1=Objects.equals(s1,s2);

 包装类

//方式一
Integer  i1 =new Integer(10);

//方式二

Integer i2 = Integer.valueof(18);
自动装箱

将一个基本类型,赋值给一个包装类

本质:将java文件编译成class文件是 jdk 会自动的帮我们调用 valueof,将基本类型封装成包装类

 Integer  i3 =20;

自动拆箱

自动的将一个包装类赋值给一个基本类型

本质:将java文件编译成class文件时,jdk会自动的帮我们调用inValue(),将包装类型转换基本类型

Integer i3=10;

int i4=i3;
 包装类的作用

 1.可以直接获取该类的最大值和最小值

int maxValue = Integer.MAX_VALUE;
int minValue = Integer.MIN_VALUE;

2.泛型只能使用引用类型

ArrayList<Integer>  list =new ArrayList<>();

3.String 和 int 类型转换

String s1="10";
int i =Integer.parseInt(s1);

4.Integer.valueOf(s1)  和 Integer.parseInt(s1)的区别 

int i = Integer.parseInt(s1)  返回的值是基本类型

Integer i  = Integer.valueOf(s1)  返回的值是包装类

注意:字符串s1必须是数字类型的字符串

5.int转字符串

int i5=20;
String s3=i5+"";//方式一
String s4=String.valueOf(i5);//方式二

StringBuilder

package com.itheima.StringBuildeDemo;

public class StringBuilderDemo {
    public static void main(String[] args) {
        //1.如果获取StringBuilder类的对象
        StringBuilder sb1 = new StringBuilder();
        StringBuilder sb2 = new StringBuilder("abc");

        //2.学习常用方法

        sb1.append("刘亦菲");
        sb1.append("黎姿");
        System.out.println(sb1);//刘亦菲黎姿

        //链式编程
        sb1.append("杨过").append("小龙女");

        //reverse:将对象中的内容反转
        //reverse并没有创建新的对象开辟新的空间,而是直接将原对象直接反转
        sb2.reverse();
        System.out.println(sb2);//cba

    }
}

 注意:StringBuilder对象转换成String类型的对象返回格式: sb.toString()

StringJoiner

 StringJoiner sj = new StringJoiner(",");
        sj.add("刘亦菲");
        sj.add("黎姿");
        sj.add("张柏芝");
        System.out.println(sj);//刘亦菲,黎姿,张柏芝

        System.out.println("__________________");
        //三个参数的构造
        //1.参数一:拼接字符串时,自动添加分隔符
        //2.参数二:拼接字符串之前,自动添加一个开始符
        //3.拼接字符串之后,自动添加一个结束符
        StringJoiner sj2 = new StringJoiner(",", "[", "]");
        System.out.println(sj2);//[刘亦菲,黎姿,张柏芝]

Math 

//取绝对值
        System.out.println(Math.abs(-10));
        System.out.println(Math.abs(15));
        //向上取整
        System.out.println(Math.ceil(5.0000009));//6.0
        //向下取整
        System.out.println(Math.floor(5.999999));//5

        //四舍五入
        System.out.println(Math.round(5.6));//6
        System.out.println(Math.round(5.4));//5
        //取最大值
        System.out.println(Math.max(10, 20));//20

        //幂次运算
        System.out.println(Math.pow(2, 3));//8.0
        //随机数
        double random = Math.random()*10;//[0,1)*10

System

System.exit(0);
sout("我执行不到了");

long L= System.currentTimeMillis();

RunTime

Runtime 是一个单例设计模式的类,调用类中提供的类方法

Runtime rt=Runtime.getRuntime();


Runtime rt=Runtime.getRuntime();
//获取CPU的核心数量
int i=rt.availableProcessors();

long l=rt.totalMemory();

//exec:开启某个程序
//参数:程序启动软件的存储路径
//返回值:启动的程序的对象

Process exec=rt.exec("D:\\software\\Tencent\\QQ\\Bin\\QQ.exe");

exec.destroy();//关闭程序

 BigDecimal

用于解决浮点型运算时,出现结果失真的问题

 //问题:小数直接进行 +,-,*,/  不能获取精确结果
        double v = 0.1 + 0.2;
        System.out.println(v);//0.30000000000000004

        //获取对象
        BigDecimal bd1 =new BigDecimal(0.1);
        BigDecimal bd2 =new BigDecimal(0.2);
        // 以上不推荐使用,计算不准
        //add:相加
        BigDecimal sum = bd1.add(bd2);
        System.out.println(sum);
        //推荐使用下面
        BigDecimal bd3 =new BigDecimal("01");
        BigDecimal bd4 =new BigDecimal("0.2");
        

        BigDecimal  bd5=BigDecimal.valueOf(0.2);
         

 double[] doubles = {0.1, 0.2, 0.3, 0.5, 0.8};
        BigDecimal sum = BigDecimal.valueOf(0.0);
        for (int i = 0; i < doubles.length; i++) {
            double d=doubles[i];
            //每个元素封装成BigDecimal类型的对象
            BigDecimal bd=BigDecimal.valueOf(d);
            //进行累加
            sum=sum.add(bd);
        }
        //长度
        BigDecimal length = BigDecimal.valueOf(doubles.length);
        //第一个参数:BigDecimal类型的被除数
        //第二个参数:小数点精确位
        //第三个参数:舍入模式(RoundingMode的枚举类型)
        BigDecimal avg =sum.divide(length,5, RoundingMode.HALF_UP);
        System.out.println(avg);

Date

        //获取系统当前时间
        Date date = new Date();
        System.out.println(date);//Wed Jun 19 20:41:49 CST 2024

        //时间原点
        Date data1 = new Date(0);
        System.out.println(data1);//Thu Jan 01 08:00:00 CST 1970

        //类中常用方法
        long time = date.getTime();  //重点
        System.out.println(time);//1718801326631

        //将date对象所代表的时间修改成指定毫秒值对应的时间
        date.setTime(100000);   //鸡肋
        System.out.println(date);//Thu Jan 01 08:01:40 CST 1970

SimpleDateFormat

        Date date = new Date();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String s = sdf.format(date);
        System.out.println(s);//2024-06-19 21:19:48

        String s1 = sdf.format(0);
        System.out.println(s1);//1970-01-01 08:00:00
 SimpleDateFormat 解析字符串时间成为日期对象

        String s="2025-01-19 12:59:59";
        //定一个日期模板类的对象
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-ddd HH:mm:ss");
        //将日期格式的字符串转换成Date类型的对象
        //parse方法注意事项:字符串的格式 和 日期模板中定义的格式 必须一摸一样
        Date date = sdf.parse(s);//Sun Jan 19 12:59:59 CST 2025
        System.out.println(date);

 

Calendar 

用的少

        //获取一个对象
        Calendar calendar =Calendar.getInstance();
        int year=calendar.get(Calendar.YEAR);
        int Month=calendar.get(Calendar.MONTH);
        int HOUR=calendar.get(Calendar.HOUR);
        //将日历对象转换成Date日期对象
        long timeInMillis = calendar.getTimeInMillis();
        System.out.println(timeInMillis);
        System.out.println("------------------------");
        calendar.set(Calendar.YEAR,2015);
        System.out.println(calendar.getTime());//Fri Jun 19 22:47:09 CST 2015

 案例:将时间+1个月

        String s = "2023年09月10日";
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日");
        Date date = sdf.parse(s);
        //获取当前时间的日历对象
        Calendar calendar = Calendar.getInstance();
        //将日历对象代表时间修改成2023年9月10日
        calendar.setTime(date);
        //将日历对象代表的时间月份+1
        calendar.add(Calendar.MONTH,1);
        //getTime,将日历对象转换成日期对象
        //format格式化
        String s1 = sdf.format(calendar.getTime());

JDK1.8的时间

LocalDate、LocalTime、LocalDateTime

        //获取日期时间对象
        LocalDate now =LocalDate.now();//年月日
        System.out.println(now);//2024-06-21
        System.out.println("----------------------");
        LocalTime now2=LocalTime.now();
        System.out.println(now2);//07:11:06.664491400
        System.out.println("--------------------------");
        LocalDateTime now3 = LocalDateTime.now();
        System.out.println(now3);//2024-06-21T07:13:23.984924200
        //获取日期时间对象
        LocalDate now =LocalDate.now();//年月日
        System.out.println(now);//2024-06-21
        System.out.println("----------------------");
        LocalTime now2=LocalTime.now();
        System.out.println(now2);//07:11:06.664491400
        System.out.println("--------------------------");

        LocalDateTime now3 = LocalDateTime.now();
        System.out.println(now3);//2024-06-21T07:13:23.984924200

        //获取指定时间的 日期时间对象
        LocalDate of = LocalDate.of(2005,12,12);
        System.out.println(of);//2005-12-12

        LocalTime of1 = LocalTime.of(12,59,30);
        System.out.println(of1);//12:59:30

        LocalDateTime of2 = LocalDateTime.of(2024,12,11,13,11,12);
        System.out.println(of2);//2024-12-11T13:11:12

 LocalDate的常用API

        LocalDate now = LocalDate.now();

        int year = now.getYear();
        System.out.println(now.getYear());
        System.out.println(now.getDayOfMonth());
        System.out.println("-------------------------");
        DayOfWeek dayofweek =now.getDayOfWeek();
        int value = dayofweek.getValue();
        System.out.println(value);
        //直接修改某个信息
        LocalDate now2 = now.withYear(2022);
        System.out.println(now);//2024-06-21
        System.out.println(now2);//2022-06-21
        //修改月
        LocalDate now3 = now.withMonth(11);
        System.out.println(now3);//2024-11-21

        LocalDate now4 = now.plusDays(10);

LocalDate、LocalTime、LocalDateTime之间的转换

        LocalDateTime now = LocalDateTime.now();
        LocalDate localDate = now.toLocalDate();
        System.out.println(localDate);//2024-06-21

        LocalTime localTime = now.toLocalTime();
        System.out.println(localTime);

        LocalDate of1 = LocalDate.of(2008, 12, 12);
        LocalTime of2 = LocalTime.of(12, 12, 12);
        LocalDateTime of = LocalDateTime.of(of1, of2);
        System.out.println(of);//2008-12-12T12:12:12

DateTimeFormatter

        //格式化:时间对象转换成字符串

        //获取当前时间
        LocalDateTime now = LocalDateTime.now();
        //定义一个日期模板类
        DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        //执行格式化
        String format = now.format(dtf);
        System.out.println(format);//2024-06-21 10:33:18
        System.out.println("_______________");
        //解析:字符串转换成时间对象
        //定义一个日期字符串
        String s="2018年12月12日 12:59:59";
        DateTimeFormatter dtf2 = DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH:mm:ss");

        //执行解析
        LocalDateTime parse = LocalDateTime.parse(s, dtf2);
        System.out.println(parse);//2018-12-12T12:59:59

正则表达式

    //用正则表达式校验字符串是否时QQ号
    //不能以0开头,长度是(6-20)之间,并且全部是数字
    public static boolean checketQQ(String qq) {
        return qq.matches("[1-9]\\d{5,19}");
    }
书写规则

        System.out.println("a".matches("[abc]]"));//现在字符串a是否在除了"abc"字符串外
        System.out.println("D".matches("[a-zA-Z]"));//b是否在a-Z之内

案例

 校验用户输入的电话,邮箱是否合法

        Scanner sc =new Scanner(System.in);
        System.out.println("请输入你的电话号码");
        String phone = sc.next();
        //定义校验规则
        String regex="1[3-9]\\d{9}";//手机号的第二位是3~9,共9位
        boolean b = phone.matches(regex);
        if(b){
            System.out.println("您的手机号正确");
        }
        else
        {
            System.out.println("您输入的手机号错误");
        }
匹配多个字符案例
"ab".matches("[a-zA-Z0-9][a-zA-Z0-9]")        //true        
//或者  
"ab".matches("[a-zA-Z0-9]{2}")        //true

案例一

验证邮箱

案例二

只需要把每个邮箱的用户名爬出来

package com.itheima.typchange;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Test3 {
    public static void main(String[] args) {
        String data="asdasd@.qwd.com";
        //定义匹配规则
        //()包含起来代表一组
        String regex="(\\w{2,})@\\w{2,10}(\\.[a-z]{2,7}){1,2}";
        //获取一个Matcher类型的对象(匹配器的对象)
        //compile指定匹配规则,matcher指定从那个文本中匹配数据
        Matcher matcher= Pattern.compile(regex).matcher(data);
        //循环匹配
        //find()开始匹配,匹配到一个内容就返回true
        //group获取到匹配的数据
        while(matcher.find()){
           /* String s=matcher.group();
            System.out.println(s);*/
            String s1 = matcher.group(1);//获取第一组
            System.out.println(s1);
        }
    }
}
案例三:使用正则表达式查找一段文本中的内容


import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class lamdaTest11 {
    public static void main(String[] args) {
        String data="欢迎................一个嘉年华";
        //定义匹配规则
        String regex="欢迎(.){2,5}光临本系统";
        //获取匹配器对象
        Matcher match= Pattern.compile(regex).matcher(data);
        //循环遍历
        while (match.find())
        {
            String s=match.group(1);
            System.out.println(s);
        }
    }
}
 用于搜索替换,分隔内容
package com.itheima.typchange;

public class lamdatest1 {
    public static void main(String[] args) {
        //需求1:请把下面字符串中不是汉字的内容替换成为"000"
        String s1 = "uhhkfa护身符FLufl f很舒服了FF 发iu去问有钱";
        String s = s1.replaceAll("FLU", "OOO");
        //正则表达用法
        String s2 = s1.replaceAll("\\w+", "OOO");

        //需求2:请把下面字符串中人名去取出来,使用切割来做
        String s3="欧阳娜娜aa付款合法回复ad迪丽热巴fs卡死fsf张三";
        String[] split = s3.split("\\w+");
    }
}

 排序算法

选择排序

int [] ints={5,1,3,2};

//外循环,确定循环轮数,确定比较的基准位
for(int i=0;i<ints.length-1;i++){
//内循环,确定每轮比较次数,比较位
for(int j=i+1;j<ints.length;j++){

   //如果比较位的值,小于基准位的值,进行交换
   if(ints[j]<ints[i]){
   //将比较位的值 存储 到temp
      int temp =ints[j];
      ints[j]=ints[i];
      ints[i]=temp;
}}}
二分查找(折半查找)



public class chazhaoerfen {
    public static void main(String[] args) {
        int num=79;
        int [] arr={1,13,16,58,64,79,81,99};
    }
    public static int binarSerach(int[] arr,int num){
        //查找的最小范围
        int left=0;
        //查找的最大范围
        int right=arr.length-1;
        while(left<=right){
            //确定中间位的索引
            int mid=(left+right)/2;
            //如果中间元素大于需要查找的元素,认为需要查找的元素在左边
            if(arr[mid]>num){
                //最大索引范围等于 mid-1
                right=mid-1;
            }
            else if(arr[mid]<num){
                //最小范围等于 mid+1
                left=mid+1;
            }
            else{
                return mid;
            }

        }
        return -1;

    }
}

 Arrays工具类

方便操作数组的工具类

toString 
//toString :循环遍历指定的数组,拼接成一个固定格式的字符串给我们返回
int [] arr ={11,22,99,44,77,66};
sout(Arrays.toString(arr));
copyOfRange

拷贝数组指定范围

int [] arr ={11,22,99,44,77,66};
//参数一:从哪个数组中拷贝数据
//参数二:从哪个索引开始拷贝
//参数三:拷贝到哪个索引(不包含)
//返回:新的数组
int [] ints=Arrays.copyOfRange(arr,2,5);
sout(Arrays.toString(ints));
//从起始位置拷贝几个
int [] ints1=Arrays.copyOf(arr,15);
sout(Arrays.toString(ints1));

Arrays.sort()实现倒叙排序

 如果在数组中存储的是对象,如何排序

 

 两种方式的对比

方式一:使用的接口 Comparable    重写的方法compareTo  一个形参

方式二:使用的接口 Comparator    重写的方法  Compare    两个形参

Lambda表达式

应用场景: 

当遇到一个方法的形参类型是函数接口时,就可以使用Lambda表达式创建接口的实现类对象,传参

Integer [] arri= {5,3,9,7,1};
Arrays.sort(arri,(o1-o2)->{return o1-o2});
//或者
Arrays.sort(arri,(o1-o2)-> o1-o2);
sout(Arrays.toString(arri));

 格式


public class Test1 {
    public static void main(String[] args) {
        Swim s1 = new Swim() {
            @Override
            public void swimming() {
                System.out.println("狗刨式有用");
            }
        };
        s1.swimming();
        System.out.println("__________________________");
        //lambda方式
        Swim s2 = () -> {
            System.out.println("猫抛石有用");
        };
        s2.swimming();
    }
}

public interface AInter{
   void sum(int a,int b);
}

public class Test{
     psvm{
 mod(new AInter(){
 @Override
    public void sum(int a,int b)
   {
      sout(a+b);
   });
//lambda表达式写法
mod((int a,int b)->{sout(a-b)});
}
//AInter a=new AInter(){.....}
//AInter a=()->{}
pubic static void mod(AInter a) 
  a.sum(10,20);
}   

public inteerface BInter{
String print(String name);
}

public class test1{

 psvm{
show(new BInter(){
@Override
public String print(String name)
{
   for(int i=0;i<100;i++){
    sout("我爱"+name);
}
return "答应";
}});
show((String name)->{
  for(int i=0;i<50;i++){
  sout("我爱"+name);
}
return "答应";
});

}

pblic static void show(BInter b){
   String s=b.print("刘亦菲");
   sout(s);
 }
}
Lambda表达式的省略写法(进一步简化Lambda表达式的写法)

 

精神病研究院王主任
关注
  • 4
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值