API以及常用类

API概述

API：应用程序编程接口（java语言中实际提供的接口和类）;

API文档：对java中提供的类和接口中的功能进行说明的文档，木目的是为开发人员提供使用说明。

API：java语言中实际提供的类和接口；

API文档：对java语言中提供的类或者接口进行说明的文档。

Object类

​ Object类是所有java类的根基类(所有的类从源头上都继承了Object类)。

Object类只有无参构造。

Object类中的一些常用方法：

toString：返回string字符串，以字符串的形式描述一个对象的相关信息，如果直接输出一个对象时就默认调用了tostring方法。

equals： public boolean equals(Object obj)方法，判断对象是否相等。 X.equals（y），的意思是如果X和y表示同一个对象时返回true，否则返回false（即就是判断两个对象的地址是不是相同的）。在许多时候我们需要比较的是内容而非地址，所以在多数类中都会重写equals方法，使其比较内容。如 String类中的equals类，A.equals（B），表示只要A和B的内容相同时返回true，否则返回false。

Object 中的 toString(){
                                 
    getClass().getName() + "@" + Integer.toHexString(hashCode())
}

Arrays类

Arrays类是在java.util.Arrays包中；主要用于对数组的操作。

Arrays类中常用的方法：

equals()：比较两个非同一数组内容是否相等。

sort()：作用将数组从小到大排序，可以使用类名直接调用。

binarySearch()：使用二分法在指定数组数组中查找关键词，如果指定关键词在数组中，则返回搜索值的索引；否则返回-1或者”-“(插入点)。

toString()：重写object泪中的方法，以字符串的形式返回指定数组内容。

public class ArraysDemo {
    public static void main(String[] args) {
        int[] a ={4,6,5,9,7,8};
        int[] b ={4,6,5,9,7,8};
        System.out.println(Arrays.equals(a, b));//true
        Arrays.sort(a, 1, 4);//将a数组中的[1,4)区间的数组从小到大排序
        Arrays.sort(a);//将a整体从小到大排序
        System.out.println(Arrays.binarySearch(a,8));//4,因为binarySearch使用的是二分法查找,所以在查找前需要为其进行排序.
        System.out.println(Arrays.toString(a));//[4, 5, 6, 7, 8, 9]
    }
}

自定义对象排序

//自定义类实现Comparable类
public class person implements Comparable<person> {
    String name;
    String sex;
    int age;
    
    //重写comparaTo方法
    @Override
    public int compareTo(person o) {
        return this.age-o.age;//以从小到大排序.
    }
}

equals()与==的区别

equals()和==都是比较是否相等的但是存在着一定的区别。

==用于基本数据类型时，比较的是值是否相等；

==用于引用类型时，比较的是引用地址是否相等；

多数类中会重写equals方法，一般会默认equals是比较内容的。

public class EqualsDemo {
    public static void main(String[] args) {
        int [] a ={1,4,8,5,2,4,5};
        int [] b ={1,4,8,5,2,4,5};
        System.out.println(Arrays.equals(a, b));//true,Arrays类重写了equals方法
        String al = "sss";
        String dd = "sss";
        System.out.println(al==dd);//true
        System.out.println(al.equals(dd));//true
        String g = new String("jei");
        String f = new String("jei");
        System.out.println(f==g);//false,凡是new 出来的,在内存空间中是独一无二的,比较的是地址是否相同.
        System.out.println(f.equals(g));//true
    }

}

String类

​ String是比较常见的一个类，在刚开始的数据类型中就提到string是一个引用类型表示字符串。其实在String类中还是将字符串储存在一个用final修饰的字符数组中的，所以string一旦创建，就不可以改变。其中的值改变一次就会创建一个新的string对象，将新创建的对象赋给对应的变量。

String有两种创建形式:

1. String str = “abc”;
   这种直接赋值的创建形式是先在栈中创建一个对String类的对象引用变量s，然后去字符串常量池中查找有没有"abc", 如果没有则在常量池中添加”abc”, s引用变量指向常量池中的”abc”，如果常量池中有,则直接指向已有的地址即可,不用重新在常量池中创建。

2. String str = new String(“abc”);

   这种通过构造方法赋值的创建形式是现在堆中创建对象，将值存储在堆内存的对象中。

String类中的方法

构造方法：

public String()：创建一个空的字符串对象
public String(String str)：字符串参数
public String(byte[] bytes)：编码
public String(char[] value）

判断功能的方法：

boolean equals(Object obj)：判断指定对象的内容是不是与obj内容相同，相同返回true，否则返回false；

boolean equalsIgnoreCase(String str)：忽略大小写，比较内容是否相等；

boolean contains(String str)：判断是否包含指定字符串；

boolean isEmpty()：判断是不是空字符串（""）；

boolean startsWith(String prefix)：判断该字符串是不是以prefix开头的;

boolean endsWith(String suffix)：判断该字符串是不是以suffix结尾的；

public class StringDemo {

    public static void main(String[] args) {
       
        /*
        String s1 = new String();源码如下:
        
        public String(String original) {
        		this.value = original.value;
        		this.hash = original.hash;
    }
    */
       String s2 = new String("abc");

        /*
           判断功能方法
         */

        String s1 = "abc";
        String s2 = new String("abC");
        System.out.println(s1.equals(s2));//比较字符串内容是否相等
        System.out.println(s1.equalsIgnoreCase(s2));//比较字符串内容是否相等(忽略大小写)

        System.out.println(s1.contains("c"));//是否包含指定的子串
        System.out.println(s1.isEmpty());//判断是否为""
        System.out.println(s1.startsWith("ab"));//判断以指定字符串开头
        System.out.println(s1.endsWith("bc"));//判断以指定字符串结尾

        String s3 = "abc";
        String s4 = "efg";
        System.out.println(s3.compareTo(s4));//字符串比大小
    }
}

获取功能的方法：

int length()：返回一个int值，表示字符串的长度；

char charAt(int index)：返回一个char类型的值，索引index位置处的值；

int indexOf(String str)：返回一个数字，表示str在该字符串中首次出现的位置；

int lastIndexOf(String str)：返回一个数，表示从后往前找首次str出现的位置；

int indexOf(String str,int fromIndex)：返回一个数字，表示从该字符串的fromIndex位置开始向后检索该字符串中str首次出现的位置；

String substring(int start)：返回一个字符串，表示从start位置输出原字符串；

String substring(int start,int end）：返回一个字符串，表示从start位置开始到end位置输出原字符串；

public class StringDemo {

    public static void main(String[] args) {
       
        String s1 = "abcdefg";
        //只要是返回一个string类型的数据,都是一个新的字符串.
        System.out.println(str.length());//7
        System.out.println(str.charAt(1));//b 返回str中索引为一的值
        System.out.println(str.indexOf("b"));//1  返回第一次出现b的索引
        System.out.println(str.indexOf("b",3));//-1表示不在范围内
        System.out.println(str.substring(3));//defg  返回从3以后的内容
        System.out.println(str.substring(2,5));//cde  返回[2,5)的内容.
        
    }
}

转换功能的方法:

byte[] getBytes()：转换成字节数
char[] toCharArray()：将字符串转换成一个新的字符数组
static String valueOf(char[] chs)：将一个字符数组转换成一个字符串(形参基本类型)
String toLowerCase()：将字符串中的字母全都转换为小写
String toUpperCase()：将字符串中的字母全都转换为大写
String concat(String str)：将str链接在原字符串后
Stirng[] split(“分割符”)：返回的是一个字符串数组，按照 分割符 将原来的字符串拆分为数组

public class StringDemo1{
    String s = "你好";     //字符集
    byte[] byt = s.getBytes("UTF-8");//将字符串按照UTF-8编码转换成字节数
    String str = new String(byt);//将字节数转换为字符串
    String str1 = new String(byt,"UTF-8");//将字节数按照UTF-8字符集转换成字符数组.
    char[] chars = s.toCharArrays();//将字符串s转换成一个新的字符数组
    String s = "dhghKJIGYU";
    System.out.println(s.toLowerCase());//dhghkjigyu  转小写
    System.out.println(s.toUpperCase());//DHGHKJIGYU  转大写
    System.out.println(s.concat("auifa"));//dhghKJIGYUauifa  链接 
    //与 string+的区别
    String d = s+5;//是允许的  dhghKJIGYU5
    //System.out.println(s.concat(5));//不允许的  concat("字符串")
}

regex正则表达式

regex:使用一些特殊的符号来表示有一个特定的规则，并用这个规则去判断一个字符串是否与之匹配，匹配成功返回true，否则返回false。

//定义一个规则
Pattern p  =  Pattern.compile("regex");//使用Patter,其中的regex就是一个规则
Matcher m = p.matcher("aga");//输入内容"aga"
System.out.println(m.matches());//输出是否匹配,是返回true,否则返回false

//String类中的matcher 同样可以定义一个规则
String str1 = "85962";
         // 注: \t等是有其他意义的,所以在规则定义中使用双反斜杠"\\".
        System.out.println(str1.matches("\\d"));//判断是不是一个数字
        System.out.println(str1.matches("\\d?"));//"X?"判断是不是一个数字,或者一个也没有
        System.out.println(str1.matches("\\d+"));//"X+"判断是不是一次或者多次
        System.out.println(str1.matches("\\d*"));//"X*"判断是不是零次或者多次
        System.out.println(str1.matches("\\d{5}"));//"X{a}"判断是不是恰好a次
        System.out.println(str1.matches("\\d{5,}"));//"X{a,}"判断是不是5次以上
        System.out.println(str1.matches("[A-Za-z]"));//判断是不是大小写字母
//案例:验证手机号
String phone = "15145123256";
        System.out.println(phone.matches("1[3578]\\d{9}"));
//邮箱账号检验
        String email = "we8594886@162.com";
        System.out.println(email.matches("\\w{6,12}@\\w{2,5}\\.(com|com.cn)"));

/*
\w:单词字符,[a-zA-Z_0-9];
\W:(大写的W),非单词字符,表示[^\w];

替换功能的方法

String replace(char old,char new)
String replace(String old,String new)
replaceAll(String regex, String replacement)
replaceFirst(String regex, String replacement)

public class StringDemo1 {
    public static void main(String[] args) {
        String str8 = new String("iggh");
        String str = " aso dfghjo kl ";
        String str2 = str.replace("o","HH");//用指定字符替换原来字符串中的指定字符串(全部替换)
        System.out.println(str);
        System.out.println(str2);
        /*
        replace和replaceAll用法相同,区别在于二者的参数不同
        replaceAll的参数是regex是一个正则表达式,是一种模式匹配,替换某一类
        */
        String str3 = str.replaceAll("\\s", "");//替换某一类 \\s表示空白字符
        System.out.println(str3);
         System.out.println(str.replaceFirst("\\s","W"));//只替换第一次出现的
        String str4 = str.trim();//去除前后两端的空格
        System.out.println(str4);
        System.out.println(str.equalsIgnoreCase("el"));
    }

}