Arrays、enum类、大数处理

Arrays、enum类、大数处理 1.Arrays里包含了一系列静态方法，用于管理或 *** 作数组（排序和搜索）

（1）toString 返回数组的字符串形式     [          ]

  Arrays.toString(arr)

（2）sort排序（自然和定制排序）

Arrays.sort(arr)（默认排序方法）

public class ArraysSortCustom {
public static void main(String[] args) {
int[] arr = {1, -1, 8, 0,20};
bubble02(arr, new Comparator() {   //匿名内部类
@Override
public int compare(Object o1, Object o2) {
int i1 = (Integer) o1;
int i2 = (Integer) o2;
return i2 - i1;// return i2 - i1;  //决定排序方式
}
});
System.out.println("==定制排序后的情况==");
System.out.println(Arrays.toString(arr));
}

//结合冒泡 + 定制
public static void bubble02(int[] arr, Comparator c) {
int temp = 0;
for (int i = 0; i < arr.length - 1; i++) {
for (int j = 0; j < arr.length - 1 - i; j++) {
//数组排序由 c.compare(arr[j], arr[j + 1])返回的值决定
if (c.compare(arr[j], arr[j + 1]) > 0) {
temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
             } 
         }  
      }
   }
}

（3）binarySearch   通过二分搜索进行查找，要求数组有序（折半查找）

int index = Arrarys.binarySearch(arr,3)  3为查找的数字

1.如果存在就返回该数字的下标

2.如果不存在就返回-（low+1） 【low：为该数字应在位置的下标】

（4）copyOf    数组元素的复制

Integer[] newArr = Arrays.copyOf(arr,arr.length)  【第二个参数：要复制的数组长度】

1.如果小于数组长度，就复制到length的位置

2.如果是大于数组长度，就在后面添  NULL

3.如果是-1，就抛出异常

（5）fill      数组元素填充

Integer[] num = new Integer[]{9,2,3};

Arrays.fill(num,99)  相当于替换，将上面元素全部换成99

（6）equals     比较两个数组元素内容是否完全一致

boolean equals = Arrays.equals(arr,arr2)

（7）asList     将一组值，转换成list

List asList = Arrays.asList(2,3,4,5,6,1);      变成集合

【泛型】

Arrays 练习

package practice;
import java.util.Arrays;
import java.util.Comparator;
public class ArrayExercise {
    public static void main(String[] args) {
        Book1[] book1s = new Book1[4];
        book1s[0] = new Book1("红楼梦",100);
        book1s[1] = new Book1("金瓶梅新",90);
        book1s[2] = new Book1("青年文摘20年",5);
        book1s[3] = new Book1("Java入门到放弃",300);
       
        Arrays.sort(book1s, new Comparator() {
            @Override
            public int compare(Object o1,Object o2) {
                Book1 book1 = (Book1)o1;    //向下转型
                Book1 book12 = (Book1)o2;
                return book1.getName().length()-book12.getName().length();  //按长度来排序
            }
        });
        System.out.println(Arrays.toString(book1s));
    }
}
class Book1{
    public String name;
    public double price;
    Book1(String name,double price){
        this.name = name;
        this.price = price;
    }
    public String getName() {
        return name;
    }
    public double getPrice() {
        return price;
    }
    @Override
    public String toString() {
        return "Book1{" +
                "name='" + name + ''' +
                ", price=" + price +
                '}';
    }
}

System.arraycopy(src,0,dest,0,src.length)

src：原数组 

0：原数组的第0位置开始copy

dest：copy放的地方

0：dest的第0位置

src.length：copy的长度

2.enum类 （1）自定义枚举类

//1. 将构造器私有化,目的防止 直接 new
//2. 去掉 setXxx 方法, 防止属性被修改
//3. 在 Season 内部，直接创建固定的对象 常量
//4. 优化，可以加入 final 修饰符
//5.枚举对象都有static修饰，是静态对象

public class T1 {
    public static void main(String[] args) {
        System.out.println(Season.AUTUMN);  //输出的tostring
        System.out.println(Season.SUMMER);
        System.out.println(Season2.AUTUMN);
    }
}
class Season {//类
    private String name;
    private String desc;//描述
    //定义了四个对象, 固定. public static final Season SPRING = new Season("春天", "温暖");
    public static final Season WINTER = new Season("冬天", "寒冷");
    public static final Season AUTUMN = new Season("秋天", "凉爽");
    public static final Season SUMMER = new Season("夏天", "炎热");

    private Season(String name, String desc) {
        this.name = name;
        this.desc = desc;
    }
    public String getName() {
        return name;
    }
    public String getDesc() {
        return desc;
    }
    @Override
    public String toString() {
        return "Season{" +
                "name='" + name + ''' +
                ", desc='" + desc + ''' +
                '}';
    }
}

（2）使用enum类

//1.使用enum（代替class） 会继承Enum  然后该类是一个final类
//2.将定义的常量对象，写在最前面
//3.若使用的是无参构造器，则可 例：SPRING()==SPRING

enum Season2{    //enum 的tostring是返回名字
    SPRING,SPRING1("春天","温暖"),
    AUTUMN("秋天","凉爽");
    private String name;
    private String des;
    private Season2() { }
    private Season2(String name,String des){
        this.name = name;
        this.des = des;
    }
    public String toString() {  //重写 让其输出
        return "Season{" +
                "name='" + name + ''' +
                ", desc='" + des + ''' +
                '}';
    }
}

（3）enum类常用方法

     1) toString:Enum 类已经重写过了，返回的是当前对象名,子类可以重写该方法，用于返回对象的属性信息
     2) name：返回当前对象名（常量名），子类中不能重写
     3) ordinal：返回当前对象的位置号，默认从 0 开始

     4) values：返回当前枚举类中所有的常量
      Season season[] = Season.values();

     5) valueOf：将字符串转换成枚举对象，要求字符串必须为已有的常量名，否则报异常！
       Season2 autumn1 = Season2.valueOf("AUTUMN"); 与autumn同一个对象
       System.out.println("autumn1=" + autumn1);   AUTUMN
       System.out.println(autumn == autumn1);      true

     6) compareTo：比较两个枚举常量，比较的就是编号(ordinal)

       this.ordinal-other.ordinal

3.大数处理（BigInteger与BigDecimal）

1.当处理较大整数时，超出long范围 用BigInteger

BigInteger bigInteger = new BigInteger("454516464646"); //底层当作字符串处理，最后转为整型数据类型
BigInteger bigInteger1 = new BigInteger("68");

System.out.println(bigInteger.add(bigInteger1)); //两数相加
System.out.println(bigInteger.subtract(bigInteger1));//减
System.out.println(bigInteger.multiply(bigInteger1));//乘
System.out.println(bigInteger.divide(bigInteger1));//除

2.当处理较大浮点数时，用 BigDecimal

 BigDecimal bigDecimal = new BigDecimal("5498846664.4416484664656565661131232326");
        System.out.println(bigDecimal);
        BigDecimal bigDecimal1 = new BigDecimal("98.654");
        System.out.println(bigDecimal.add(bigDecimal1));//加
        System.out.println(bigDecimal.subtract(bigDecimal1));//减
        System.out.println(bigDecimal.multiply(bigDecimal1));//乘

//        System.out.println(bigDecimal.divide(bigDecimal1));  除
//除  可能会出现异常 （因为：可能除不尽，出现无限不循环小数）
        //应该在后面加一个保留多少位小数   BigDecimal.ROUND_CEILING 与分子精度一样
        System.out.println(bigDecimal.divide(bigDecimal1,BigDecimal.ROUND_CEILING));