数组的升序和降序
1.Arrays.sort （数组名），默认是升序
2.Arrays.sort (数组名，int beginIndex, int endIndex)
对指定数组的指定范围进行升序
3.Arrays.sort(数组名，Collections.reverseOrder());
降序排列
4.集合排序： Collections.sort(List list) ,默认也是升序
四舍五入保留小数
BigDecimal bigD = new BigDecimal("3.14159");
bigD.setScale(1)表示保留一位小数，默认用四舍五入方式
bigD.setScale(1,BigDecimal.ROUND_DOWN)直接删除多余的小数位，如2.35会变成2.3
bigD.setScale(1,BigDecimal.ROUND_UP)进位处理，2.35变成2.4
bigD.setScale(1,BigDecimal.ROUND_HALF_UP)四舍五入，2.35变成2.4
bigD.setScale(1,BigDecimal.ROUND_HALF_DOWN)四舍五入，2.35变成2.3，如果是5则向下舍
对应的参数定义如下：
ROUND_CEILING
Rounding mode to round towards positive infinity.
向正无穷方向舍入
ROUND_DOWN
Rounding mode to round towards zero.
向零方向舍入
ROUND_FLOOR
Rounding mode to round towards negative infinity.
向负无穷方向舍入
ROUND_HALF_DOWN
Rounding mode to round towards "nearest neighbor" unless both neighbors are equidistant, in which case round down.
向（距离）最近的一边舍入，除非两边（的距离）是相等,如果是这样，向下舍入, 例如1.55 保留一位小数结果为1.5
ROUND_HALF_EVEN
Rounding mode to round towards the "nearest neighbor" unless both neighbors are equidistant, in which case, round towards the even neighbor.
向（距离）最近的一边舍入，除非两边（的距离）是相等,如果是这样，如果保留位数是奇数，使用ROUND_HALF_UP ，如果是偶数，使用ROUND_HALF_DOWN
ROUND_HALF_UP
Rounding mode to round towards "nearest neighbor" unless both neighbors are equidistant, in which case round up.
向（距离）最近的一边舍入，除非两边（的距离）是相等,如果是这样，向上舍入, 1.55保留一位小数结果为1.6
ROUND_UNNECESSARY
Rounding mode to assert that the requested operation has an exact result, hence no rounding is necessary.
计算结果是精确的，不需要舍入模式
ROUND_UP
Rounding mode to round away from zero.
向远离0的方向舍入
printf 的使用
https://www.cnblogs.com/seakt/p/4478045.html
Java高精度使用
BigIngteger 可以表示任意大小的整数，并且可以像使用int类的数字一样进行正常的计算。只不过加减乘除之类的操作都换成了方法调用
String temp1 = "-1000000000000000000000000000000000000";
BigInteger bg1 = new BigInteger(temp1); //注意初始化的方式,使用字符串来初始化
System.out.println(bg1.abs()); //绝对值方法 object.abs()
String temp2 = "100000000000000000000000000";
BigInteger bg2 = new BigInteger(temp2);
System.out.println(bg1.add(bg2)); //加法 object.add(BigInteger b)
System.out.println(bg1.subtract(bg2)); //减法 返回为 bg1 - bg2 (this - param)
System.out.println(bg1.multiply(bg2)); //乘法 返回 bg1 * bg2
System.out.println(bg1.divide(bg2)); //除法 返回bg1 / bg2
System.out.println(bg1.mod(bg2)); //取模运算 返回的是 bg1%bg2 (this mod param)
System.out.println(bg1.gcd(bg2)); //直接封装好了 求解bg1,bg2 的最大公约数
int temp5 = 5;
System.out.println(bg2.pow(temp5)); //乘方运算 注意这个方法的参数是基本类型int
System.out.println(bg2.compareTo(bg1)); // 比较方法 结果为1 bg2大
System.out.println(bg1.compareTo(bg2)); // 结果为-1 bg2大
//这个地方注意比较的方法，还有一个方法是equal()
String temp3 = "1000";
String temp4 = "001000";
BigInteger bg3 = new BigInteger(temp3);
BigInteger bg4 = new BigInteger(temp4);
System.out.println(bg3.compareTo(bg4)); //结果为0 表示相等
System.out.println(bg3.equals(bg4)); //返回结果为true 这样看是没有区别，但是更推荐比较的时候使用compareTo()方法，
//在BigDecimal更直观，例如0.1 与0.10 ，equal返回false 而compareTo则是正确的结果。
关于BigInteger详解链接
https://docs.microsoft.com/zh-cn/dotnet/api/system.numerics.biginteger.one?view=net-6.0
关于BigDecimal详解
image.png
String temp1 = "1.2222222222222222222222222";
BigDecimal bd1 = new BigDecimal(temp1);
String temp2 = "2.333333333333333333333333";
BigDecimal bd2 = new BigDecimal(temp2);
System.out.println(bd1.add(bd2)); // 加法 输出 3.5555555555555555555555552
System.out.println(bd1.add(bd2).doubleValue()); // 输出 3.5555555555555554 这里用了一个方法将结果转化为double类型了
System.out.println(bd2.subtract(bd1)); //减法 输出 1.1111111111111111111111108
System.out.println(bd2.subtract(bd1).doubleValue()); //输出 1.1111111111111112
System.out.println(bd2.multiply(bd1)); //乘法 输出 2.8518518518518518518518513925925925925925925925926
System.out.println(bd2.multiply(bd1).doubleValue()); //乘法 2.8518518518518516
System.out.println(bd2.divide(bd1, 5, RoundingMode.HALF_UP)); //除法应该注意很有可能会有除不尽的情况，这时候会有异常抛出，所以要传入控制参数
System.out.println(bd2.divide(bd1, 5, RoundingMode.HALF_UP).doubleValue()); //输出都是 1.90909
System.out.println(bd1.compareTo(bd2)); //比较方法
BigDecimal bd3 = new BigDecimal("1.20");
BigDecimal bd4 = new BigDecimal("1.2");
System.out.println(bd3.compareTo(bd4)); //返回0表示相等
System.out.println(bd3.equals(bd4)); //返回的是false 是错误的
//所以比较的时候使用compareTo()方法
Java求质数
https://blog.csdn.net/dragon3100/article/details/100426407
https://blog.csdn.net/jinyeran/article/details/114479935
方法一：
双重for循环，使除数和被除数各个计算，效率低
//100之内的质数
public class Main{
public static void main(String []args){
for(int i = 2; i<100; i++){
boolean flag = true;
for(int j = 2; j<i; j++){
if(i%j == 0){
flag = false;
break;
}
}
if(flag){
System.out.println("质数："+i);
}
}
}
}
方法二：
//已知质数的和，求质数及质数个数
以下情况是当质数的和大于5时
L 是输入的质数和
int i = 5;
int sum = 5;//起始质数的和
int n = 2;//起始质数的个数
boolean flag = true;
while(flag){
for(int j=2; j<i; j++){
if(i%j == 0){
break; //先排除不是质数的数
}
if(j == i-1 && sum+j<=L){
System.out.println(i);
sum+=j;
n++;
}
if(sum+j>L){
flag = false;
}
}
i++;
}
System.out.println(n);
方法三：
//num范围内的质数
import java.util.Scanner;
public class Main{
public static void main(String []args){
boolean isPrime = true;
Scanner in = new Scanner(System.in);
System.out.println("请输入一个正整数");
int num = in.nextInt();
if(num>0){
int k = (int)Math.sqrt(num);//num开平方
for(int i = 2; i<=k; i++){
if(num%i == 0){
ifPrime = false;//不是素数
break;
}
}
}
if(isPrime){
System.out.println(num+"是质数");
}else{
System.out.println(num+"不是质数");
}
}
}
方法四：
100范围内的质数
public class Main {
public static void main(String []args){
for(int i = 2; i<=100; i++){
for(int j = 2; j<=i; j++){
if(i%j==0 && i!=j){
break;
}
if(j==i){
System.out.println("质数："+i);
}
}
}
}
}
普遍解法
根据质数的定义，除了1和他本身没有其他的因数，就是质数，所以把数用 2~数本身-1的数字除余，看有没有被整除，如果没有就是质数，这个方法只适用于数较小的情况，数字太大会非常慢
int n = in.nextInt();
for (int i = 2; i < n - 1; i++)
if (n % i == 0){
return false;
}else{
return true;
}
根号解法
int n = nextInt();
for(int i = 2; i <= sqrt(n); i ++){
if(n%i == 0){
return false;
}
}
普通筛选法-
基本思想： 质数的倍数一定不是质数
实现方法： 用一个长度为 n+1 的数组保存信息（0表示质数，1表示非质数，这个不是固定的也可以是1表示质数，0表示和数），从第一个质数2开始，把2 的倍数都标记为非质数（置为1），一直到大于n，然后进行下一趟找到2后面的下一个质数3，进行同样的处理，直到最后数组中依然为0 的数即为质数
public class Main{
public static void main(String []args){
int n = 100,sqrt(int)Math.sqrt(n),sum = 0;
boolean[] isPrime = new boolean[n+1];
isPrime[2] = true;
for(int i = 3; i < n; i+=2)
isPrime[i] = true;
for(int i = 3; i < sqr; i+=2)
if(isPrime[i])
for(int j = i*3;j<=n; j+=i<<1) //排除质数的所有奇数倍
isPrime[j] = false;
for(int i = 2; i<n; i++){
if(isPrime[i])
System.out.println(i+" ")
}
}
}
