JavaSE基础--API_常用类1

API_常用类1

1.JavaAPI概述

API(Application Programming Interface)应用程序编程接口。

​ 1.api文档

：是对java预先定义的类或接口功能和方法的说明文档，目的是提供给开发人员进行使用帮助说明。

2.基本数据类型包装类

Java语言是一个面向对象的语言，但是Java中的基本数据类型却是不面向对象的，这在实际使用时存在的不便，为了解决这个不足，在设计类时为每个基本数据类型设计了一个对应的类进行代表，这样八个和基本数据类型对应的系统称为包装类。

包装类：类封装了一个相应的基本数据类型数值，并为其提供了一系列操作。

基本数据类型	包装类
byte	Byte
short	Short
char	Character
int	Integer
long	Long
float	Float
double	Double
boolean	Boolean

对于包装类说，这些类的用途主要包含两种：
1.作为和基本数据类型对应的类类型存在，方便涉及到对象的操作。

2.包含每种基本数据类型的相关属性如最大值、最小值等，以及相关的操作方法。

1.包装类常见方法

以下方法以java.lang.Integer为例：

//测试Integer类的一些方法
System.out.println(a.byteValue());//返回封装类型数据的int型值
System.out.println(Integer.BYTES);//得到该基本类型的字节数
System.out.println(Integer.MAX_VALUE);//得到该基本类型取值范围的最大值
 System.out.println(Integer.MIN_VALUE);//得到该基本类型取值范围的最小值
System.out.println(Integer.SIZE);//得到该基本类型的位数
System.out.println(Integer.TYPE);//得到该包装类的基本类型

2.使用Integer类需要注意范围

使用时，如果输入的参数在一个byte内(-128-127),那么你所创建的变量指向的就是同一个对象；如果超出这个范围，那么就会创建两个对象。

装箱与拆箱(Auto-boxing/unboxing)

装箱：自动装箱时自动将基本数据类型转换为包装类型；装箱时调用的是value(int)方法。

拆箱：自动拆箱是自动将包装类型转换为基本数据类型，拆箱时所调用的时intValue()方法。

3.Object类

Java中所有的类，如果自身没有显式的继承其他类，会默认继承Object类。

1.tostring方法

​ 在Object类中定义了public string tostring()方法，其返回值是String类型，会返回一组哈希值，因此一般在使用的时候需要重写。

2.equals方法

​ 在Object类中定义了public boolean equals(Object obj)方法，判断对象是否是同一个对象的逻辑。

​ equals方法的定义是：x.equals(y)当x与y指向同一个对象时返回true,否则返回false。

​ 在JDK中提供了一些类，例如String，Data等重写了Object中的equals方法，调用它们的equals方法时，当x和y的内容相等时，返回true，否则返回false。

public class Test1 {
    public static void main(String[] args) {
        Second p1=new Second("aaa","bbb");
        Second p2 = new Second("aaa","bbb");
        System.out.println(p1.equals(p2));//Object中的默认equal方法是比较地址，需要重写
    }
}

public class Person {
    int age;
    String name;

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

    @Override
    public String toString() {
        return "Person{" +
                "年龄=" + age +
                ", 姓名='" + name + '\'' +
                '}';
    }

}

public class Test {
    public static void main(String[] args) {
        Person p1= new Person(10,"abc");
        Person p2=new Person(10,"acc");

        System.out.println(p1);
        System.out.println(p2);
    }
}

4.Arrays类

用于操作数组的工具类，里面定义常见操作数组的静态方法。

4.1 equals

最初在Object类中，形式"=="，比较的是对象是否相同

现在调用的Array.equals(a,b)是Array类重写之后的，比较的是对象中的内容。

相等返回true,否则为false。

public class Demo {
    public static void main(String[] args) {
        int [] a = {1,2,3};
        int [] b = {1,2,3};
        System.out.println(Arrays.equals(a,b));
    }
}

---

4.2 sort

1.简单排序

在底层使用的其实是快速排序

Arrays.sort(a)；升序,Arrays类只有升序方法，想要降序的话，可以升序后在倒序输出，或者如果相使用降序的数组，那就在程序中新建一个数组接收倒序之后的旧数组就可以。

Arrays.sort(a,fromIndex(包括),toIndex(不包括));分段排序。

Integer [] integer = {1,2,3,4,5}

Arrays.sort(integer);引用类型可以排序

public class Demo {
    public static void main(String[] args) {
        int [] c = {5,8,5,3,4,46,2,1,20,0};
        Arrays.sort(c);
        System.out.println(Arrays.toString(c));
        //如果是字符串，sort默认按照字母升序
		String [] str = {"10","2","5","1};
        Arrays.sort(str);
        System.out.println(Arrays.toString(str));
     }
}

4.3自定义排序

sort(List,list,Comparator c);根据指定比较器产生的顺序对指定列表进行排序，也就是自定义排序，第一个参数是传入的是排序的列表，第二个参数是指定的比较器。

int compare(Object o1,Object o2)返回一个基本类型的整型。

如果要按照升序排序:

则o1小于o2,返回-1(负数),相等返回0,o1大于o2返回1(正数).

如果要按照降序排序：

则o1小于o2,返回1(正数),相等返回0，o1大于o2返回-1(负数).

public class Demo {
    public static void main(String[] args) {
        Student s1 = new Student("A",80,100);
        Student s2 = new Student("M",90,75);
        Student s3 = new Student("F",85,80);
        Student[] students = new  Student[3];
        students[0]=s1;
        students[1]=s2;
        students[2]=s3;
        Arrays.sort(students);
        System.out.println(Arrays.toString(students));
    }
}
//排序类
public class Student  implements Comparable<Student>{
    private String name;
    private int sjscore;
    private int bsscore;
    public Student(){}
    
    @Override
    public String toString() {
        return "{" +
                "姓名='" + name + '\'' +
                ", 上机成绩=" + sjscore +
                ", 笔试成绩=" + bsscore +
                '}';
    }

    public String getName() {
        return name;
    }

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

    public int getSjscore() {
        return sjscore;
    }

    public void setSjscore(int sjscore) {
        this.sjscore = sjscore;
    }

    public int getBsscore() {
        return bsscore;
    }

    public void setBsscore(int bsscore) {
        this.bsscore = bsscore;
    }

    @Override
    public int compareTo(Student o) {
        //return this.bsscore-o.bsscore;
        //return this.sjscore-o.sjscore;通过数字排序
        return  this.name.compareTo(o.name);//通过名字排序
    }

}

4.3 二分搜索

使用二分搜索查找指定范围(前提:有序数组)

binarySearch(type [] a,type key);在指定数组中搜索指定元素。

binarySearch(type [] a,fromIndex(包括)，toIndex(不包括),type key);在指定区间查找。

如果找到了，返回索引值。

如果没找到，返回一个负数。

public class Demo {
    public static void main(String[] args) {
        int [] array1 = {5,4,2,38,9,1,42,0};
        Arrays.sort(array1);//二分搜索数组的元素要是有序的
        System.out.println(Arrays.binarySearch(array1,9));
    }
}

5.String类

Java中所有的字符串，都是String类的对象。

值一旦给定不能改变，一旦修改，会重新创建一个对象。

1.两种创建方式

1.String s = “abc”；

2.String s = new String("abc“);

2.构造方法

public class Demo1 {
    public static void main(String[] args) throws UnsupportedEncodingException {
        String s0 = new String();
        System.out.println(s0);// 调用无参构造方法，将value值赋给char，转为一个空格字符

        String  s1 = new String("123");//将指定字符赋给value
        System.out.println(s1);

        char[] s2 = {'a','b','c'};
        String s3 = new String(s2);//将char类型数组转为字符串
        System.out.println(s3);

        String s4 = "abc";
        byte [] b0 = s4.getBytes();// 将字符串转换为字节数组，这个过程称作编码
        byte [] b1 = s4.getBytes("utf-8");// 指定编码表编码，使用这个的时候需要抛出异常
        new String(b0);// 把看不懂的byte数组转为字符， 叫做解码
        new String(b1,"utf-8");// 指定编码表解码
        new String(b1,0,3,"utf-8");// 指定编码长度
    }
}

3.判断功能

public class test1 {
    public static void main(String[] args) {
        String str = "afkmasdk";
                    //01234567
        //判断功能
        System.out.println(str.isEmpty());//判断字符是否为空
        System.out.println(str.contains("abc"));//判断字符串是否有指定的字符串，无则false。
        System.out.println(str.startsWith("a"));//判断字符串是否以指定字符开头
        System.out.println(str.endsWith("k"));//判断字符串是否以指定字符结束
        System.out.println(str.equalsIgnoreCase("scs"));//判断字符串是否与指定字符串一致
    }
}

4.获取功能

public class test1 {
    public static void main(String[] args) {
        String str = "afkmasdk";
                    //01234567
        //获取功能
        System.out.println(str.length());//查询字符串的长度
        System.out.println(str.charAt(3));//根据下标查找字符
        System.out.println(str.indexOf("m"));//返回指定字符第一次出现的字符串内的位置
        System.out.println(str.indexOf("a",3));
        //返回指定字符第一次出现的字符串内的索引，以指定的索引开始搜索。
        System.out.println(str.substring(5));//返回一个字符串，该字符串是此字符串的子字符串。
        System.out.println(str.substring(2,5));
        //返回一个字符串，该字符串是此字符串的子字符串。
    }
}

5.替换功能

public class StringDemo4 {
    public static void main(String[] args) {
        String s0 = "abcdefghik";
        System.out.println(s0.replace("c","C"));// 替换，前面是被替换的
        String s1 = " abcd ";
        System.out.println(s1.length());// 长度为7，前面有三个空格
        int a = s1.trim().length();// trim方法可以消除空格，但是不能消除中间的空格。
                                // 并且这是一个链式调用，得到的是消除空格之后的新字符串的长度
        System.out.println(a);
    }
}

6.替换功能

String replace(char old,char new)//替换

String replace(String old,String new)

replaceAll(String regex, String replacement)//将所有的指定字符换成给定字符

replaceFirst(String regex, String replacement)//将字符串中的与给定字符相同的第一个字符替换

String trim()//去除空格,不能去除中间的空格

6.StringBuffer类/StringBuilder类

Stringbuffer类功能和StringBuild功能完全一致。但是StringBuilder不是多线程安全。

6.1构造方法

public StringBuffer()

public StringBuffer(String str)

6.2添加功能

public StringBuffer append(String str)

public StringBuffer insert(int offset,String str)

6.3删除功能

public StringBuffer deleteCharAt(int index)

public StringBuffer delete(int start,String str)

6.4替换功能

public StringBuffer replace(int start,int end,String str)

6.5翻转功能

public StringBuffer reverse()

6.6截取功能

public StringBuffer substring(int start)

public String substring(int start,int end)

截取功能和前面几个功能的不同，返回值类型是String类型，本身没有发生变化

public class Demo3 {
    public static void main(String[] args) {
        String str = "";
        StringBuffer a = new StringBuffer("acdcasx");
       // System.out.println(a.append("abc"));将指定的字符串添加到a序列
        //a.insert(3,"A"); 把指定位置的字符改为指定字符
        //a.deleteCharAt(3);删除指定位置的字符
        ///a.delete(2,5);删除指定长度的字符串
        //a.replace(2,5,"A");替换指定长度的字符位指定字符
        //a.reverse();反转功能
        str=a.substring(2,5);//截取指定位置的字符串，创建新的对象，原对象不变。
        System.out.println(str);
    }
}

String类、StringBuffer类和StringBuffer的区别

String:是字符常量，适用于少量的字符串操作的情况

StringBuilder:适用于单线程下在字符缓冲区进行大量操作的情况

StringBuffer:适用多线程下在字符缓冲区进行大量操作的情况