[Java知识库]java基础

常用的API

object类

• 说明

1）object类是所有类的父类，多有的类都直接或者间接继承object类
2）object类中只有一个空参的构造
3）public String toString(); 返回对象的字符串表示形式(即: 地址值), 无意义, 建议子类重写该方法. 
4）public boolean equals(Object obj); 比较两个对象是否相等, 默认比较的是地址值, 无意义, 子类一般都会重写该方法.

注：一般开发中，如果同一个类的两个对象，各个属性值都相同，我们默认他们就是同一个对象，所以相等，但是需要重写父类的equals方法，才可以证明相等，要不比较的仍是地址值

String类

• 说明

1）String代表字符串类, 即: 由多个字符组成的一串数据. 字符串的本质就是一个字符数组

2）
  1- equals
 	   解释: 比较两个字符串的内容是否相同, 区分大小写. 即: "a" 和 "A"不是同一个字符串. 
  2- equalsIgnoreCase
 	   解释: 比较两个字符串的内容是否相同, 不区分大小写. 即: "a" 和 "A"是同一个字符串

• 代码实现

package cn.liu.b;

public class Demo02 {
    public static void main(String[] args) {
        //定义一个字符数组
        char[] chs = {'a','b','c'};
        //将字符数组进行封装
        String st1 = new String(chs);
        String st2 = new String(chs);

        //直接通过""的方式创建两个字符串对象s3和s4.
        String st3 = "abc";
        String st4 = "abc";

        //通过==分别判断s1和s2, s1和s3, s3和s4是否相同
        System.out.println(st1 == st2);  //false
        System.out.println(st3 == st4);   //true
        System.out.println(st1 == st4);  //false

        //通过equals()判断的是内容
        System.out.println(st1.equals(st2));
        System.out.println(st1.equals(st4));

        //通过equalsIgnoreCase()不区分大小写
        System.out.println("abc".equals("abc"));
        System.out.println("abc".equals("ABC"));
        System.out.println("abc".equalsIgnoreCase("ABC"));
    }
}

Stringbuilder类

• 说明

1）StringBuilder是一个可变的字符序列, 也叫字符串缓冲区类
2）Stringbuilder的拼接时间比String耗时更短

• 代码的实现

package cn.liu.c;

public class StringBuilder01 {
    public static void main(String[] args) {
        //添加一个开始时间
        long start = System.currentTimeMillis();

        //method01();
        //method02();

        long end = System.currentTimeMillis();

        System.out.println("耗时（毫秒）为：" + (end - start));



    }

    public static void method02() {
        //创建一个StringBuilder
        StringBuilder sb = new StringBuilder();
        //遍历100
        for (int i = 0; i < 100000; i++) {
            //将遍历的每一个数字都添加到str中
            sb.append(i);

        }
        System.out.println(sb.toString());
    }


    public static void method01() {
        String str = "";
        //遍历100
        for (int i = 0; i < 100000; i++) {
            //将遍历的每一个数字都添加到str中
            str += i;

        }
        System.out.println(str);
    }



}

• stringbuilder 和 string互转

package cn.liu.c;

public class StringBuilder02 {
    public static void main(String[] args) {
        //StringBuilder和String的互相转化

        String str = "abd";
        //放入StringBuilder中
        StringBuilder sb1 = new StringBuilder(str);
        //再将sb1转化为字符串
        String sb2 = sb1.toString();


        System.out.println(sb1);
        System.out.println(sb2);
    }
}

• 数组转字符串

package cn.liu.c;

import java.util.Arrays;

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


        //定义一个数组
        int[] arr = {1,3,5,7};

        //转化为字符串
        String str = Arrays.toString(arr);
        System.out.println(str);

    }
}

• 字符串反转
  reverse方法实现字符串的反转

        System.out.println("请输入您要反转的字符串：");
        String s1 = new Scanner(System.in).nextLine();

        //将字符串转为StringBuilder对象
        StringBuilder sb1 = new StringBuilder(s1);

        //通过reverse方法实现
        String sb2 = sb1.reverse().toString();

        System.out.println(sb2);

数组元素的排序

• 排序的实现方式（Arrays.sort（））

//已知数组int[] arr = {25, 69, 80, 57, 13}, 请编写代码对齐进行升序排序.
//即: 排序后结果为: arr = {13, 25, 57, 69, 80};

import java.util.Arrays;

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

        //定义一个数组
        int[] arr = {25, 69, 80, 57, 13};

        //使用Arrays.sort方法
        Arrays.sort(arr);

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

    }
}

包装类

说明：

1- 基本类型的缺点：
  基本类型无法确定边界值，Java就针对每一种基本类型提供了一个对应的引用类型, 这就是包装类.

2- 
Byte用于byte和String之间的相互转换
Integer用于int和String之间的相互转换
Double用于double和String之间的相互转换

包装类型的相互转化

自动拆装箱

public class Demo02 {
    public static void main(String[] args) {
        Integer j = new Integer(02);

        Integer i = 02;

        int m1 = 10 + 20;
        int m2 = i + 20;
    }
    
}

Date类

说明

1）Date类表示特定的瞬间，精确到毫秒. 它是java.util包下的类, 用之前需要先导包
2)SimpleDateFormat类:用来格式化和解析日期的具体类

代码实现

package cn.liu.c;

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

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

        //创建日期，默认是当前的日期
        Date d1 = new Date();
        System.out.println(d1);
        System.out.println(d1.toLocaleString());

        //毫秒转时间格式
        Date d2 = new Date(1633791019888L);
        System.out.println(d2);

        //转换日期格式
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String str = sdf.format(d2);
        System.out.println(str);

        SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy/MM/dd");
        String str2 = sdf1.format(d2);
        System.out.println(str2);
    }

}

calendar类（日历类）

• 使用方法参考代码

import java.util.Calendar;

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

        //演示calendar的用法

        //调用该方法
        Calendar cal01 = Calendar.getInstance();
        //用当前的时间减两天
        cal01.add(Calendar.DATE, -1);
        System.out.println(cal01);

        System.out.println(cal01.get(Calendar.YEAR));
        System.out.println(cal01.get(Calendar.MARCH) + 1);
        System.out.println(cal01.get(Calendar.DAY_OF_MONTH));
        System.out.println(cal01.get(Calendar.HOUR_OF_DAY));
        System.out.println(cal01.get(Calendar.MINUTE));
        System.out.println(cal01.get(Calendar.SECOND));

    }
}

• 获取2月份的天数

package cn.liu.c;

import java.util.Calendar;

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

        //获取2月份对应的天数
        int year = 2021;
        Calendar c1 = Calendar.getInstance();

        //获取3月1日
        c1.set(year, 2, 1);

        //3月1日减1就是2月份对应的天数
        c1.add(Calendar.DATE, -1);

        System.out.println(c1.get(Calendar.DAY_OF_MONTH));

    }
}

异常的处理

• 第一种处理异常的方式

 SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        
        try {
            Date d1 = sdf.parse(str); // 报错了, 需要立刻处理这个异常
        } catch (ParseException e) {
            e.printStackTrace();
        } finally {
        }

• 第二种直接抛给父类