目录
一、Map类
- Map<String,Integer> mp1=new HashMap<>(); 实现快速查找
- Map<String,Integer> mp2=new TreeMap<>(); 保证元素字母顺序排列的map
- Map<String,Integer> mp3=new LinkedHashMap<>(); 保证插入顺序的map
1、HashMap
Map<Integer,Integer> mp=new HashMap<>();
Map<Character,Integer> mp=new HashMap<>();
//将key-value添加到map中
mp.put(key值,val值);
char ch;
mp.put(ch,mp.getOrDefault(ch,0)+1); //相当于mp[ch]++;
mp.put(ch,mp.getOrDefault(ch,0)-1); //相当于mp[ch]--;
mp.putAll(Map m); //将m中的所有key-value添加到map中
mp.remove(key); //删除key-val对
mp.clear(); //清空
mp.getOrDefault(key,0); //获取key值所对应的value值 如果不存在返回0
//查询是否存在key或value值
mp.containsKey(key);
mp.containsValue(Value);
mp.replace(key,value) //替换指定key对应的value值
mp.replace(key,oldValue,newValue) //当指定key的对应的value为指定值时 替换该值为新值
mp.size();
mp.isEmpty();
//map套set、list等
Map<Integer,Set<Integer>> mp=new HashMap<>();
Map<String,List<Integer>> mp=new ArrayList<>();
mp.computeIfAbsent(id,key->new HashSet<>()).add(val);
//如果mp中存在id，则对id所对应的value值进行操作
//如果mp中不存在id，会创建一个满足Value类型的数据结构放到Value的位置中
mp.computeIfAbsent(name,k->new ArrayList<>()).add(val);2、TreeMap - 补充
TreeMap中的元素默认按照keys的自然排序排列。
- 对Integer来说，其自然排序就是数字的升序
- 对String来说，其自然排序就是按照字母表排序
TreeMap<Integer,String> mp = new TreeMap<>();
//按key值从大到小排列
TreeMap<Integer,String> mp = new TreeMap<>(Comparator.reverseOrder());
mp.ceilingEntry(key) //返回大于等于key的最小元素，不存在则返回null
mp.floorEntry(key) //返回小于等于key的最大元素，不存在则返回null
3、遍历
（1）entry法
for(Map.Entry<String,String> x: map.entrySet())
{
String Key = x.getKey();
String Value = x.getValue();
System.out.println(Key + "：" + Value);
}（2） 只输出key或value时
// 打印键集合
for (String key : map.keySet())
System.out.println(key);
// 打印值集合
for (String value : map.values())
System.out.println(value);（3）将map转化为set输出
Set st=mp.keySet();
System.out.print(st);二、Set类
由不能重复得相同类型元素构成的集合
- Set<String> s1=new HashSet<>(); 实现快速查找
- TreeSet<String> s2=new TreeSet<>(); 保证元素字母顺序排列的set
- Set<String> s3=new LinkedHashSet<>(); 保证插入顺序的set
1、HashSet
Set<Integer> st=new HashSet<>();
st.add(val); //添加
st.addAll(st1);
st.remove(val); //删除
st.clear(); //清空
st.size(); //大小
st.isEmpty(); //判空
st.contains(val); //查找指定元素是否存在
st.containsAll(st1);
st.retainAll(st2); //取交集2、TreeSet - 补充
TreeSet<Integer> st=new TreeSet<>();
TreeSet<Integer> st = new TreeSet<>(Comparator.reverseOrder()); //倒序
st.first(); //返回第一个元素
st.last(); //返回最后一个元素
st.pollFirst(); //返回并删除第一个元素
st.pollLast(); //返回并删除最后一个元素
st.floor(x); //返回最后一个≤x的元素
st.ceiling(x); //返回第一个≥x的元素
st.lower(x); //返回最后一个<x的元素
st.higher(x); //返回第一个>x的元素三、栈 Stack
1、定义
Deque<Integer> stack=new LinkedList<>();2、相关操作
stack.push(x); //入栈
stack.pop(); //出栈 删除并返回栈顶值
res=stack.pop();
stack.peek(); //返回栈顶值
stack.isEmpty(); //判空
stack.clear(); //清空四、队列 Queue
1、定义
Queue<Integer> q=new LinkedList <>();
Queue<int[]> q=new LinkedList <>(); //{i,j}2、相关操作
//入队 offer
q.offer(x);
q.offer(new int[] {i,j});
//出队 poll
q.poll();
//取队头元素
q.peek();
//队伍长度
q.size();
//判空
q.isEmpty();
//清空
q.clear();
3、优先队列PriorityQueue - 补充
PriorityQueue<Integer> q=new PriorityQueue<>(); //默认小顶堆
PriorityQueue<Integer> q=new PriorityQueue<>((a,b)->(b-a)); //大顶堆
q.contains(val);
Integer[] t=q.toArray(new Integer[n]); //将队列转化为数组
4、双端队列 - 补充
Deque<Integer> q=new ArrayDeque<>();
offerFirst(): 向队头插入元素，如果插入成功返回true，否则返回false
offerLast(): 向队尾插入元素，如果插入成功返回true，否则返回false
pollFirst(): 返回并移除队头元素，如果队列无元素，则返回null
pollLast(): 返回并移除队尾元素，如果队列无元素，则返回null
peekFirst(): 获取队头元素但不移除，如果队列无元素，则返回null
peekLast(): 获取队尾元素但不移除，如果队列无元素，则返回null五、List
1、定义
List<Integer> list2 = new ArrayList<Integer>();
list.add(val); //添加元素
list2.addAll(list); //拷贝
list.add(1,245);
list.add(idx,val); //在某位置插入元素
list.get(i); //获取元素
list.remove(1); //移除某位置的元素
list.set(i,val); //将第i个元素设置为val
Collections.sort(list); //升序排序
Collections.sort(list,Collections.reverseOrder()); //降序排序
int idx = list.indexOf(66);
int idx = list.lastIndexOf(66); //求某个元素首次/最后一次出现的位置
list.size();
list.clear();
list.isEmpty();2、list自定义排序
list.sort(new Comparator<int[]>(){
public int compare(int[] o1,int[] o2)
{
if(o1[0]!=o2[0]) return o1[0]-o2[0]; //从大到小
if(o1[1]!=o2[1]) return o1[1]-o2[1];
return o1[2]-o2[2];
}
}); 3、浅拷贝和深拷贝
res.add(list)为浅拷贝，后续list内容的变化会导致res的变化，在原来地址改变数据，内容肯定会被改变res.add(new ArrayList(list))为深拷贝，对象中开辟一个新地址，存放的内容为list链表，所以后续不会被影响。
https://www.jianshu.com/p/575d38381baf
4、二维List
List<Integer>[] g=new ArrayList[n+1];
for(int i=0;i<n;i++) g[i]=new ArrayList<>();
for(int[] e:edges)
{
g[e[0]].add(e[1]);
g[e[1]].add(e[0]);
}六、StringBuilder
==只能比较两个字符串的内存地址是否一样，不能比较字符串内容
1、定义
StringBuilder s = new StringBuilder();2、字符串链接append
s.append(String str);
s.append(Char c);3、替换setCharAt
s.setCharAt(int i,char c);//将第 i 个代码单元替换为 c4、插入insert——在指定位置之前插入字符串
insert(int idx, String str);
insert(int idx, Char c); //在指定位置之前插入字符(串)5、删除delete
s.delete(int startidx,int endidx);
//删除起始位置（含）到结尾位置（不含）之间的字符串6、翻转reverse
s.reverse();七、数组Arrays
1、求最大最小值
//求数组中的最大值
//意思是将nums数组转化为stream流然后得到流中的最大值，最后再以int类型获取
int max = Arrays.stream(nums).max().getAsInt();
//求数组中的最小值
//意思是将nums数组转化为stream流然后得到流中的最小值，最后再以int类型获取
int min = Arrays.stream(nums).min().getAsInt();
2、求数组和
//nums为数组
int sum = Arrays.stream(nums).sum();
3、Arrays.fill()
Arrays.fill(f,0);
Arrays.fill(f, begin, end, val); //将[begin,end)范围内所有元素初始化为val4、Arrays.sort()
Arrays.sort(a); //从小到大
Arrays.sort(a,begin,end);
//从大到小
Arrays.sort(a,0,n);
for(int i=0,j=n-1;i<j;i++,j--)
{
int t=a[i];
a[i]=a[j];
a[j]=t;
}5、Arrays.equal()
Arrays.equal(arr1,arr2);6、Arrays.toString()
Arrays.toString(arr);7、Arrays.asList()
Arrays.asList(1,2,3); //将数组转化为List8、Arrays.copyOfRange()
Arrays.copyOfRange(arr,begin,end); //要拷贝的数组范围[begin,end)八、进制转换
（1）十进制 → 二、八、十六
| 进制转换方向 | API | 备注 |
| 十转二 | Integer.toBinaryString(s) | 返回值都是字符串 |
| 十转八 | Integer.toOctalString(s) | |
| 十转十六 | Integer.toHexString(s) | |
| 十转任意 | Integer.toString(数字，进制数) |
（2）二、八、十六 → 十进制
Integer.parseInt((String) s,(int) a);
a进制的字符串s转为十进制
(返回Integer类型）
九、BigInteger
（1）加减乘除方法
| 方法 | 含义 |
| BigInteger(String val) | 根据参数指定的字符串来构造对象 |
| BigInteger add(BigInteger val) | 加法 |
| BigInteger subtract(BigInteger val) | 减法 |
| BigInteger multiply(BigInteger val) | 乘法 |
| BigInteger divide(BigInteger val) | 除法 |
| BigInteger remainder(BigInteger val) | 取余 |
| BigInteger[] divideAndRemainder(BigInteger val) | 用于实现取商和余数的运算 |
（2）BigInteger类型转换
public void testToAnother() {
BigInteger bigNum = new BigInteger("36");
int radix = 2;
//1.转换为bigNum的二进制补码形式
byte[] num1 = bigNum.toByteArray();
//2.转换为bigNum的十进制字符串形式
String num2 = bigNum.toString(); //36
//3.转换为bigNum的radix进制字符串形式
String num3 = bigNum.toString(radix); //100100
//4.将bigNum转换为int
int num4 = bigNum.intValue();
//5.将bigNum转换为long
long num5 = bigNum.longValue();
//6.将bigNum转换为float
float num6 = bigNum.floatValue();
//7.将bigNum转换为double
double num7 = bigNum.doubleValue();
}（3）其他方法
- pow(exp)方法，这个函数的作用是将大整数取exp的指数
- gcd()方法，这个函数的作用是将两个大整数取最大公约数
- abs()方法，这个函数的作用是取绝对值
- negate()方法，这个函数的作用是取数的相反数
- mod()方法，这个函数的作用是对数进行取余
- max()方法，min()方法，分别是比较两个数的大小
- compareTo()，这个方法是用来比较两个大整数大小的
- equals()方法，判断两个大整数是否相等
package com.bigInterger;
import java.math.*;
public class bigInterger {
public static void main(String[] args) {
BigInteger b1 = new BigInteger("9");
BigInteger b2 = new BigInteger("6");
BigInteger b3 = new BigInteger("-3");
// 转换成int类型以后才能使用+，-，*，/ 此时准换后相当于真int
System.out.println(b1.intValue() + 3);//12
// 加法
System.out.println(b1.add(b2));//15
// 减法
System.out.println(b1.subtract(b2));//3
// 乘法
System.out.println(b1.multiply(b3));//-27
// 除法整除
System.out.println(b1.divide(b2));//1
// 除法带余数 返回一个数组，保存商和余数
BigInteger b4[] = b1.divideAndRemainder(b2);
System.out.println(b4[0]);//1
System.out.println(b4[1]);//3
//remainder()与mod()-------取余
System.out.println(b1.remainder(b2));//3
System.out.println(b1.mod(b2));//3
//negate()------取相反数
System.out.println(b1.negate());//-9
//abs()------取绝对值
System.out.println(b3.abs());//3
//min(),max()------取最大与最小值
System.out.println(b1.min(b2));//6
System.out.println(b1.max(b2));//9
//gcd()------取最大公约数
System.out.println(b1.gcd(b2));//3
BigInteger bi = new BigInteger("1234567890");
System.out.println(bi.pow(5)); // 2867971860299718107233761438093672048294900000
BigInteger n = new BigInteger("999999").pow(99);
float f = n.floatValue();
System.out.println(f);//Infinity
// 和long型整数运算比，BigInteger不会有范围限制，但缺点是速度比较慢。
// 也可以把BigInteger转换成long型：
BigInteger i = new BigInteger("123456789000");
System.out.println(i.longValue()); // 123456789000
System.out.println(i.multiply(i).longValueExact()); // java.lang.ArithmeticException: BigInteger out of long range
}
}
十、保留小数
（1）String的format方法
double f = 111231.5585;
System.out.println(String.format(“%.2f”, f));（2）DecimalFormat的format方法
double f = 111231.5585;
DecimalFormat df = new DecimalFormat(“#.00”); System.out.println(df.format(f));
493
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
