机试一些常见技巧，持续更新中...

news2024/10/11 23:21:53

对字符串的操作

对单个字符串排序

char[] sourceArray = str.toCharArray();
Arrays.sort(sourceArray);
String sourceArrayStr = new String(sourceArray);

对字符串去重(不使用 list)

public static String ARFA2(String str) {
   StringBuffer sb = new StringBuffer();
   for (int i = 0; i < str.length(); i++) {
       // 比如 acqafa，遍历到第二个a，此时 str.indexOf(str.charAt(i)) 等于0，就不会添加到 StringBuffer
       if (str.indexOf(str.charAt(i))==i) {
           sb.append(str.charAt(i));
       }
   }
   return sb.toString();
}

对 list 中的字符串排序

List<String> list = Arrays.asList("aa", "cae", "eef", "dee", "bbae");
list.sort(Comparator.comparing(String::toLowerCase)); // toUpperCase 结果也是一样..
// 或者用这个 Collections.sort(list);
System.out.println(list);// 输出 [aa, bbae, cae, dee, eef]

对 map 分别对 key 和 value 排序

// 按值降序排序后的 map,降序排序要返回LinkedHashMap对象才有效
LinkedHashMap<Character, Integer> linkedHashMap = map.entrySet().stream().sorted(Collections.reverseOrder(Map.Entry.comparingByValue())).collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (e1, e2) -> e1, LinkedHashMap::new));
HashMap<Character, Integer> collect = map.entrySet().stream().sorted(Map.Entry.comparingByKey()).collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (e1, e2) -> e1, HashMap::new));

对于map，因为排序后也不能直接取出第一个数，所以也可以使用另外的方式

List<Integer> list = new ArrayList<>(map.keySet());
list.sort((o1, o2) -> o2 - o1); //降序
return map.get(list.get(0));// 返回第一个元素

把字符串反转
StringBuilder 和 StringBuffer 都提供了 reverse() 方法，可以方便地反转字符串

String reversed = new StringBuilder(original).reverse().toString();

还可以下面这样

String s = "abcdefg";
List<String> list = s.chars().mapToObj(c->(char)c).map(String::valueOf).collect(Collectors.toList());//s.chars()是转成十进制了
Collections.reverse(list);
String str = list.stream().collect(Collectors.joining());

判断字符串是不是纯数字组成

public static boolean isNumeric(String str){
    Pattern pattern = Pattern.compile("[0-9]*");
    return pattern.matcher(str).matches();
}

判断是否是纯字符串，直接用API就好

public static boolean isCharacter(String str){
    for (char ch : str.toCharArray()) {
        if (!Character.isLetter(ch)) {
            return false;
        }
    }
    return true;
}

给定一字符串，按固定长度分割，比如abcde，2位长度分割，ab、bc、cd、de

// 用一个list来装
List<String> list = new ArrayList<>();
for (int i=0; i<=str.length()-len; i++) {
    String substring = str.substring(i ,len + i);
    list.add(substring);
}

更常用的是下面这种，从1分割到字符串等长的

for (int len = 1; len <= shortStr.length(); len++) {
    for (int i = 0; i <= shortStr.length()-len; i++) {
        String substring = shortStr.substring(i, i + len);
    }
}

字符串转整型

String str = "12345";
int res = 0;
for (char ch : str.toCharArray()) {
    res = 10 * res + (ch - '0'); //防止溢出
}

list 转数组-字符串

List<String> list = List.of("aa", "bb", "cc", "dd", "ee");
String[] arr = list.toArray(new String[0]);

list 转数组-整型

List<Integer> list = List.of(1, 2, 3, 4, 5, 6);
int[] arr = list.stream().mapToInt(Integer::intValue).toArray();

数组转list，转换后的list支持增删改查

String[] arr = {"1", "2", "3", "4", "5"};
List<String> list1 = new ArrayList<>(arr.length);
Collections.addAll(list1, arr);

// 或者使用 stream
String[] arr = {"1", "2", "3", "4", "5"};
List<Integer> list = Arrays.stream(arr).mapToInt(Integer::parseInt).boxed().collect(Collectors.toList());

分组排序

List<String> list = Arrays.asList("aaa", "bb", "s32", "sdjfkl");
Map<Integer, List<String>> map = list.stream().collect(Collectors.groupingBy(String::length));

字符串判空

String s = "hello,world";
// 之前的做法
if (s != null) {
    System.out.println(s);
}
// 现在
Optional.ofNullable(s).ifPresent(System.out::println);

Java中保留两位小数的多种写法

BigDecimal bd = new BigDecimal("3.2323455");
bd = bd.setScale(3, RoundingMode.HALF_UP);
System.out.println(bd);

DecimalFormat df = new DecimalFormat("0.00");
df.setRoundingMode(RoundingMode.HALF_UP);
System.out.println(df.format(0.2323));

NumberFormat nf = NumberFormat.getNumberInstance();
nf.setMaximumFractionDigits(2);
/*
* setMinimumFractionDigits设置成2
*
* 如果不这么做，那么当value的值是100.00的时候返回100
*
* 而不是100.00
*/
nf.setMinimumFractionDigits(2);
nf.setRoundingMode(RoundingMode.HALF_UP);
/*
* 如果想输出的格式用逗号隔开，可以设置成true
*/
nf.setGroupingUsed(false);
System.out.println(nf.format(47.20000));

String s = new Formatter().format("%.2f", 47.000).toString();
System.out.println(s);

String res = String.format("%.2f", 3.1415).toString();
System.out.println(res);