常用类API

官方提供的类，接口·功能·进行说明的文档

API(Application Programming Interface)应用程序编程接口，指的是java语言中提供的类和接口

API-->API文档 在文档中对java语言中提供的类和接口的功能进行说明

人手一份

基本数据类型包装类

基本类型指的是8种数据类型 byte short int long float double boolean char

基本类型通过8种关键字，来进行声明定义的。

int a = 10； 值就是10 结构简单

包装类

因为基本数据类型，使用关键字定义，不是面向对象的

String{集合类型

类中可以定义其他方法

}

所以在Java语言中，为每种基本类型都提供了一个类进行了包装表示

这样就是以面向对象的方式来进行操作。

有八种基本类型，java为我们提供了8种包装类

关键字 包装类名

byte Byte

short Short

char Character

int Integer

long Long

float Float

double Double

boolean Boolean

Integer

有些是静态的，通过类名直接调用

有些是非静态的，需要通过包装对象去调用

package com.ffyc.javapi.basepackage;
public class TestInteger1 {
    public static void main(String[] args) {
        System.out.println(Integer.MAX_VALUE);
        System.out.println(Integer.MIN_VALUE);
        System.out.println(Integer.BYTES);
        System.out.println(Integer.SIZE);
        System.out.println(Integer.toOctalString(3));
        System.out.println(Integer.toBinaryString(3));
        System.out.println(Integer.toHexString(11));
        int c  = Integer.parseInt("100");//把字符串转为基本的int
        int d = Integer.valueOf(10);
    }
}

package com.ffyc.javapi.basepackage;
public class TestInteger3 {
    public static void main(String[] args) {
        /*
        Integer a = 127;默认会调用Integer Integer.volueOf(int i){}
        在Integer类中为了节省空间，对-128到+127之间的225个对象进行缓存（数组）
        在-128到127之间的时候，之间从数组中获取，如果值相同的时候，取到的对象是相同的 
        如果不在这个范围之间每一次都会创建一个新的对象 
        {-128，-127，-126......120,121,122.。。。127}
        */
        Integer a = 127; 
        Integer b = 127;
        System.out.println(a==b);//true
        Integer c = new Integer(127);
        Integer d = new Integer(127);
        System.out.println(c==d);//false
        Integer e = 128; 
        Integer f = 128; 
        System.out.println(e==f);
    }
}

自动装箱和自动拆箱

package com.ffyc.javapi.basepackage;
public class TestInteger2 {
    /*
    基本类型与基本类型包装类之间的转换；
    有的时候以面向对象德方式进行操作，希望拿到包装类型
    也有时候需要获取到包装类里面的基本类型数据
    自动装箱：基本类型转为包装类型
    自动拆箱：包装类型转为基本类型
    */ 
    public static void main(String[] args) {
        int a = 10;//把基本类型转为包装类型，产生一个Inteder类的对象
        Integer ba = new Integer(a);
        Integer ba1 = Integer.valueOf(a);
        Integer ba2 = a;//自动装箱
        //把包装类型转为基本类型，取出包装类对象中的基本类型值 
        int c = ba.intValue(); 
        //自动拆箱
        Integer b = new Integer(10);
        int d = b;
    }
}

自动装箱: 把基本类型 转为 包装类型 Integer valueOf(int a) 将-128 +127 256个对象 存储在一个数组中, 此区间的值,可以直接从数组中取出对象返回 此区间之间外,每次还是new Integer对象

     自动拆箱: 将包装类型 转为 基本类型
      Integer b = a;
      int c = b;  默认调用的是 intValue()

Object

当一个类没有直接使用extends关键字继承其他类时，这个类默认继承Object类

Object是最顶尖的类

ToString

Object中默认有ToString输出类名，对象在内存中的地址转换为16进制整数

我们可以重写ToString，自己指定字符串格式

package com.ffyc.javapi.object;
public class Person extends Object{
    private int num;
    private String name;
    public int getNum() {
        return num;
    }
    public void setNum(int num) {
        this.num = num;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    //    @Override
    //    public String toString(){
    //        return "num="+this.num+",name="+this.name;
    //    }
    @Override    public String toString() {
        return "Person{" +                "num=" + num +                ", name='" + name + '\'' +                '}'; 
    }
}

package com.ffyc.javapi.object;
public class ToStringDemo {
    public static void main(String[] args) {
        /*
        System.out.println(person);在控制台输出一个Person对象
        对象在内存中怎么输出？
        看似输出的是对象，其实输出的是字符串，在对象输出时，会默认调用类中的ToString（）Object默认输出对象内存地址
        我们想看对象中的值是什么，子类实现与父类实现不同，在子类重写父类中ToString
        如果类中没有ToString（），那么会调用父类中ToString类型
        public String toString() {
        拿到类名                            hashCode（）拿到对象在内存中的哈希值（十进制整数）
        Integer.toHexString（哈希值）转为16进制整数        return getClass().getName() + "@" + Integer.toHexString(hashCode());
        }
        com.ffyc.javapi.object.Person@1b6d3586
        */
        Person person = new Person();
        person.setNum(100);
        person.setName("1010");
        System.out.println(person);
    }
}

Equals

package com.ffyc.javapi.object;
public class Person extends Object{
    private int num;
    private String name;
    public int getNum() {
        return num;
    }
    public void setNum(int num) {
        this.num = num;
    }
    public Person() {
    }
    public Person(int num, String name) {
        this.num = num;
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    //@Override
    //    public String toString(){
    //        return "num="+this.num+",name="+this.name;
    //    }    @Override    public String toString() {        return "Person{" +                "num=" + num +                ", name='" + name + '\'' +                '}';    }
    //重写Object方法
    @Override
    public boolean equals(Object object){
        Person otherPerson = (Person)object;
        if(this==otherPerson){
            return true;
        } 
  
        if(this.num==otherPerson.num&&this.name.equals(otherPerson.name)){
            return true;
        }
        return false; 
    }
}

package com.ffyc.javapi.object;
public class EqualsDome {
    public static void main(String[] args) {
        /*
        ==            基本类型比较 比较值是否相等
        引用类型比较 比较的是引用变量所指向的内存中的地址
        有时候想要比较对象中所包含的对象是否相等
        */
        int a = 10;
        int b = 10;
        System.out.println(a==b);
        String x1 = new String("abc");
        String x2 = new String("abc");
        System.out.println(x1==x2);
        //false  x1,x2值是内存中的对象地址        System.out.println(x1.equals(x2));//ture String类中已经重写了此方法       
        //凡是new'出来的对象，地址肯定不同
        Person p1 = new Person(100,"jim");
        Person p2 = new Person(100,"jim");
        System.out.println(p1==p2);
        System.out.println(p1.equals(p2));
        //false 没有重写Object中的quals，返回false        System.out.println(p1.equals(p2));
        //true 重写Object中的equals程序，返回值为true
        /*
        p1.equals(p2) 我们自己Person类中并没有equal（）；
        调用的是父类（Object）中equals（）
        Object类中的equals（），比较的时候，仍然使用的是==，比较的是对象中的地址是否相等 
        public boolean equals(Object obj) {
        return (this == obj);
        }
        所以大家约定俗称，在其他类中如果需要比较内容是否相等时我们要重写Object中equal()
        */
    }
}

Arrays类

package com.ffyc.javaapi.arraysDemo;
import java.util.Arrays;
public class ArraysDemo1 {
    /*
    java.util.Arrays 包含了许多关于数组操作的方法
    排序，二分查询‘ 
    Arrays.equals（a，b）;
    比较数组元素是否相等
    Arrays.binarySearch(a,2);二分查找算法，数组必须有序 
    */
    public static void main(String[] args) { 
        int [] a = {1,2,3,4,5};
        int [] b = {1,2,3,4,5};
        boolean res = Arrays.equals(a,b);
        System.out.println(res);       
        System.out.println(Arrays.toString(a));  
        //int c = Arrays.binarySearch(a,2);//整个数组中查找
        int c = Arrays.binarySearch(a,0,4,2);//指定区间查找
        System.out.println(c);
    }
}

package com.ffyc.javaapi.arraysDemo;
import java.util.Arrays;
public class ArraysDemo2 {
    public static void main(String[] args) {
        int [] a = {2,1,4,3,5};
        Arrays.sort(a);//d对整个数组进行排序 
        Arrays.sort(a,0,3);//对某区间进行排序 
        System.out.println(Arrays.toString(a)); 
        String [] arrays = {"a","c","b"}; 
        Arrays.sort(arrays); 
        System.out.println(Arrays.toString(arrays)); 
        /*         */ 
        Student student1 = new Student(101,"zhangsan1");
        Student student2 = new Student(102,"zhangsan2"); 
        Student student3 = new Student(103,"zhangsan3");
        Student student4 = new Student(104,"zhangsan4");
        Student[] students = new Student[4];   
        students[0] = student4; 
        students[1] = student3;  
        students[2] = student2;  
        students[3] = student1;  
        Arrays.sort(students); 
        System.out.println(Arrays.toString(students));
    }
}

copyof数组复制

package com.ffyc.javaapi.arraysDemo;
import java.util.Arrays;
public class ArraysDemo3 {
    public static void main(String[] args) {
        /* 
        java中数组长度是固定的，不变得，但是程序运行时的数据长度是变化的
        有时数据多了，不满足了，需要对数组进行扩容
        */ 
        int []a = {1,2,3,4,5};//        int []b = new int[a.length*2];
        //        for(int i = 0;i<a.length;i++){//            b[i] = a[i];
        //        }
        //        System.out.println(Arrays.toString(b));
        //int []b =  Arrays.copyOf(源数组,行数组长度);
        //创建一个指定容量的新数组，并且把原来的数组内容复制到新数组中
        int []b =  Arrays.copyOf(a,a.length*2);
        System.out.println(Arrays.toString(b));
    }
}

package com.ffyc.javaapi.arraysDemo;
/*
Comparable 是java中进行排序的功能，进行比较的方法的定义
*/
public class Student implements Comparable<Student> {
    private String name;
    private int sum;
    public Student( int sum,String name) {
        this.name = name;
        this.sum = sum;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    } 
    public int getSum() {
        return sum;
    } 
    public void setSum(int sum) {
        this.sum = sum;
    }
    @Override
    public String toString() {
        return "Student{" +                "name='" + name + '\'' +                ", sum=" + sum +                '}';
    } 
    /* 
    compareTo就是提供的自定义排序比较规则的方法
    此方法会在sort（）方法的原码中调用
    返回值是整数，小于0， 等于0 大于0 
    */
    @Override
    public int compareTo(Student o){
        return this.sum-o.sum;//定义的是通过学号进行排序
    }
}