JAVA常用类中的方法(持续更新)

Integer类

/**
 * 十进制转二进制
 */
String str = Integer.toBinaryString(n);

String类

String str = "hello world";


/**
 * 获取下标对应的字符
 */
char firstChar = str.charAt(0);


/**
 * 将char[] 转为 Stirng
 */
char[] chars = new char[]{'1','2'};
String str = String.valueOf(chars);


/**
 * String 转 字符Array
 */
char[] charArray = str.toCharArray();


/**
 * 字符串替换(正则表达式，部分字符需要\\转义) 如  '('   ')'    '.'
 */
str = str.replaceAll("\\(\\)", "hello");


/**
 * 字符串截取 包左  不包右
 */
String str1 = str.substring(1);
String str2 = str.substring(0, 1);


/**
 * 字符串分割成数组
 */
str.split(".");


/**
 * 去除首位空格
 */
str = str.trim();


/**
 * Pattern.quote() 将正则表达式转为字面量(非正则匹配)
 * 或者 \\. 来转义
 */
str.split(Pattern.quote("."));

List类

/**
 * list 转 array
 */
List<Integer> list = new ArrayList<>();
Object[] array = idxList.toArray();

Map类

/**
 * entrySet 遍历map
 */
for (Map.Entry entry : map.entrySet()) {

}


/**
 * treeMap  根据key排序的map
 * Character::compareTo   升序
 * Comparator.reverseOrder()  降序排序
 */
Map<Character, Integer> map1 = new TreeMap<>(Character::compareTo);
Map<Character, Integer> map2 = new TreeMap<>(Comparator.reverseOrder());



/**
 * compute: key不存在就插入， value更新为返回值(null则删除)
 *
 * computeIfPresent: key存在 value新为返回值(null则删除)
 *
 * computeIfAbsent: key不存在 执行后面的方法
 */
map.compute("a", (k, v) -> v == null ? 1 : 2);
map.computeIfPresent("a", (k, v) -> ++v);
map.computeIfAbsent("b", k -> 1);

Set

/**
 * 复制一个set
 */
Set<Integer> curSet = new HashSet<>(set);

StringBuffer类

/**
 * 字符串翻转
 */
String str = new StringBuffer(words[i]).reverse().toString();

Arrays类

/**
 * 拷贝数组
 */
int[][] arr = new int[2][3];
int[][] res = arr.clone();


/**
 * 获取最大值
 */
int[] nums = new int[]{1,2,3};
int max = Arrays.stream(nums).max().getAsInt();

/**
 * 排序(降序)
 */
Arrays.sort(nums);



/**
 *  array转stream流， char[] 无法转换
 */
Arrays.stream(nums)

Stream流

/**
 * array 初始化
 */
int[] arr = Stream.of(1,3).mapToInt(Integer::intValue).toArray();


/**
 * list初始化
 */
List<Integer> list = Stream.of(nums[0]).collect(Collectors.toList());


/**
 * list转int[]
 * Integer::intValue  将包装类转为基本数据类型
 */
List<Integer> list = new ArrayList<>();
int[] array = list.stream().mapToInt(Integer::intValue).toArray();



/**
 * int[]  转 set
 * boxed(): 将基本数据类型转为包装类
 */
int[] array = new int[10];
Set<Integer> set = Arrays.stream(array).boxed().collect(Collectors.toSet());


/**
 * sum:累加(需要是数值类型)
 * mapToInt: 转为 int值 
 */
List<Integer> nums = new ArrayList<>();
nums.stream().mapToInt(Integer::intValue).sum();


/**
 * max 获取最大值
 * getAsInt() : OptionalInt转int
 */
int max = Arrays.stream(nums).max().getAsInt();


/**
 * stream流遍历map
 */
map.forEach((key, value) -> {

});


/**
 * 字符串list元素拼接
 */
list.stream().collect(Collectors.joining(" "));

Objects类

/**
 * 判断引用对象是否为null
 */
Objects.isNull(root);

原子类

优势
粒度更细：原子变量可以把竞争范围缩小到变量级别，通常锁的粒度要大于原子变量的粒度
效率更高，除了高度竞争的情况

/**
 * stream中foreach是多线程的，需要修改外部数据需要用原子类
 * 原子类中的原子操作： 操作不可中断，多线程的情况下也可以保证
 * 
 * addAndGet:相加
 */
AtomicInteger sum = new AtomicInteger();
Arrays.stream(nums).forEach(item -> {
	sum.addAndGet(item);
});



/**
 * 自增1(++)
 */
sum.getAndIncrement();

StringUtils

包 ：org.apache.commons.lang3.StringUtils

/**
 *  字符串(左/右)补齐
 */
String str = "abc";
str = StringUtils.leftPad(str, 6, "0");
str = StringUtils.rightPad(str, 6, "0");

Queue

队列，先进先出

Queue<Integer> queue = new LinkedList<>();


/**
 * 入队
 */
queue.add(t);


/**
 * 返回队头
 */
queue.peek();


/**
 * 返回队头并出队
 */
queue.remove()

Stack

先进后出

Stack<Integer> stack = new Stack<>();

/**
 * 入栈
 */
stack.push(1);

/**
 * 出栈
 */
stack.pop();

/**
 * 查看栈顶元素
 */
stack.peek();

Math

/**
 * 向下取整
 */
double num1 = Math.floor(1.55);


/**
 * 向上取整
 */
double num2 = Math.ceil(1.55);


/**
 * 四舍五入取整
 */
double num3 = Math.round(1.55);

Collections

/**
 * 将list元素反转
 */
Collections.reverse(list);