api开发安全架构 java java的api结构

转载

ghpsyn 2023-07-05 12:57:56

文章标签 api开发安全架构 java java System 字符串 文章分类 架构后端开发

Java的常用工具——API

Object类

成员方法
JavaBean类重写Object类的方法

Scanner类
String类

判断功能
获取功能
转换功能

StringBuffer类与StringBuilder类
Date类
Calendar类

API（Application Programming Interface，应用程序接口）是一些预先定义的函数，或指软件系统不同组成部分衔接的约定。目的是提供应用程序与开发人员基于某软件或硬件得以访问一组例程的能力，而又无需访问原码，或理解内部工作机制的细节。
点击查看API文档

Object类

类层次结构最顶层的基类，所有类都直接或间接的继承自Object类，所以，所有的类都是一个Object（对象）。

成员方法

int hashCode()；
返回对象的哈希码值，该方法通过对象的地址值进行计算，不同对象的返回值一般不同
Class <?> getClass()；
返回调用此方法对象的运行时类对象（调用者的字节码文件对象）
String toString()；
返回该对象的字符串表示
boolean equals()；
返回其他某个对象是否与此对象“相等”。默认情况下比较两个对象的引用，建议重写

package demo4;

public class Test {
    public static void main(String[] args) {
        //1.创建Object类型的对象
        Object obj1 = new Object();
        Object obj2 = new Object();

        //2.测试Object类中的成员方法
        //int hashCode();   返回对象的哈希码值,不同对象的哈希码值一般不同
        int code1 = obj1.hashCode();
        int code2 = obj2.hashCode();
        System.out.println(code1);
        System.out.println(code2);
        System.out.println("------------------------------");

        //Class<?> getClass();  返回该调用者的字节码文件对象，一个类只有一个字节码文件对象
        Class clazz1 = obj1.getClass();
        Class clazz2 = obj2.getClass();
        System.out.println(clazz1);
        System.out.println(clazz2);
        System.out.println("------------------------------");

        //String toString();    返回该对象的字符串表示形式,默认打印的是地址值
        //                      地址值的组成：全类名 + @ + 该对象的哈希码的无符号十六进制形式
        String s1 = obj1.toString();
        String s2 = obj2.toString();
        System.out.println(s1);
        System.out.println(s2);
        System.out.println("------------------------------");

        //boolean equals();     比较两个对象是否相等,默认比较的是地址值，子类一般会重写
        boolean b1 = obj1.equals(obj2);
        System.out.println(b1);
    }
}

运行结果：

1607521710
764977973
------------------------------
class java.lang.Object
class java.lang.Object
------------------------------
java.lang.Object@5fd0d5ae
java.lang.Object@2d98a335
------------------------------
false

JavaBean类重写Object类的方法

package demo5;

import java.util.Objects;

//学生类
public class Student {
    //成员变量
    private int age;
    private String name;
    private int score;

    //构造方法
    public Student() {
    }

    public Student(int age, String name, int score) {
        this.age = age;
        this.name = name;
        this.score = score;
    }

    //成员方法
    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public int getScore() {
        return score;
    }

    public void setScore(int score) {
        this.score = score;
    }
   
	
	 //toString();原来将对象转成其对应的字符串形式

    @Override
    public String toString() {
        return "Student{" +
                "age=" + age +
                ", name='" + name + '\'' +
                ", score=" + score +
                '}';
    }


    //equals（）；用来比较两个对象是否相同


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

测试类：

package demo5;

public class Test {
    public static void main(String[] args) {
        //测试toString（）方法
        //创建学生类的对象
        Student s1 = new Student(1,"PAG",66);
        //输出语句直接打印对象，默认调用了该对象的toString（）方法
        System.out.println(s1);
        System.out.println(s1.toString());
        System.out.println("----------------------");


        //测试equals（）方法
        Student s2 = new Student(10,"PAG",66);
        boolean b1 = s1.equals(s2);
        System.out.println(b1);
    }
}

运行结果：

Student{age=1, name='PAG', score=66}
Student{age=1, name='PAG', score=66}
----------------------
false

Scanner类

( 在实际开发中，接收整数通常用nextInt(); ，接收字符串通常用nextLine(); )

package demo6;

import java.util.Scanner;

public class Test {
    public static void main(String[] args) {
        //创建Scanner类型的对象
        //System.in；标准的输入流，默认指向键盘
        Scanner sc = new Scanner(System.in);

        //接收整数
        System.out.println("请输入一个整数");
        //为了避免InputMismatchException错误，可以加一个判断
        if(sc.hasNextInt()) {
            int num = sc.nextInt();
            System.out.println("num:" + num);
        }

        //接收字符串类型的数据
        System.out.println("请输入一个字符串");
       /* String str1 = sc.nextLine(); //结束标记：换行符
        System.out.println("str1:" + str1);*/

       String str2 = sc.next();         //结束标记：空白字符（空格，TAB，换行符）
        System.out.println("str2:" + str2);
    }
}

String类

判断功能

boolean equals(String);
判断当前字符串与给定字符串是否相同，区分大小写
boolean equalsIgnoreCase(String);
判断当前字符串与给定字符串是否相同，不区分大小写
boolean startsWith(String);
判断是否以给定字符串开头
boolean isEmpty();
判断是否字符串是否为空

package demo6;

import java.util.Scanner;

public class Test {
    public static void main(String[] args) {
        //测试 构造方法
        //1.将指定的字节数组转成字符串
        //‘a’：97
        byte[] byt = {97,98,99};
        String s1 = new String(byt);
        System.out.println("s1:" + s1);

        //2.将指定的字符数数组转成字符串
        char[] cha = {'h','e','l','l','o'};
        String s2 = new String(cha);
        System.out.println("s2：" + s2);

        //3.免new
        String s3 = "abc";
        System.out.println("s3:" + s3);
        System.out.println("----------------------");


        //测试成员方法
        String str1 = "abc";
        String str2 = "ABC";
        //boolean equals(String);           判断当前字符串与给定字符串是否相同，区分大小写
        boolean b1 = str1.equals(str2);
        System.out.println("b1:" + b1);
        //boolean equalsIgnoreCase(String);  判断当前字符串与给定字符串是否相同，不区分大小写
        boolean b2 = str1.equalsIgnoreCase(str2);
        System.out.println("b2:" + b2);
        //boolean startsWith(String);         判断是否以给定字符串开头
        boolean b3 = str1.startsWith("a");
        System.out.println("b3:" + b3);
        //boolean isEmpty();                  判断是否字符串是否为空
        String str3 = "";
        boolean b4 = str3.isEmpty();
        System.out.println("b4:" + b4);
    }
}

运行结果：

s1:abc
s2：hello
s3:abc
----------------------
b1:false
b2:true
b3:true
b4:true

获取功能

int length();
获取当前字符串的长度
char charAt(int index);
获取指定索引位置的字符
int indexOf(String);
获取指定字符（串）第一次出现的索引
int lastIndexOf(String);
获取指定字符（串）最后一次出现的索引
String substring(int);
获取指定索引位置（含）之后的字符串
String substring(int ,int)
获取从索引start位置（含）到end位置（不含）的字符串

package demo6;

import java.util.Scanner;

public class Test {
    public static void main(String[] args) {
        //定义一个字符串
        String str = "java PAG";

        //int length();         获取当前字符串的长度
        int length = str.length();
        System.out.println("length:" + length);
        System.out.println(str.length());
        System.out.println("----------------------------");

        //char charAt(int index);   获取指定索引位置的字符
        char ch = str.charAt(1);
        System.out.println(ch);
        System.out.println("----------------------------");

        //int indexOf(String);      获取指定字符（串）第一次出现的索引
        int i1 = str.indexOf("j");
        System.out.println("i1:" + i1);
        System.out.println("----------------------------");

        //int lastIndexOf(String);   获取指定字符（串）最后一次出现的索引
        int i2 = str.lastIndexOf("a");
        System.out.println("i2:" + i2);
        System.out.println("----------------------------");

        //String substring(int)      获取指定索引位置（含）之后的字符串
        String str1 = str.substring(3);
        System.out.println("str1:" + str1);
        System.out.println("----------------------------");

        //String substring(int ,int)    获取从索引start位置（含）到end位置（不含）的字符串
        String str2 = str.substring(3,8);
        System.out.println("str2:" + str2);
    }
}

运行结果：

length:8
8
----------------------------
a
----------------------------
i1:0
----------------------------
i2:3
----------------------------
str1:a PAG
----------------------------
str2:a PAG

转换功能

byte[] getBytes();
将字符串转换成字节数组
char[] toCharArray();
将字符串转换字符数组
static String valueOf();
将指定类型数据转换成字符串
String replace(old,new);
将指定字符（串）替换成新的字符（串）
String[] spilt(String);
切割字符串，返回切割后的字符串数据，原字符串不变
String trim();
去掉字符串两端的空白字符

package demo6;

import java.util.Scanner;

public class Test {
    public static void main(String[] args) {
        //定义一个字符串
        String s1 = "abc";

        //byte[] getBytes();             将字符串转换成字节数组
        byte[] byt = s1.getBytes();     //97.98.99
        for (int i = 0; i < byt.length ; i++) {
            System.out.println(byt[i]);
        }
        System.out.println("----------------------------");

        //char[] toCharArray();          将字符串转换字符数组
        char[] cha = s1.toCharArray();  //'a','b','c'
        for (int i = 0; i < cha.length ; i++) {
            System.out.println(cha[i]);
        }
        System.out.println("----------------------------");

        //static String valueOf();       将指定类型数据转换成字符串
        //整数123 ---> 字符串"123"
        String s2 = String.valueOf(123);
        System.out.println(s2 + 4);

//        可以将上面的代码换成一下的,答案相同
        String s3 = "" + 123;
        System.out.println(s3 + 4);
        System.out.println("----------------------------");

        //String replace(old,new);      将指定字符（串）替换成新的字符（串）
        String s4 = "abc abc abc";
        String s5 = s4.replace("b","d");
        System.out.println("s5:" + s5);
        System.out.println("----------------------------");

        //String[] spilt(String);        切割字符串，返回切割后的字符串数据，原字符串不变
        String [] arr = s4.split(" ");
        for (int i = 0; i < arr.length ; i++) {
            System.out.println(arr[i]);
        }
        System.out.println("----------------------------");

        //String trim();             去掉字符串两端的空白字符
        String s6 = " abc ";
        String s7 = s6.trim();
        System.out.println("s6:" + s6);
        System.out.println("s7:" + s7);
    }
}

运行结果：

97
98
99
----------------------------
a
b
c
----------------------------
1234
1234
----------------------------
s5:adc adc adc
----------------------------
abc
abc
abc
----------------------------
s6: abc 
s7:abc

StringBuffer类与StringBuilder类

StringBuilder append();
将任意数据添加到StringBuilder容器中，返回自身
String toString();
将当前StringBuilder容器转成字符串

package demo6;

import java.util.Scanner;

public class Test {
    public static void main(String[] args) {
        //测试构造方法
        //测试空参构造
        StringBuilder sb = new StringBuilder();     //构造一个空的StringBuilder容器
        //StringBuilder append(); 将任意数据添加到StringBuilder容器中，返回自身
        StringBuilder sb2 = sb.append("abc");
        System.out.println("sb:" + sb);
        System.out.println("sb2:" + sb2);
        System.out.println("----------------------------");
        //将String类型的“abc”转成StringBuilder类型的对象
        StringBuilder sb3 = new StringBuilder("abc");
        System.out.println("sb3:" + sb3);
        System.out.println("----------------------------");

        //测试成员方法
        //将三个字符串拼接成一个新的字符串
        StringBuilder sb4 = new StringBuilder();
        sb4.append("我");
        sb4.append("是");
        sb4.append("PAG");
        System.out.println("sb4:" + sb4);
        System.out.println("----------------------------");
        //String toString();     将当前StringBuilder容器转成字符串
        String a = sb4.toString();
        System.out.println("字符串a:" + a);
    }
}

运行结果：

sb:abc
sb2:abc
----------------------------
sb3:abc
----------------------------
sb4:我是PAG
----------------------------
字符串a:我是PAG

Date类

Date();
构造一个日期对象，当前系统时间，精确到毫秒
long getTime();
将日期对象转换成对应时间的毫秒值
Date(long);
构造一个日期对象，时间为自“1970年1月1日00：00：00 GMT”起，至指定参数的毫秒数

package demo6;

import java.util.Date;
import java.util.Scanner;

public class Test {
    public static void main(String[] args) {
        //测试Date类
        //测试空参构造，采用当前操作系统的默认时间
        //Date();            构造一个日期对象，当前系统时间，精确到毫秒

        Date date1 = new Date();
        System.out.println("date1:" + date1);

        //long getTime();   将日期对象转换成对应时间的毫秒值

        //获取当前操作系统时间的毫秒值
        long time = date1.getTime();
        System.out.println("time:" + time);

        //Date(long);       构造一个日期对象，时间为自“1970年1月1日00：00：00 GMT”起，至指定参数的毫秒数

        //Tue Feb 25 21:54:13 CST 2020 = 1582638853108
        //创建一个指定的时间
        Date date2 =new Date(1582638853108L);
        System.out.println("date2:" + date2);

    }
}

运行结果：

date1:Tue Feb 25 22:15:51 CST 2020
time:1582640151256
date2:Tue Feb 25 21:54:13 CST 2020

Calendar类

static Calendar getInstance();
根据当前系统时区和语言环境获取日历对象
int get(int field);
返回给定日历字段的值
void set(int field , int value);
将给定的日历字段设置为指定的值

package demo6;

import java.util.Calendar;

public class Test2 {
    public static void main(String[] args) {
        //测试Calender
        //static Calendar getInstance();    根据当前系统时区和语言环境获取日历对象
        Calendar c = Calendar.getInstance();
        System.out.println(c);

        //获取年月日的信息
        //int get(int field);               返回给定日历字段的值
        int year = c.get(Calendar.YEAR);
        int month = c.get(Calendar.MONTH);  //Java中使用0-11的数字表示月份，对应1-12月
        int day = c.get(Calendar.DATE);
        System.out.println(year + "年" +(month + 1) +"月" + day + "日");
        System.out.println("----------------------------------");

        //void set(int field , int value);      将给定的日历字段设置为指定的值
        //设置指定时间为：2222年2月2日
        c.set(2222,1,2);
        int year2 = c.get(Calendar.YEAR);
        int month2 = c.get(Calendar.MONTH);
        int day2 = c.get(Calendar.DATE);
        System.out.println(year2 + "年" +(month2 + 1) +"月" + day2 + "日");
    }
}

运行结果：

java.util.GregorianCalendar[time=1582640175978,areFieldsSet=true,areAllFieldsSet=true,lenient=true,zone=sun.util.calendar.ZoneInfo[id="Asia/Shanghai",offset=28800000,dstSavings=0,useDaylight=false,transitions=29,lastRule=null],firstDayOfWeek=1,minimalDaysInFirstWeek=1,ERA=1,YEAR=2020,MONTH=1,WEEK_OF_YEAR=9,WEEK_OF_MONTH=5,DAY_OF_MONTH=25,DAY_OF_YEAR=56,DAY_OF_WEEK=3,DAY_OF_WEEK_IN_MONTH=4,AM_PM=1,HOUR=10,HOUR_OF_DAY=22,MINUTE=16,SECOND=15,MILLISECOND=978,ZONE_OFFSET=28800000,DST_OFFSET=0]
2020年2月25日
----------------------------------
2222年2月2日

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。