object math System

1.Arrays
1.1冒泡排序：

  int[] arr = {24, 69, 80, 57, 13};
            //用arrayToString方法对数组进行遍历
            System.out.println("排序前：" + arrayToString(arr));
            //每次循环会把数组中的最大值放到最右边
            //
            for (int x = 0; x < arr.length-1; x++) {
                for (int i = 0; i < arr.length-1-x; i++) {
                    if(arr[i]>arr[i+1]){
                        int temp=arr[i];
                        arr[i]=arr[i+1];
                        arr[i+1]=temp;
                    }
                }
            }
            System.out.println("排序后:"+arrayToString(arr));

用Arrays.sort排序

            Arrays.sort(arr);
            System.out.println("使用sort方法排序后"+arrayToString(arr));
        }

2.内部类

内部类访问特点：
内部类可以直接访问外部类的成员，包括私有
外部类要访问内部类的成员，必须创建对象

public class Outer{
   //成员变量
       private  int num =15;
       //内部类
       public  class Inner{
           public  void show(){
               System.out.println(num);
           }
       }
       //成员方法
       public void method(){
           //创建对象调用show方法
           Inner i=new Inner();
           i.show();
       }
}

**

2.1成员内部类

public class Outer {
    private  int num=10;
//成员内部类
    private  class Inner{
        public void show(){
            System.out.println(num);
        }
    }
    public void method(){
        //创建内部类对象并调用方法
        Inner i =new Inner();
        i.show();
    }
}

public class InnerDemo {
    public static void main(String[] args) {

        //  Outer.Inner oi=new Outer().new Inner();
        // oi.show();
        Outer o=new Outer();
        o.method();
    }
}

2.2局部内部类

public class Otuer{
    private  int num=10;
    public  void methos(){
        int num2=20;
        //局部内部类
        class Inner{
            public void show(){
                System.out.println(num);
                System.out.println(num2);
            }
        }
        Inner i = new Inner();
        i.show();
    }
}

public class OuterDemo {
    public static void main(String[] args) {
        Outer o=new Outer();
        o.method();
    }
}

3.Object顶级父类

自定义类一般会重写toString()、equals(object obj)方法，不重写的话是比较或者输出地址值

public class Student extends Object {
    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;
    }

    //重写toString方法
     @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("林青霞");
        s.setAge(30);
        System.out.println(s);
        //如果不重写toString方法打印的结果还是一个地址值
        //重写toString方法比较的是内容
        System.out.println(s.toString());
    }
}

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 boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age &&
                Objects.equals(name, student.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

public class ObjectDemo {
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.setName("林青霞");
        s1.setAge(30);

        Student s2 = new Student();
        s2.setName("林青霞");
        s2.setAge(30);
        //需求：比较两个对象的内容是否相同
        System.out.println(s1.equals(s2));
    }
}

4.System

System.currentTimeMillis();获取当前系统时间与时间原点之间的的毫秒差值

public class SystemDemo {
    public static void main(String[] args) {
        //public static void exit(int status)：终止当前运行的 Java 虚拟机，非零表示异常终止


        //public static long currentTimeMillis()：返回当前时间(以毫秒为单位)
        //System.out.println(System.currentTimeMillis()*1.0/1000/60/60/24/365+"年");
        //定义了循环10000次所有的时间
        long start= System.currentTimeMillis();
        for (int i = 0; i < 10000; i++) {
            System.out.println(i);
        }
       long end  =System.currentTimeMillis();
        System.out.println((end-start));

        System.out.println("-------------");

        int[] arrSrc={4,5,6,8,9,7};
        int []arrDest=new int[3];
        //以一个数组的开始索引和第二个数组的开始索引      数组长度
        System.arraycopy(arrSrc,1,arrDest,0,3);
        for (int i = 0; i < arrDest.length; i++) {
            System.out.print(arrDest[i]+" ");
        }
    }
}

5.Math

public class MathDemo {
    public static void main(String[] args) {
        //public static int abs​(int a)：返回参数的绝对值
        System.out.println(Math.abs(88));
        System.out.println(Math.abs(-88));
        System.out.println("---------------");

        //public static double ceil​(double a)：返回大于或等于参数的最小double值，等于一个整数
        System.out.println(Math.ceil(12.34));
        System.out.println(Math.ceil(12.56));
        System.out.println("---------------");

        //public static double floor​(double a)：返回小于或等于参数的最大double值，等于一个整数
        System.out.println(Math.floor(12.34));
        System.out.println(Math.floor(12.56));
        System.out.println("---------------");


        //public static int round​(float a)：按照四舍五入返回最接近参数的int
        System.out.println(Math.round(12.34F));
        System.out.println(Math.round(12.56F));
        System.out.println("---------------");

        //public static int max​(int a,int b)：返回两个int值中的较大值
        System.out.println(Math.max(66,88));
        System.out.println("---------------");

        //public static int min​(int a,int b)：返回两个int值中的较小值(自学)
        System.out.println(Math.min(55,99) );
        System.out.println("----------");
        //public static double pow​(double a,double b)：返回a的b次幂的值
        System.out.println(Math.pow(2.0,3.0));
        System.out.println("----------");

        //public static double random​()：返回值为double的正值，[0.0,1.0)
        System.out.println((int)(Math.random()*10)+1);

    }
}