1. String类
2. StringBuilder类
3. StringJoiner类
4. ArrayList集合
5. Math类
6. System类
7. Runtim类
8. Object类和Objects类
9. BigInteger类
10. BigDecimal类
11. Array类

1.String类

1.1 boolean equals(要比较的字符串)

String str1 = "abc";  
String str2 = "abc";  
boolean result1 = str1.equals(str2);  
System.out.println(result1);//true 判断两个字符串是否相等

boolean equalsIgnoreCase(要比较的字符串)

String str3 = "abc";  
String str4 = "Abc";  
boolean result2 = str1.equalsIgnoreCase(str2);  
System.out.println(result2);//ture equalsIgnoreCase方法会忽略两个字符串中的大小写

1.2返回字符串的长度-public int length()

String str5 = "abc";  
int leng = str5.length();//计算字符串的长度  
System.out.println(leng);//3

1.3根据索引返回字符-public char charAt

String str6 = "abc";  
char a = str6.charAt(0);//返回str6中索引为0的字符  
System.out.println(a);//a

1.4 String substring(int beginIndex,int endIndex)-截取字符串

截取字符串时包头不包尾

String str7 = "liangmou3434";  
String s1 = str7.substring(0,5);//截取str7中索引为0到索引为4的字符-liang  
System.out.println(s1);//liang

String substring(int brginIndex)-从开始索引截取到末尾

String str7 = "liangmou3434";  
String s2 = str7.substring(5);//从索引为5的字符开始截取到最后  
System.out.println(s2);//mou3434

1.5 替换-String replace(旧值，新值)

String str8 = "abcd";  
String s3 = str8.replace("a","e");//把a换成e  
System.out.println(s3);//ebcd

1.6把字符串变成字符数组-public char[] tocharArray

把字符数组转变成字符串

String str = "abc";  
char[] arr = str.toCharArray();//把字符串变量str变成字符数组arr
String str1 = new String(arr);//把字符数组arr再转变成字符串

1.7比较两个字符串的大小-compareTo

返回两个字符串ASCII码值的差

String s1 = "a";//字符'a'的ASCII码值为97
String s2 = "b";//字符'b'的ASCII码值98
int i = s1.compareTo(s2);   
System.out.println(i);//-1 
// 字符串s1比字符串s2小 比较两个字符串对应的ascii码值

2.StringBuilder类

一个容器-创建后内容是可变的
构造方法 1)空参构造 StringBuilder s = new StringBuilder();
2)有参构造 StringBuilder s = new StringBuilder(“abc”);

2.1添加数据,并返回对象本身-public StringBuilder append(任意类型)

StringBuilder sb1 = new StringBuilder();  
sb1.append(1);//把1添加进sb1变量里  
sb1.append("abc");//把abc添加进sb1变量里  
System.out.println(sb1);//1abc

2.2反转容器中的内容-public StringBuilder reverse()

StringBuilder sb2 = new StringBuilder();  
sb2.append("abc");//把abc添加进容器里  
sb2.reverse();//反转容器中所有的内容  
System.out.println(sb2);//cba

2.3返回长度,字符出现的个数-public int length()

StringBuilder sb3 = new StringBuilder();  
sb3.append("abc");  
int leng = sb3.length();//计算sb3的长度  
System.out.println(leng);//3

2.4通过toString把StringBuilder类转化成String类-public String toString

StringBuilder sb4 = new StringBuilder();  
sb4.append("abc");  
String s1 = sb4.toString();//将sb4变量转变成字符串类型  
System.out.println(s1);//abc

3.StringJoiner类

与StringBuilder类似

3.1添加数据并返回对象本身(只能添加字符串)-public StringJoiner add(添加内容)

public StringJoin(间隔符号)
public StringJoiner(间隔符号,开始符号,结束符号)

StringJoiner sj1 = new StringJoiner(",");//用逗号间隔  
sj1.add("aaa");//添加字符串变量  
sj1.add("bbb");  
sj1.add("ccc");  
System.out.println(sj1);//aaa,bbb,ccc

StringJoiner sj2 = new StringJoiner(",","[","]");//逗号间隔,[为开始符号,]为结尾符号  
sj2.add("aaa");//添加字符串变量  
sj2.add("bbb");  
sj2.add("ccc");  
System.out.println(sj2);//[aaa,bbb,ccc]

3.2返回长度,字符串出现的个数-public int length()

StringJoiner sj3 = new StringJoiner(",");  
sj3.add("abc");  
sj3.add("efg");  
int leng = sj3.length();//计算sj3变量的长度  
System.out.println(leng);//sj3内的内容 "abc,efg"-长度为7

3.3返回一个字符串-public String toString

StringJoiner sj4 = new StringJoiner(",");  
sj4.add("abc");  
sj4.add("efg");  
String s2 = sj4.toString();//把sj4从StringJoiner变量转变成String类型  
System.out.println(sj4);//abc,efg

4.ArrayList集合

使用前需要导包-在ArrayList包下
ArrayList与数组的区别: ArrayList长度是可变的,只能存引用数据类型,添加元素时自动扩容
数组长度是不可变的,能存基本数据类型,也能存引用数据类型

4.1ArrayList创建的对象

ArrrayList<需要放置的引用数据类型> list = new ArrayList<需要放置的引用数据类型(可省略)> ();

4.2添加元素,返回布尔类型-public boolean add(要添加的内容)

ArrayList<String> list1 = new ArrayList<>();  
list1.add("abc");//把abc添加到list集合内  
System.out.println(list1);//[abc]

4.3public boolean remove(要删除的内容)

1)直接删除-返回布尔类型
2)根据下标删除-返回被删除的元素

ArrayList<String> list2 = new ArrayList<String>();  
list2.add("abc");  
list2.add("efg");  
list2.remove("abc"); // 删除元素"abc" -直接删除 
System.out.println(list2);//[efg]

list2.remove(0); // 删除索引为0的元素"abc"  
System.out.println(list2);//[efg]

4.4public String set(需要修改元素的下标,修改之后的内容)

ArrayList<String> list3 = new ArrayList<String>();  
 list3.add("aaa");  
 list3.add("ccc");  
 list3.set(1,"bbb");//将下标为1的元素"ccc"改为"bbb"  
 System.out.println(list3);//[aaa,bbb]

4.5public String get(要查找的元素的下标)

ArrayList<String> list4 = new ArrayList<String>();  
list4.add("aaa");  
list4.add("bbb");  
String s3 = list4.get(0);//获取索引为0的元素  
System.out.println(s3);//aaa

4.6获取集合的长度-public int size

ArrayList<String> list5 = new ArrayList<String>();  
list5.add("aaa");  
list5.add("bbb");  
int leng = list5.size();//计算集合的长度  
System.out.println(leng);//2

5.Math类

5.1获取参数的绝对值-abs(int a)

  System.out.println(Math.abs(12.34));//12.34
  System.out.println(Math.abs(12.54));//12.54
  System.out.println(Math.abs(-12.34));//12.34
  System.out.println(Math.abs(-12.54));//12.54

5.2向上取整-向无穷大取整-ceil(double a)

  System.out.println(Math.ceil(12.34));//13
  System.out.println(Math.ceil(12.54));//13
  System.out.println(Math.ceil(-12.34));//-12
  System.out.println(Math.ceil(-12.54));//-12

5.3 向下取整-向无穷小取整-floor(double a)

System.out.println(Math.floor(12.34));//12
System.out.println(Math.floor(12.54));//12
System.out.println(Math.floor(-12.34));//-13
System.out.println(Math.floor(-12.54));//-13

5.4四舍五入-round(float a)

System.out.println(Math.round(12.34));//12
System.out.println(Math.round(12.54));//13
System.out.println(Math.round(-12.34));//-12
System.out.println(Math.round(-12.54));//-13

5.5获取两个int值中的较大/小值-max/min(int a,int b)

System.out.println(Math.max(12.34,12.54));//12.54

5.6 返回a的b次幂的值-pow(double a,double b)

System.out.println(Math.pow(2,3));//返回2的三次方-8.0

5.7random() 返回值为double的随机值，范围0~1.0(包括0,不包括1.0)

double ret = Math.random() * 100 + 1;
//再对ret向下取整,向无穷小靠近
ret = Math.floor(ret);
System.out.println(ret);//生成的随机数包括0.0但不包括1.0

5.8对一个数开平方-sqrt()

System.out.println(Math.sqrt(4.0));//2.0

6.System类

6.1终止当前运行的 Java 虚拟机-public static void exit(int status)

0:表示当前虚拟机是正常停止
非0:表示当前虚拟机是异常停止

System.exit(0);

6.2返回当前系统的时间毫秒值形式-public static long currentTimeMillis()

用于判断程序执行完毕用了多少时间
从c语言的生日1970年1月1日到执行代码的时间一共过了多少毫秒,返回数据为long类型

 long l = System.currentTimeMillis();
 System.out.println(l);

6.3拷贝数组-public static void arraycopy(数据源数组，起始索引，目的地数组，起始索引，拷贝个数)

	int[] arr = {1,2,3,4,5,6,7,8,9,10};
	int[] arr1 = new int[10];
	把arr数组拷贝到arr1中
    System.arraycopy(arr,0,arr1,0,10);
	数据源数组-要拷贝的数组
	起始索引:要拷贝的数组从哪个索引开始
	目的地数组:要把数组拷贝到哪个数组上
	起始索引:目的地数组的索引
	拷贝个数:要拷贝的元素有多少个

    检验拷贝是否成功
    for (int i = 0; i < arr1.length; i++) {
          System.out.print(arr1[i] + " ");
      }

如果数据源数组和目的地数组都是基本数据类型,那么两者的类型必须保持一致,数据源数组和目的地数组都是一样的基本数据类型
数据源数组和目的地数组的长度必须一致
如果数据源数组和目的地数组都是引用数据类型,那么子类型可赋值给父类型

 //将子类赋值给父类类型
	 Student[] arr1 = {s1,s2,s3};
	 Person[] arr2 = new Person[3];//Stunde为Person的子类
	System.arraycopy(arr1,0,arr2,0,3);
	for (int i = 0; i < arr1.length; i++) {//遍历赋值后的数值,看赋值是否成功
		 Person p = arr1[i];
		 System.out.println(p.getName() + "," + p.getAge());
	}

7.Runtime类

7.1当前系统的运行环境对象-public static Runtime getRuntime

Runtime r = Runtime.getRuntime();

7.2停止虚拟机-public void exit(int status)

0:正常停止虚拟机
非0:虚拟机异常停止

 Runtime.getRuntime().exit(0);

7.3获得CPU的线程数 4或者8-public int availableProcessors()

System.out.println(Runtime.getRuntime().availableProcessors());//16

7.4JVM能从系统中获取总内存大小（单位byte)-public long maxMemory()

System.out.println(Runtime.getRuntime().maxMemory() / 1024 / 1024);//两次除1024得到以兆为单位的内存大小-4028

7.5 JVM己经从系统中获取总内存大小（单位byte）-public long totalMemory()

System.out.println(Runtime.getRuntime().totalMemory() / 1024 / 1024);//以兆为单位的获取的总内存的大小-252

7.6JVM剩余内存大小（单位byte)-public long freeMemory()

System.out.println(Runtime.getRuntime().freeMemory() / 1024 / 1024);//以兆为单位剩余的内存大小-249

7.7运行cmd命令-public Process exec(String command)

 shutdown：关机,加上参数才能执行
 shutdown-s：默认在1分钟之后关机
 shutdown-s-t指定时间：指定关机时间
 shutdown-a：取消关机操作
 shutdown-r:关机并重启
 Runtime.getRuntime().exec("notepad");//notepad为记事本-可以执行该行代码打开记事本
 Runtime.getRuntime().exec("shutdown - a");//取消关机操作

8.Oject类和Objects类

一Object类

8.1 返回对象的字符串表示形式-public String toString()

 Object obj = new Object();
 String str1 = obj.toString();
 System.out.println(str1);//打印-java.lang.Object@4eec7777包名+类名+对象的地址值

打印语句 System.out.println();
println():方法,传递是需要打印的内容
核心逻辑:当我们打印一个对象时,底层会调用对象的toString方法,把对象变成字符串,然后打印在控制台上

默认情况下,因为Object类中的toString方法返回的是地址值,打印一个对象打印的就是地址值
想要看到对象内部的属性值,应该重写object类里的toString方法,在重写的方法中,把对象的属性进行拼凑

 @Override
    public String toString(){
        return name + "," + age;
    }

8.2比较两个对象是否相等-public boolean equals（object obj)

Student s1  = new Student("zhangsan",23);
Student s2  = new Student("zhangsan",23);
System.out.println(s1.equals(s2));//原eqauls比较的是两个对象的地址值
//如果需要比较两个对象的属性值,就需要在Student类里重写equals方法,

//重写equals方法 alt+回车-按下一步到完成
    @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);
    }

例题解析

String s="abc";
StringBuilder sb =new StringBuilder("abc");
System.out.println(s.equals(sb));//false equals方法被s调用,看String类里的equals方法
//字符串中的equals方法,先判断参数是否为字符串,如果是字符串,再比较内部的属性,如果参数不是字符串,直接返回false
//StringBuilder类的sb不是字符串,所以直接返回false

System.out.println(sb.equals(s));//false equals方法被sb调用,看StringBuilder类的equals方法
//在StringBuilder当中,没有重写equal方法,调用的是Oject中的,Object类中equals方法比较两个对象的地址值
//sb和地址值和s的地址值不一样,所以返回的是false

8.3对象克隆-protected object clone(int a)

1)重写Object类中的clone方法
1)让javabean类实现Cloneable接口
3)创建对象并调用clone
1)

//重写clone方法,在javaBean类内输入Colne()-选择系统写好的Clone方法
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

![[Pasted image 20240727105432.png]]
3)

  Student s = new Student("张三",19);
  Student s1 = new Student();

 //创建Object类对象
   Object obj = s.clone();
   s1 = (Student)s.clone();//实际s.clone是Object引用数据类型,要强转成Student类

System.out.println(s.getName() + "," + s.getAge());
System.out.println(s1.getName() + "," + s1.getAge());//打印克隆后的对象验证是否克隆成功

9.Objects类

9.1 先做非空判断，比较两个对象-public static boolean equals(object a,Object b)

与Object类类似,需要重写equals方法才能判断两个对象里面的属性值

  Student s1 = new Student("张三",19);  
  Student s2 = new Student("张三",19);  
  
  //比较两个对象的属性值是否相同  
    boolean result = Objects.equals(s1,s2);
    System.out.println(result);//true  
}

9.2判断对象是否为nul1，为nul1返回true，反之则为false-public static boolean isNull(object obj)

Student s2 = null;
boolean result1 = Objects.isNull(s2);//null返回true,非null返回false  
System.out.println(result1);//true

9.3 判断对象是否为null，跟isNull的结果相反-public static boolean nonNull(object obj)

Student s2 = null;
boolean result2 = Objects.nonNull(s2);//null返回false,非null返回true  
System.out.println(result2);//false

10.BigInteger类

10.1获取随机大整数，范围：[θ～2的num次方-1]-public BigInteger(int num,Random rnd)

//1.获取一个较大的随机整数
	Random r = new Random();
	BigInteger bd1 = new BigInteger(2, new Random());
	BigInteger bd1 = new BigInteger(4, r);//获取到的bd1为2的四次方-1
	//获取的bd1随机数为0~15 包括0也包括15
	System.out.println(bd1);

10.2获取指定的大整数-public BigInteger(String val)

 BigInteger bd2 = new BigInteger("9999999999999");
 System.out.println(bd2);//9999999999999

10.3 获取指定进制的大整数-public BigInteger(String val,int radix)

字符串中的数字必须是整数且字符串中的数字必须要与进制吻合
比如二进制数字就只能写0和1

	BigInteger bd3 = new BigInteger("100",10);//表示一百是十进制的一百
	BigInteger bd4 = new BigInteger("100",2);
	//一百是二进制的一百,但编译器会将二进制的一百转换成十进制再打印在控制台上
	System.out.println(bd3);//100
	System.out.println(bd4);//4

10.4静态方法获取BigInteger的对象，内部有优化-public static BigInteger valueOf(long val)

==valueOf能表示的范围比较小,不能超出long类型

 BigInteger bd5 = BigInteger.valueOf(100);
 System.out.println(bd5);//100

在内部对常使用的数字 -16~16进行了优化
提前把-16~16先创建好了BigInteger的对象,如果多次获取不会重新创建对象

	BigInteger bd6 = BigInteger.valueOf(16);
	BigInteger bd7 = BigInteger.valueOf(16);
	System.out.println(bd6 == bd7);//结果为true-比较的是bd6和bd7的地址值,说明bd7没有创建新的对象,而是获取bd6的地址值

	BigInteger bd8 = BigInteger.valueOf(17);
	BigInteger bd9 = BigInteger.valueOf(16);
	System.out.println(bd8 == bd9);//false-小于-16或大于16,编译器就会重新创建对象

对象创建后内部的数据不能发生改变

	BigInteger bd10 = BigInteger.valueOf(1);
	BigInteger bd11 = BigInteger.valueOf(2);
	BigInteger result = bd10.add(bd11);
	System.out.println(result);//结果为3
	//不会改变参与运算的BigInteger对象中的值,而是产生了一个新的Biginteger对象用来记录3
	
	System.out.println(bd10 == result);//false
	System.out.println(bd11 == result);//false

//①如果BigInteger表示的数字没有超出long的范围，可以用静态方法获取。
//②如果BigInteger表示的超出long的范围，可以用构造方法获取。
//③对象一旦创建，BigInteger内部记录的值不能发生改变。
//④只要进行计算都会产生一个新的BigInteger对象

10.5加法-public BigInteger add(BigInteger val)

public BigInteger subtract(BigInteger val)-减法
public BigInteger multiply(BigInteger val)-乘法
public BigInteger divide(BigInteger val)- 除法，获取商**

*1.先创建两个BigInteger对象
BigInteger bd1 = BigInteger.valueOf(10);
BigInteger bd2 = BigInteger.valueOf(5);

以加法为例

//2.加法(减法,乘法,除法类似)
BigInteger bd3 = bd1.add(bd2);//15
System.out.println(bd3);

public BigInteger[] divideAndRemainder(BigInteger val)- 除法，获取商和余数

 //下标为0的为商,下标为1的为余数
	BigInteger[] bd4 = bd1.divideAndRemainder(bd2);
	for (int i = 0; i < 2; i++) {
		System.out.print(bd4[i] + " ");
	}//遍历数组,验证商和余数=是否正确

10.6比较是否相同-public boolean equals(object x)

   4.比较是否相同
	boolean result = bd1.equals(bd2);
	System.out.println(result);

10.7public BigInteger pow(int exponent)-次幂

BigInteger bd5 = bd2.pow(2);//括号内为次幂数,bd2为5,结果为5的平方
System.out.println(bd5);

10.8返回较大值或较小值-public BigInteger max/min(BigInteger val)

以较大值为例

 BigInteger bd6 = bd1.max(bd2);
 System.out.println(bd6);

10.9转为int类型,超出范围数据有误-public int intValue(BigInteger val)

BigInteger bd7 = BigInteger.valueOf(1000);
int i = bd7.intValue();
System.out.println(i);//1000

11.Bigdecimal类

BigDecima的作用:用于小数的精确计算,用来表示很大的小数

11.1用构造方法来获取BigDecimal对象

public BigDecimal(double val)
public BigDecimal(String val)

1)通过传递double类型的小数来创建对象-这种方式有可能是不精确的,不推荐使用

BigDecimal bd1 = new BigDecimal(0.01);
BigDecimal bd2 = new BigDecimal(0.09);    System.out.println(bd1);//0.01000000000000000020816681711721685132943093776702880859375
System.out.println(bd2);//0.0899999999999999966693309261245303787291049957275390625

2)通过字符串来传递小数

	BigDecimal bd3 = new BigDecimal("0.01");
	BigDecimal bd4 = new BigDecimal("0.09");
	BigDecimal bd5 = bd3.add(bd4);
	System.out.println(bd3);//0.01
	System.out.println(bd4);//0.09
	System.out.println(bd5);//0.10

11.2静态方法获取BigDecimal对象-public static BigDecimal valueOf(double val)

 BigDecimal bd6 = BigDecimal.valueOf(10);
 System.out.println(bd6);

如果表示的数字不大,没有超出double范围,使用静态方法
如果表示数字较大,超出了double范围,使用构造方法
如果传递的是0~10之间的整数,包括0,包括10,那么方法会返回已经创建好的对象,不会重新new

	BigDecimal bd7 = BigDecimal.valueOf(10);
	BigDecimal bd8 = BigDecimal.valueOf(10);
	System.out.println(bd7 == bd8);//true-如果传递的是0~10之间的整数,包括0,包括10,那么方法会返回已经创建好的对象,不会重新new
	//传递的只能是整数,如果是10.0,那么编译器也会new一个新的对象
	
	BigDecimal bd9 = BigDecimal.valueOf(20);
	BigDecimal bd10 = BigDecimal.valueOf(20);
	System.out.println(bd9 == bd10);//false-如果是超过10的整数,编译器就会重新new一个对象

11.3获取对象-public static BigDecimal valueof(double val)

BigDecimal bd1 = BigDecimal.valueOf(10.0);
BigDecimal bd2 = BigDecimal.valueOf(5.0);

11.4加法-public BigDecimal add(BigDecimal val)

public BigDecimal subtract(BigDecimal val) 减法
public BigDecimal multiply(BigDecimal val) 乘法**
以加法为例

  BigDecimal bd3 = bd1.add(bd2);
  System.out.println(bd3);//15

11.5除法-余数为0(被除数能够被除尽)-public BigDecimal divide(BigDecimal val)

 BigDecimal bd6 = bd1.divide(bd2);
 System.out.println(bd6);//2

public BigDecimal divide(BigDecimal val,精确几位，舍入模式） 除法-余数不为0(被除数无法被除尽)如果被除数无法被除尽却使用了第一个除法,就会报错

 BigDecimal bd7 = bd1.divide(bd2,2, RoundingMode.HALF_UP);//ROUND_HALF_UP--四舍五入
        //精确到两位
 System.out.println(bd7);

12.Array类

int[] arr = {1,2,3,4,5,6,7,8,9,10};

12.1把数组拼接成一个字符串-publicstaticString toString（数组)

int[] arr = {1,2,3,4,5,6,7,8,9,10};  
System.out.println(Arrays.toString(arr));//[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

12.2二分查找法查找元素-publicstaticintbinarySearch(数组，查找的元素)

二分查找的前提:数组是有序的,binarySearch方法要求数组必须是升序的
如果查找的元素存在,返回的是真实的索引,如果查找的元素不存在,则返回-插入点-1(-10-1=-11)

//2.二分查找法查找元素-返回查找元素的下标,如果没有则返回-插入点-1  
System.out.println(Arrays.binarySearch(arr,10));//9  
System.out.println(Arrays.binarySearch(arr,2));//1  
System.out.println(Arrays.binarySearch(arr,20));//-11

12.3拷贝数组-public static int[]copyof（原数组，新数组长度)

方法底层会根据第二个参数来创建新的数组
如果新数组的长度小于老数组长度,会部分拷贝
如果新数组的长度等于来数组的长度,会完全拷贝
如果新数组的长度大于老数组的长度,会补上默认值

int[] newArr1 = Arrays.copyOf(arr,20);  
System.out.println(Arrays.toString(newArr1));  
//[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]

12.4拷贝数组(指定范围)-public staticint[]copyofRange（原数组，起始索引，结束索引)

包头不包尾,包左不包右

int[] newArr2 = Arrays.copyOfRange(arr,0,9);//把arr0~9下标的元素拷贝过来-包头不包尾  
System.out.println(Arrays.toString(newArr2));//[1, 2, 3, 4, 5, 6, 7, 8, 9]

12.5填充数组-publicstaticvoidfill（数组，元素)

数组内所有元素被替换,原来的数据会被覆盖

//5.填充数组-数组内所有元素替换成100,原来的数据会被覆盖    
Arrays.fill(arr,100);  
System.out.println(Arrays.toString(arr));//[100, 100, 100, 100, 100, 100, 100, 100, 100, 100]

12.6按照默认方式进行数组排序-public static void sort(数组)

sort默认把数组中的基本数据类型排成升序

int[] arr2 = {10,2,3,5,6,1,7,8,4,9};  
Arrays.sort(arr2);  
System.out.println(Arrays.toString(arr2));//[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

12.7按照指定的规则排序-public static void sort(数组，排序规则)

1)只能给引用数据类型的数组进行排序,如果数据是基本数据类型,则需要变成包装类
2)参数二是一个接口,所以在调用方法的时候需要传递这个接口的实现类对象,作为排序的规则。 但是这个实现类只要使用一次,所以没有必要单独地去写一个类,可以采用匿名内部类的方式调用

Integer[] arr = {2, 3, 1, 5, 6, 7, 8, 4, 9};    
//compare方法的形式参数:  
//参数一 o1:表示在无序序列中,遍历得到每一个元素  
//参数二 o2:有序序列的元素  
  
//返回值：  
//负数：表示当前要插入的元素是小的，放在前面  
//正数：表示当前要插入的元素是大的，放在后面  
//0：表示当前要插入的元素跟现在的元素比是一样的们也会放在后面  
Arrays.sort(arr, new Comparator<Integer>() {  
    @Override  
    public int compare(Integer o1, Integer o2) {  
        return o1 - o2;//把此处的0改为o1-o2  
    }  
});  
System.out.println(Arrays.toString(arr));