javaAPI

javaAPI

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

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

1 基本数据类型包装类

​ ：java语言是面向对象的语言，但其基本数据类型不是面向对象的，所以在使用时存在很多不便，为解决这个问题，设计时为每个基本类型设计了一个对应类和八个基本类型相对应，统称为包装类。包装类中封装了一个相应的基本数据类型，并为其提供很多操作。

包装类用途：1 作为和基本数据类型对应的类类型存在，方便涉及到对象的操作

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

1.1基本数据类型包装类：

String类/StringBuffer类/StringBuilder类

Math类/Random类/System类

Date类/Calendar类/ SimpleDateFormat类

BigInteger/BigDecimal

/*
包装类:Integer
属性:最大值\最小值\SIZE\BYTES
构造方法创建Integer对象:1 Integer x = new Integer("8");
                     2 Integer z = 8;
基本类型和引用类型的转换
 */
public class IntDemo {
    public static void main(String[] args) {
        int num = 10;//存在栈空间里,基本类型,没有可操作的方法
        Integer a = 10;//引用类型,相当于Integer a = new Integer(10);在堆空间里创建了a对象
        System.out.println(a.intValue());
        //属性
        System.out.println(Integer.BYTES);
        System.out.println(Integer.SIZE);
        System.out.println(Integer.MAX_VALUE);
        System.out.println(Integer.MIN_VALUE);
        //构造方法
        Integer x = new Integer("8");
        Integer y = new Integer(9);
        Integer z = 10;
        System.out.println(x);
        System.out.println(y);
        System.out.println(z);

        //Integer中包含的方法
        System.out.println(Integer.toBinaryString(4));//转二进制
        System.out.println(Integer.toHexString(24));//转十六进制
        System.out.println(Integer.toOctalString(10));//转八进制
        System.out.println(Integer.max(8,9));//输出两个数中较大的
        System.out.println(x == y);//比较Integer对象x y的地址
        System.out.println(x.equals(y));//比较Integer对象中包含的x y的值
        System.out.println(x.intValue());//取出Integer对象中包含的int值
        //转换
        String s = x.toString();//Integer类型的 x 转为String类型
        System.out.println(s);
        int n = Integer.parseInt("99");
        System.out.println(n);
        Integer m = Integer.valueOf(n);//基本类型转为引用类型
        System.out.println(m.intValue());
    }

1.2包装类常见方法：

1、 MAX_VALUE( )//获取最大值

2、 MIN_VALUE( )//获取最小值

3、 intVALUE( )//返回封装数据的int类型

4、parseInt(String s )//将字符串解析成int型数据，并返回

5 、public static Integer valueOf(String s)返回Integer对象，其中封装的整型数据为字符串s所表示

6、 public String toString()返回一个表示该 Integer 值的 String对象

7 、public static String toString(int i)返回一个表示指定整数的String对象

1.3装箱和拆箱：

装箱：

自动将基本数据类型转换为包装类型；

装箱时自动调用Integer类中的intValueOf（int）方法；

拆箱：

自动将包装类型转换为基本类型；

拆箱时自动调用Integer的intValue()方法；

//装箱：
        int a = 9;
        Integer b = Integer.valueOf(a);
        System.out.println(b);
//拆箱
        int c = b.intValue();
        System.out.println(c);

2 Object类：

2.1 若一个类没有显示继承任何类，默认继承Object类，为了实现多态性，Object类型可以表示任何类型。

2.2 Object类是所有类的祖先（基类）。有对象（包括数组）都实现这个类的方法

2.3 toString方法和equals方法：

public class ObjectDemo {
    public static void main(String[] args) {
        ObjectDemo obj = new ObjectDemo();
        obj.hashCode();
        //数组对象也继承object类
        int [] a = new int[5];
        a.hashCode();

        /*
        totring()方法:
         */
        Person p = new Person("jim",20);

        /*
        输出对象时,会默认调用对象中的toString方法,
        如果对象中没有,会调用Object类中的toString
        为了显示方便,一般在子类中重写toString方法,从而调用调用子类中的
         */
        //System.out.println(p.toString());输出:com.ff.javaapi.day1.Person@74a14482  Person中还没有toString方法
        System.out.println(p.toString());//输出:Person{name='jim', age=20}  Person中重写了toString方法

        /*
        equals()方法：
         1 Object类定义有：public boolean equals(object obj)方法，用来判断是否相等
         2 一般类中都重写Object类的equals方法，他们有自己实现方式，比较的是对象中包含的内容（具体值）是否相等
         */
        String s1 = new String("abc");
        String s2 = new String("abc");
        System.out.println(s1 == s2);//false 比较的是s1 s2的地址
        System.out.println(s1.equals(s2));//ture 比较的是s1 s2的值
    }
}

3 String类（字符串类）

3.1、字符串：多个字符组成的一串 数据的 字符串常量，值改变后会重新创建对象；

3.2、Java中所有字符串对象都是String类的对象；

3.3、两种创建方法：

​ 1 String s1 = “abc”;

​ 特点：创建对象时，会现在常量池检测有没有相同的值

​ 若没有，就在堆中创建一个字符串对象，值存在常量池中；

​ 第二次创建对象时，常量池中值已存在，直接让引用变量指向已有的字符串对象

        String s1 = "abc";
        String s2 = "abc";

        System.out.println(s1 == s2);
        //ture 第二次创建对象时，常量池中值已存在，直接让引用变量指向已有的字符串对象
        System.out.println(s1.equals(s2));
        //ture 比较的是s1 s2的值,都是常量池中的同一份abc
        

        //值一旦改变，就会重新建一个对象
        String s5 = "abc";
        s5 += "def";
        System.out.println(s5);//输出：abcdef
        s5 += "ghi";
        System.out.println(s5);//输出：abcdefghi
        s5 += "jkl";
        System.out.println(s5);//输出：abcdefghijkl
        s5 += "mno";
        System.out.println(s5);//输出：abcdefghijklmno
    }

​ 2 使用构造方法创建：String s2 = new String(“abc”);

String s3 = new String("abc");
        String s4 = new String("abc");

        System.out.println(s3 == s4);
        //false 比较的是s1 s2两个对象的地址
        System.out.println(s3.equals(s4));
        //ture 比较的是s1 s2的值,都是常量池中的同一份abc

3. 4值一旦改变，就会重新建一个对象

String s5 = "abc";
        s5 += "def";
        System.out.println(s5);//输出：abcdef
        s5 += "ghi";
        System.out.println(s5);//输出：abcdefghi
        s5 += "jkl";
        System.out.println(s5);//输出：abcdefghijkl
        s5 += "mno";
        System.out.println(s5);//输出：abcdefghijklmno

4 Arrays类

：是用于操作数组的对象类；定义了操作数组的静态方法

4.1equals（）方法：

/*
equals方法:
返回一个Boolean值;
比较两个数组每个位置的元素的值是否相等
 */
public class EqualsDemo {
    public static void main(String[] args) {
        int[] a = {1,2,3,4};

        int[] a1 = {1,2,5,4};
        System.out.println(Arrays.equals(a,a1));//false
    }

4.2sort()方法：

/*
sort方法:
 */
public class SortDemo1 {
    public static void main(String[] args) {

        int[] a = {7,2,9,4};

        int[] b = {4,2,1,3,9,0,6,8};

        Arrays.sort(a);//对整个数组进行升序排序
        System.out.println(Arrays.toString(a));

        Arrays.sort(b,0,5);//对数组中一定元素区间进行排序,[0,5)包含左边,不包含右边
        System.out.println(Arrays.toString(b));


    }

4.3二分搜索（折半查找）：

:binarySearch(数组名,要查找的元素 )

1 前提:数组必须有序

2 在某个区间查找:[index1,index2)包含左边,不包含右边

3 binarySearch(数组名,index1,index2,要查找的元素 )

4 若没找到,会返回一个负数;若找到了,会返回找到元素的索引

public static void main(String[] args) {
        int[] a = {3,1,7,9,6,4,0};

        Arrays.sort(a);

        System.out.println(Arrays.toString(a));

        int t = Arrays.binarySearch(a,6);
        System.out.println(t);//4

        //一定区间[0,5)查找
        int t1 = Arrays.binarySearch(a,0,5,3);
        System.out.println(t1);//2

        //查不到
        int t3 = Arrays.binarySearch(a,11);
        System.out.println(t3);//-8
    }

4.4自己实现二分搜索：

/**
     * 自己实现二分搜索
     * 1 定义最大最小索引min=0 , max=数组长度减1
     * 2 找中间索引mid
     * 3 找中间值midval
     * 4 minval和要查的值key比较:midval大,mid-1,去左边
     *                        midval小,mid+1,去右边
     *
     */
    public static void search(int[] array,int key){
        int min = 0;
        int max = array.length - 1;
        int mid = (min+max)/2;
        int midval = array[mid];
        for (int i = 0; i < array.length/2; i++) {
            if (midval > key){
                min -= 1;
            }else if (midval < key){
                min += 1;
            }else {
                System.out.println(mid);
            }
        }
        System.out.println(Arrays.binarySearch(array,key));
    }