JavaSE基础语法--傻瓜笔记--1103(第五章:API_常用类1)

第五章：API_常用类1

1.JavaAPI概述

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

1. api文档

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

2.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，Date等重写了Object中的equals方法，调用它们的equals方法时，当x和y的内容相等时，返回true，否则返回false。

代码：

/*
* Object类
* toString方法
* equals方法
* */
public class ObjectDemo {
    public static void main(String[] args) {
        Person person = new Person("袁永豪", 21);
        System.out.println(person);

        String s1 = new String("123");
        String s2 = new String("123");

        System.out.println(s1 == s2);// flase，这个是调用的Object中的，比较的是地址

        System.out.println(s1.equals(s2));/*true，这个是调用的String中的equals方法。
                                                并且它们是对象不同，但是在常量池中都指向了同一个常量。*/

        String s3 = "456";
        String s4 = "456";
        System.out.println(s3 == s4);// s3与s4的对象是都一个，，都是s3对象，因此这里输出的也是true。

        System.out.println(s3.equals(s4));// 对象都是一个了，指向的常量也必然是同一个。
    }
}

person类：

public class Person {
    String name;
    int age;

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

    @Override
    public String toString() {
        return "Person::"+name+"\t"+age;
    }
}

3.基本数据类型包装类

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

​ 在这里我们只测试Java.lang.Integer类为例

		// 通过下面两个可以看出基本类型的包装类型，是创建了一个对象，通过这个对象将值赋给了包装类中的属性。
        Integer a0 = new Integer(10);
        Integer a1 = 10;
        System.out.println(a0);
        System.out.println(a1);

1.测试四个包装类通用方法

	   	// 测试Integer类的一些方法
        System.out.println(a0.byteValue());
        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),那么你所创建的变量指向的就是同一个对象；如果超出这个范围，那么就会创建两个对象。

public void testValu() {
        Integer i1 = new Integer(125);// 创建新对象
        Integer i2 = new Integer(125);// 指向i1的对象
    
      	Integer i3 = new Integer(150);// 创建新对象
		Integer i4 = new Integer(150);// 创建新对象
    
    // 通过上面的内容我们已经知道了直接使用 == 比较的是对象，而不是内容
        System.out.println(i1 == i2);// true
    	System.out.println(i3 == i4);// false
    }

3.两个有参构造方法

这两个构造方法,传参的时候要么传入整型数值;要么传入( 数字 )字符串,如果传入其他的就会运行报错。java.lang.NumberFormatException

		// Integer包装类中有两个有参构造方法
        Integer i =  new Integer(89);
        System.out.println(i.intValue());
        Integer i2 = new Integer("123");
        int i1 = i2.intValue();
        System.out.println(i2.intValue());
        String s = "98";
        Integer i3 = new Integer(s);
        System.out.println(i3.intValue());

4.valueOf / intValue

​ 返回一个指定的 int型 的Integer类的实例， doublevalue 以 int型 返回此Integer的值

一般需要将 字符串 转为 int 型时，最好使用这种转换形式，因为这样在转换过程中不需要创建新的对象。

		// 将一个字符串类型转为整型包装类，在把这个整形包装类转为double型
        System.out.println(Integer.valueOf(s).doubleValue());

5.parseInt

		// parseint方法
        String s2 = "123";
        int s3 = Integer.parseInt(s2);
        System.out.println("s3:"+s3*3);

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

其中只有 Integer， Character ，与基本类型相比较不仅首字母大写，而且单词也不一样了。其余的都只是将首字母大写。

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

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

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

		// 装箱与拆箱
        Integer i4 = Integer.valueOf(10);// 装箱
        int i5 = i4.intValue();// 拆箱
        // 自动装箱与自动拆箱
        Integer i6 = 20;// 自动装箱
        int i7 = i6;// 自动拆箱

5.Arrays类

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

1.equals

​ 最初在Object类中，形式为 “==” ，比较的是对象是否相同。

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

​ 相等返回true， 否则为false。

/*
* equals方法是Arrays类中的一个简单方法
* 最初的equals方法是在Object类中的，形式为“ == ”
* */
public class Equals {
    public static void main(String[] args) {
        int [] a = {1,2,3};
        int [] b = {1,2,3};
        int [] c = {1,2,4};

        // 这里比较的是对象，一般对象不同结果都为false
        System.out.println(a == b);

        // 这里是数组重写的equals方法，比较的是数组的内容
        System.out.println(Arrays.equals(a,b));
        System.out.println(Arrays.equals(a,c));
    }
}

2.sort

1.简单排序

​ 在底层使用的其实是快速排序算法。

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

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

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

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

/*
* sort方法可以自动为基本类型或者引用类型排序，结果为升序。
* */
public class SortDemo0 {
    public static void main(String[] args) {
        int [] a = {2,1,4,5,3,9,8,6,7,0};

        // fromIndex:开始下标(包括) toIndex:结束下标(不包括)
        Arrays.sort(a,0,4);
        System.out.println(Arrays.toString(a));// 它的底层是快速排序

        Arrays.sort(a);// 升序排序
        System.out.println(Arrays.toString(a));

        // 包装类类型也可以排序
        Integer [] integer = {1,3,4,6,2,9,7};
        Arrays.sort(integer);
        System.out.println(Arrays.toString(integer));

        // 引用类型的也可以排序
        String [] s = {"1","4","2","9","5","7"};
        Arrays.sort(s);
        System.out.println(Arrays.toString(s));
    }
}

2.自定义对象排序

​ 自定义对象排序需要实现 comparable 接口，重写 compareTo 方法(可以自定义排序规则)，之后自定义的对象也就可以使用 Arrays.sort 方法了。

​ compareTo方法：在Array类中进行sort方法排序时，每次都会调用compareTo方法，会传入两个参数进行比较，结果为 <0, =0, >0 ;

​ 自定义对象专门排序类：即专门为某一个类建立比较类，需要实现comparator接口。

​ 创建好专门比较类后，需要注意的是它的使用语法：

​ Arrays.sort( stuArrays，new StudenSort());

/*
* 自定义对象排序
*
* */
public class SortDemo1 {
    public static void main(String[] args) {
        Student s0 = new Student("yuan",0);
        Student s1 = new Student("liu",1);
        Student s2 = new Student("wang",2);
        Student s3 = new Student("li",3);
        Student s4 = new Student("zhao",4);

        Student [] student = {s1,s2,s4,s0,s3};
//        Arrays.sort(student);
        // java.lang.ClassCastException
        // 编译正常，运行报错。所以对于这种自定义类型需要实现Comparable类，重写CompareTo方法。


        Arrays.sort(student,new StudentSort());// 使用专门的排序类排序
        System.out.println(Arrays.toString(student));


        Arrays.sort(student);
        System.out.println(Arrays.toString(student));
    }
}

对象模板类：

public class Student implements Comparable<Student> {//  这是泛式，尖括号中如果写T，表示任意的
    private String name;
    private int num;

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

    public String getName() {
        return name;
    }

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

    public int getNum() {
        return num;
    }

    public void setNum(int num) {
        this.num = num;
    }

    @Override
    public int compareTo(Student o) {
        return this.name.compareTo(o.name);// 字符串中已经有实现的compareTo方法了
    }

    //    @Override
//    public int compareTo(Student o) {   通过重写方法可以自定义排序规则，上面是通过名字排序，这里是通过编号排序
//        return this.num-o.num;    在Arrays类中进行sort方法排序时，每次都会调用CompareTo方法，
//                                                      会传进来两个参数进行比较，结果为 <0,==0,>0
//    }

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

}

专门排序类：

/*
* 学生专门的排序类
* 这种类需要实现Comparator接口
* */
public class StudentSort implements Comparator<Student> {
    @Override
    public int compare(Student o1, Student o2) {
        return o1.getNum() - o2.getNum();// 通过编号排序
        // return o1.compareTo(o2);  通过名称排序
    }
}

3.二分搜索(折半查找)—binarySearch

​ 使用二分搜索查找指定范围（前提：有序数组）

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

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

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

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

/*
* 二分算法 (折半查找)
* 前提： 有序数组
* */
public class SearchDemo0 {
    public static void main(String[] args) {
        int [] a = {2,3,6,4,9,7,1,0};
        Arrays.sort(a);
        System.out.println(Arrays.toString(a));// [0, 1, 2, 3, 4, 6, 7, 9]


        System.out.println(Arrays.binarySearch(a,3));// 在数组a中查找数字3
        /*
        * 如果找到，返回下标索引
        * 如果没找到，返回一个负数
        * */
        // 区段查找，fromindex：开始下标(包括)
        // toindex：结束下标(不包括)
        int k = Arrays.binarySearch(a,0,5,7);
        System.out.println(k);                                                   
    }
}

自定义二分算法

/*
* 自定义二分算法
* */
public class SearchDemo1 {
    public static void main(String[] args) {
        int [] a = {3,5,1,7,2,9,8,0};
        Arrays.sort(a);
        System.out.println(Arrays.toString(a));// [0, 1, 2, 3, 5, 7, 8, 9]
        // 先排序，再查找
        SearchDemo1.erfen(a,2);
    }

    // 二分算法
    public static void erfen(int[] a,int key){
        int low = 0;// 低位
        int height = a.length-1;// 高位

        while(low <= height){
            int middle = (low + height) >>> 1;// 位运算，无符号右移一位，等于除2
            int value = a[middle];// 将中间值赋给value

            if(key > value){ // 查找值大于中间值，去右边找，将中间值加一赋给低位
                low = middle+1;
            }else if(key < value){// 查找值小于中间值，去左边找，将中间值减一赋给高位
                height = middle-1;
            }else {
                System.out.println(middle);
                return;// 这个return用于结束方法
            }
        }
        System.out.println("false");
    }
}

若有错误，欢迎私信指正。