常用API

Math

1.1 Math概述

public final class Math

extends Object

Math 类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。

没有构造方法，

使用：看类的成员是否都是静态，即static修饰，如果是，直接类名调方法

1.2Math的常用方法

public class MathDemo {
    public static void main(String[] args) {
        //    public static int abs(int a) 返回参数的绝对值
        System.out.println(Math.abs(-52));
        System.out.println(Math.abs(22));
//    public static double ceil(double a) 返回大于或等于参数的最小double值，等于一个整数
        System.out.println(Math.ceil(12.24));
        System.out.println(Math.ceil(-12.33));
//    public static double floor(double a 返回小于或等于参数的最大double值，等于一个整数
        System.out.println(Math.floor(11.25));
        System.out.println(Math.floor(11.99));
//            public static int round(float a) 按照四舍五入返回最接近参数的int
        System.out.println(Math.round(30.65F));
        System.out.println(Math.round(29.49F));
//    public static int max(int a,int b) 返回两个int值中的较大值
        System.out.println(Math.max(111,999));
//    public static int min(int a,int b) 返回两个int值中的较小值
        System.out.println(Math.min(111,999));
//    public static double pow(double a,double b)返回a的b次幂的值
        System.out.println(Math.pow(2,2));
//    public static double random() 返回值为double的正值，[0.0,1.0)
        System.out.println(Math.random());
    }
}

2.1 System类

public final class

Systemextends Object

System 类包含一些有用的类字段和方法。它不能被实例化。被static稀释，直接类名调对象

在 System 类提供的设施中，有标准输入、标准输出和错误输出流；对外部定义的属性和环境变量的访问；加载文件和库的方法；还有快速复制数组的一部分的实用方法。

2.2 System常用方法

/*
system 常用方法
 */
public class SystemDemo {
    public static void main(String[] args) {
        //System.out.println("开始");
        //public static void exit(int status),终止当前运行的java虚拟机，非零表示异常终止
        //System.exit(0);
        //System.out.println("结束");
        //public static void currenTimeMillis(),返回当前时间，以毫秒为单位
        System.out.println(System.currentTimeMillis() / 1000 / 60 / 60 / 24 / 365);
        //计算
        long start = System.currentTimeMillis();
        for (int i = 0; i<1000000; i++){
            System.out.println(i);
        }
        long end = System.currentTimeMillis();
        System.out.println((double)(end - start)/1000);
    }
}

3.1 Object类的概述

public class Object类

Object 是类层次结构的根类。每个类都使用 Object 作为超类。所有对象（包括数组）都实现这个类的方法。

equals方法

public boolean equals(Object obj)指示其他某个对象是否与此对象“相等”。

equals 方法在非空对象引用上实现相等关系：

自反性：对于任何非空引用值 x，x.equals(x) 都应返回 true。

对称性：对于任何非空引用值 x 和 y，当且仅当 y.equals(x) 返回 true 时，x.equals(y) 才应返回 true。

传递性：对于任何非空引用值 x、y 和 z，如果 x.equals(y) 返回 true，并且 y.equals(z) 返回 true，那么 x.equals(z) 应返回 true。

一致性：对于任何非空引用值 x 和 y，多次调用 x.equals(y) 始终返回 true 或始终返回 false，前提是对象上 equals 比较中所用的信息没有被修改。

对于任何非空引用值 x，x.equals(null) 都应返回 false。

Object 类的 equals 方法实现对象上差别可能性最大的相等关系；即，对于任何非空引用值 x 和 y，当且仅当 x 和 y 引用同一个对象时，此方法才返回 true（x == y 具有值 true）。

学生类：

public class Student {
    private String name;
    private int age;
    public Student(){
    }
    public Student(String name, int age){
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        if (age != student.age) return false;
        return name != null ? name.equals(student.name) : student.name == null;
    }
}

测试类：

public class ObjectDemo {
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.setName("hmm");
        s1.setAge(19);
        Student s2 = new Student();
        s2.setName("hmm");
        s2.setAge(19);
        System.out.println(s1.equals(s2));//未重写equals方法，比较的是地址
    }
}

注意：当此方法被重写时，通常有必要重写 hashCode 方法，以维护 hashCode 方法的常规协定，该协定声明相等对象必须具有相等的哈希码。

参数：

obj - 要与之比较的引用对象。

如果此对象与 obj 参数相同，则返回 true；否则返回 false。

另请参见：

hashCode(), Hashtable

toString方法

public String toString()返回该对象的字符串表示。通常，toString 方法会返回一个“以文本方式表示”此对象的字符串。结果应是一个简明但易于读懂的信息表达式。建议所有子类都重写此方法。

Object 类的 toString 方法返回一个字符串，该字符串由类名（对象是该类的一个实例）、at 标记符“@”和此对象哈希码的无符号十六进制表示组成。换句话说，该方法返回一个字符串，它的值等于：

getClass().getName() + ‘@’ + Integer.toHexString(hashCode())

该对象的字符串表示形式。

学生类：

public class Student {
    private String name;
    private int age;
    public Student() {
    }
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

测试类：

public class ObjectDemo {
    public static void main(String[] args) {
        Student s  =new Student();
        s.setName("hmm");
        s.setAge(10);
        System.out.println(s);
        System.out.println(s.toString());
    }
}

Arrays

4.1 冒泡排序

排序：将一组数据按照固定规则进行排列

冒泡排序：一种排序的方法，对于进行的数据排序中相邻的数据进行两两比较，将较大的数据放在后面，依次对所有数据进行操作，直至所有数据按要求完成排序

1. 算法步骤

比较相邻的元素。如果第一个比第二个大，就交换他们两个。

对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。

针对所有的元素重复以上的步骤，除了最后一个。

持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

图示：

public class BubbleSort implements IArraySort {
    @Override
    public int[] sort(int[] sourceArray) throws Exception {
        // 对 arr 进行拷贝，不改变参数内容
        int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);
        for (int i = 1; i < arr.length; i++) {
            // 设定一个标记，若为true，则表示此次循环没有进行交换，也就是待排序列已经有序，排序已经完成。
            boolean flag = true;
            for (int j = 0; j < arr.length - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    int tmp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = tmp;
                    flag = false;
                }
            }
            if (flag) {
                break;
            }
        }
        return arr;
    }
}

注：

如果有n个数据进行排序，总共需要比较n-1次

每一次比较完毕，下一次比较就会少一个数据参与

4.2 Arrays类的概述和常用方法

public class Arrays

extends Object

此类包含用来操作数组（比如排序和搜索）的各种方法。此类还包含一个允许将数组作为列表来查看的静态工厂。

除非特别注明，否则如果指定数组引用为 null，则此类中的方法都会抛出 NullPointerException。

此类中所含方法的文档都包括对实现的简短描述。应该将这些描述视为实现注意事项，而不应将它们视为规范的一部分。实现者应该可以随意替代其他算法，只要遵循规范本身即可。（例如，sort(Object[]) 使用的算法不必是一个合并排序算法，但它必须是稳定的。）

此类是 Java Collections Framework 的成员。

toString 方法

sort方法

import java.util.Arrays;
public class ArraysDemo {
    public static void main(String[] args) {
        int arr[] = {10,52,555,74,2,6,5};
        System.out.println("排序前"+Arrays.toString(arr));
        Arrays.sort(arr);
        System.out.println("排序后"+Arrays.toString(arr));
    }
}

注：工具类的设计思想

构造方法用private修饰

成员用public static 修饰

5.基本类型包装类

5.1基本数据类型包装类概述

将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能方法操作该数据

常用的操作之一：用于基本数据类型与字符串之间的转换

基本数据类型和包装类的区别

区别：

包装类是对象，拥有方法和字段，对象的调用都是通过引用对象的地址，基本数据类型不是

包装类型是引用的传递，基本类型是值的传递

声明方式不同、基本数据类型不需要new关键字，而包装类型需要new在堆内存中进行new来分配内存空间

存储位置不同，基本数据类型直接将值保存在值栈中，而包装类型是把对象放在堆中，然后通过对象的引用来调用它们

初始值不同，eg:int的初始值为0、boolean的初始值为fales ，而包装类型的初始值为null

使用方法不同，基本数据类型直接赋值使用就好，而包装类型是在集合如collction Map时会使用

5.2 Integer 类的概述和使用

构造方法

Integer ：类在对象中包装了一个基本类型 int 的值。Integer 类型的对象包含一个 int 类型的字段。

此外，该类提供了多个方法，能在 int 类型和 String 类型之间互相转换，还提供了处理 int 类型时非常有用的其他一些常量和方法。

public class IntegerDemo {
    public static void main(String[] args) {
        //构造方法摘要
//Integer(int value)
//          构造一个新分配的 Integer 对象，它表示指定的 int 值。
//Integer(String s)
//          构造一个新分配的 Integer 对象，它表示 String 参数所指示的 int 值。
//
        Integer i = new Integer(100);
        System.out.println(i);
        Integer i1 = new Integer("1000");//由数字组成的字符串
        System.out.println(i1);
        //static Integer valueOf(int i)
        //          返回一个表示指定的 int 值的 Integer 实例。
        //static Integer valueOf(String s)
        //          返回保存指定的 String 的值的 Integer 对象。
        Integer i2 = Integer.valueOf(10);
        System.out.println(i2);
        Integer i3 = Integer.valueOf("10000");
        System.out.println(i3);
    }
}

5.3 int和 String 的相互转化

基本类型包装类的最常见的操作就是：用于基本类型和字符串之间的相互转换

public class ZhuanHuan {
    public static void main(String[] args) {
        //int--->String
        // 方法一
        int number = 100;
        String i = "" + number;
        System.out.println(i);
        //方法二
        //static String valueOf(int i)
        //          返回 int 参数的字符串表示形式。
        String i1 = String.valueOf(number);
        System.out.println(i1);
        System.out.println("-----------------");
        //String --> Integer -- > int
        String s1 = "100";
        //String --->Integer
        Integer i2 = Integer.valueOf(s1);
        // int intValue()
        //          以 int 类型返回该 Integer 的值。
        int x = i2.intValue();
        System.out.println(x);
        //f方法二
        //static int parseInt(String s) 
        //          将字符串参数作为有符号的十进制整数进行解析。 
        int y = Integer.parseInt(s1);
        System.out.println(y);
    }
}

5.4自动装箱和拆箱

装箱：把基本数据类型转换为对应包装类类型

拆箱：把包装类型转换为对应的基本数据类型

// - 装箱：把基本数据类型转换为对应包装类类型
// - 拆箱：把包装类型转换为对应的基本数据类型
public class BaoChai {
    public static void main(String[] args) {
        // - 装箱：把基本数据类型转换为对应包装类类型
        Integer i = Integer.valueOf(100);
        Integer ii =100;//自动装箱Integer.valueOf(100);
        //- 拆箱：把包装类型转换为对应的基本数据类型
       /* ii = ii.intValue()+200;
        System.out.println(ii);*/
        ii+=200;//内部隐含ii.intValue()
        System.out.println(ii);
        Integer iii = null;
        if(iii!=null){
            iii+=300;//NullPointerException//内部隐含ii.intValue(),所以null掉对象，会触发空指针异常
        }
    }
}

注意：在使用包装类类型的时候，若果做操作，最好先判断是否为null

我们推荐的是：只要是对象，在使用之前就必须进行不为null判断

详讲Java开发中的六个常用API（Math，System，Object，Integer，Date）（一）