什么是BigDecimal？

Java在java.math包中提供的API类BigDecimal，用于精确计算16位以上有效位数。

双精度浮点变量double可处理16位有效数。在实际应用中，需要计算和处理更大或更小的数字。

float和double科学计算或工程计算只能用于商业计算java.math.BigDecimal。

BigDecimal创建的是对象，不能用传统的 、-、*、/等算术运算符直接对其对象进行数学运算，必须调用相应的方法。方法中的参数也必须是BigDecimal对象。构造器是专门用来创建对象的特殊方法，特别是有参数的对象。

BigDecimal(int)       创建具有参数指定的整数值的对象。  BigDecimal(double) 创建具有参数指定的双精度值的对象。 ///不推荐使用 BigDecimal(long)    创建具有参数指定的长整数值的对象。  BigDecimal(String) 创建具有参数指定的字符串所表示的值的对象。//建议使用 

add(BigDecimal)        BigDecimal加入对象中的值，然后返回对象。  subtract(BigDecimal) BigDecimal对象中的值相减，然后返回对象。  multiply(BigDecimal)  BigDecimal对象中的值相乘，然后返回对象。  divide(BigDecimal)     BigDecimal除去对象中的值相，然后返回对象。  toString()                将BigDecimal对象的值转换为字符串。  doubleValue()          将BigDecimal对象中的值以双精度数返回。  floatValue()             将BigDecimal对象中的值以单精度数返回。 
longValue()             将BigDecimal对象中的值以长整数返回。 
intValue()               将BigDecimal对象中的值以整数返回。

Integer.parseInt(s)与Integer.valueOf(s)的联系

Integer.parseInt(s)是把字符串解析成int基本类型，Integer.valueOf(s)是把字符串解析成Integer对象类型，其实int就是Integer解包装，Integer就是int的包装，在jdk8中已经自动实现了自动解包装和自动包装，所以两种方式都能得到想要的整数值。

1. Integer.parselnt(S)：将字符串转换为有符号的int基本类型

2. Integer.valueOf(s):将字符串转换为integer类型

• 有什么区别呢？

当使用parselnt（）时，如果比较两个相同的数，可以直接用==号

但是如果使用valueOf（）时，则不行，当比较内容是否相等时，使用isequal，比较对象是否相等时，使用==

https://blog.csdn.net/u010502101/article/details/79162587

字符串转数字：Integer.parseInt(s)vsInteger.valueOf(s)

​ 转成int基本类型 转成Integer类型

• 设置calendar的值求日期

calendar.set(calendar.YEAR, i);//set方法，两个参数（设置的项，甚至的值）
calendar.set(calendar.MONTH, 11);//从0开始记数，1月=0，12月=11
calendar.set(calendar.DAY_OF_MONTH, 31);//设置日期，31号
System.out.println(i+" "+calendar.get(calendar.DAY_OF_WEEK));//验证1999年12月31日 星期五 是不是 6

System.out.println(String.format("%.2f",2.2222));//2.22
System.out.println(String.format("%02d:%02d:%02d",hour,minutes,second));
//首先字符串格式化用string.format(" ",v1),%d代表整型，%f浮点数，%s字符串

基本数据类型

• 分析hashset底层是HashMap，hashmap的底层是（数组+链表+红黑树）

tips：

为什么要设计成数组加链表的形式，主要还是为了提高效率。

结论

1.HashSet底层是HashMap

2.添加一个元素时，会先得到hash值，会转化为索引值

3.找到存储数据表table，看这个索引位置是否已经有存放的元素

4.如果没有，直接加入

5.如果有，则调用equals比较，如果相同就放弃添加，如果不相同则添加到下一个

6.在java8中，如果一条链表的元素个数达到TREEIFY_THRESHOLD（8），并且table的大小大于等于MIN_TREEIFY_CAPACITY（默认64）就会进行树化

1.HashSet底层是HashMap,第一次添加时，table数组扩容到16，临界值(threshold)是16**加载因子(loadFactor)0.75=12.*

2.如果table数组使用到了临界值12，就会扩容到162=32，新的临界值就是320.75=24,依次类推

3.在Java8中，如果一条链表的元素个数到达TREEIFY THRESHOLD(默认是8)，并且tablel的大小>=]MIN TREEIFY CAPACITY(默认64)，就会进行树化（红黑树），否则仍然采用数组扩容机制

Map接口实现类的特点[很实用]
注意：这里讲的是JDK8的Map接口特点
1)Map与Collection并列存在。用于保存具有映射关系的数据：Key-Value
2)Map中的key和value可以是任何引用类型的数据，会封装到HashMaps$Node对象中
3)Map中的key不允许重复，原因和HashSet一样，前面分析过源码.(会替换)
4)Map中的value可以重复
5)Map的key可以为nul,value也可以为null,注意key为null,只能有一个，value为null,可以多个.
6)常用String类作为Map的key
7)key和value之间存在单向一对一关系，即通过指定的key总能找到对应的value
8)Map存放数据的key-value示意图，一对k-v是放在一个Node中的，有因为Node实现了Entry接口，有些书上也说一对k-就是一个Entry(如图)[代码演示]

Map cache =new HashMap ()

查询：cache.map(obj key)

插入键值对：cache.put(obj key,V)

删除：cache.remove

sortedSet=new TreeSet()

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PSDGUZI5-1651584189607)(算法基础（可能Img/image-20220404171646284.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5VbKS7ZK-1651584189607)(算法基础（可能Img/image-20220403144433632.png)]

数字转换为字符串方法二：

String _a = a + "", _b = b + "", _c = c + "";

package Data_structures_algorithms;

import 第11届蓝桥杯JavaB组第1场省赛2020_7_5.Main;

import java.util.HashSet;
import java.util.Set;

public class dfs { 
        //全排列模板
    static Set<String> set=new HashSet<String>();
    public static void dfs1(char[] a,int k){ 
        //字符数组，起始位置？？
        if (k==a.length){ 
        //形成一个排列
            //注意！！这里完成你想要的动作
            String s=new String(a);//用char数组生成一个字符串
                set.add(s);//set去重
        }
        for(int i=k;i<a.length;i++){ 
        
            char t=a[k];//交换，确定这一位
            a[k]=a[i];
            a[i]=t;
            dfs1(a,k+1);
            t=a[k];
            a[k]=a[i];//回溯。恢复到探测之前的状态
            a[i]=t;
        }
    }

    public static void main(String[] args) { 
        
        char[] a={ 
        'A','B','C'};
        dfs1(a,0);
        for(String x:set){ 
        
            System.out.println(x);
        }
    }
}

package provincialGames_04_2013_JavaB;
 
public class A09_全排列 { 
         // 全排列模板——整数数组
 
	// 数字型、字符串、含重复元素的全排列 子集的生成、真子集、集合
	
	public static void main(String[] args) { 
        
		int arr1[] = { 
         1, 2, 3, 4, 5, 6, 7, 8, 9 };
		int arr2[] = { 
         1, 2, 3 };
		f(arr1, 0);
	}
 
	// 确认某一个排列的第k位
	private static void f(int[] arr, int k) { 
        
		if (k == arr.length) { 
         // 全部确认
			for (int x : arr) { 
        
				System.out.print(x);
			}
			System.out.println();
			return;
		}
		for (int i = k; i < arr.length; i++) { 
         // 选定第k位，
			// 将第i位和第k位交换
			int t = arr[i];
			arr[i] = arr[k];
			arr[k] = t;
 
			f(arr, k + 1); // 移交下一层去确认k+1位
 
			// 回溯（换回来）
			t = arr[i];
			arr[i] = arr[k];
			arr[k] = t;
		}
	}
 
}

public class 不同字串 { 
        
    public static void main(String[] args) { 
        
        String a="0100110001010001";
        Set<String> set=new HashSet<>();
        int n=a.length();
        for (int i = 0; i < n; i++) { 
        
            for (int j = i; j < n; j++) { 
        
                String substring = a.substring(i, j + 1);
                set.add(substring);
            }
        }
        for (String s : set) { 
        
            System.out.println(s);
        }
    }
}

package q2019;

import java.util.Scanner;
// 1:无需package
// 2: 类名必须Main, 不可修改
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.Queue;

public class migong { 
        
    static int N =(int)1e2+10;
    static int dir[][]= { 
        { 
        0,1},{ 
        -1,0},{ 
        1,0},{ 
        0,-1}};
    static int n;
    static int m;
    static boolean f[][]=new boolean[N][N];
    static int sx;
    static int sy;
    static int ex;
    static int ey;
    static int str[][]=new int[N][N];
    static int bfs(int sx,int sy,int ex,int ey) { 
        
        Queue<Node> q=new LinkedList();
        q.offer(new Node(sx,sy,0));
        f[sx][sy]=true;
        while(!q.isEmpty()) { 
        
            int x=q.peek().x;
            int y=q.peek().y;
            int step=q.peek().step;
            q.poll();
            if(x == ex && y == ey)//z终点
                return step;
            for(int i=0;i<4;i++) { 
        
                int xx=x+dir[i][0];
                int yy=y+dir[i][1];
                if(xx >= 0 && xx <n && yy >= 0 && yy < m && str[xx][yy]==1&&!f[xx][yy])
                { 
        
                    f[xx][yy] = true;
                    q.offer(new Node(xx, yy,step+1));
                }
            }
        }
        return -1;
    }

    public static void main(String[] args) throws IOException { 
        
        // TODO 自动生成的方法存根
        Scanner in=new Scanner(System.in);
        n=in.nextInt();
        m=in.nextInt();
        for(int i=0;i<n;i++) { 
        
            for(int j=0;j<m;j++) { 
        
                str[i][j]=in.nextInt();
            }
        }
        sx=in.nextInt();
        sy=in.nextInt();
        ex=in.nextInt();
        ey=in.nextInt();
        System.out.println(bfs(sx-1,sy-1,ex-1,ey-1));
    }
    static class Node { 
        
        int x;
        int y;
        int step;
        public Node(int x, int y,int step) { 
        
            super();
            this.x = x;
            this.y = y;
            this.step=step;
        }

    }

}