java stl

王鹤淞

已于 2023-12-28 16:23:05 修改

阅读量83

点赞数

于 2023-10-06 14:25:28 首次发布

本文链接：https://blog.csdn.net/wangheson/article/details/133610819

版权

String、StringBuilder、StringBuffer

Map常用api（包括HashMap,TreeMap等）：

String、StringBuilder、StringBuffer

// String
@Test
public void test16() throws Exception {

    String s1 = "HelloWorld";
    // 输出字符串长度
    System.out.println(s1.length());  // 10
    // 获取字符串中某个字符
    System.out.println(s1.charAt(0));  // H
    // 判断字符串是否为空
    System.out.println(s1.isEmpty());  // False
    // 将字符串转化为全小写/全大写 后返回
    System.out.println(s1.toLowerCase());  // helloworld
    System.out.println(s1.toUpperCase());  // HELLOWORLD
    System.out.println(s1);  // HelloWorld
    // 去除字符串前后的空格
    System.out.println("--" + "  he llo  world   ".trim() + "--");  // --he llo  world--
    // 比较字符串
    String s2 = "helloWorld";
    System.out.println(s1.equals(s2));  // false  直接比较字符串内容
    System.out.println(s1.equalsIgnoreCase(s2));  // true  忽略大小写比较字符串内容
    // 字符串连接
    System.out.println(s1.concat("You"));  // HelloWorldYou  等价于+
    // 比较字符串的大小
    System.out.println("abc".compareTo("abcd"));  // -1  负数意味着左边小，正数左边大，0相等
    // 截取字符串 substring(int beginIndex, int endIndex) 左闭右开
    String s3 = "我爱你中国";
    System.out.println(s3.substring(3));  // 中国
    System.out.println(s3.substring(0, 3));  // 我爱你


    System.out.println("-------------------------------------");
    System.out.println(s1);  // HelloWorld
    // 测试此字符串是否以指定的后缀结束
    System.out.println(s1.endsWith("world"));  // false
    // 测试此字符串是否以指定的前缀开始
    System.out.println(s1.startsWith("He"));  // true
    // 测试此字符串从指定索引开始的子字符串是否以指定前缀开始
    System.out.println(s1.startsWith("ll", 2));  // true


    System.out.println("-------------------------------------");
    System.out.println(s1);  // HelloWorld
    // 测试当前字符串是否包含指定的char值序列
    System.out.println(s1.contains("ll"));  // true

    // 返回指定子字符串在此字符串中第一次出现处的索引，没有返回-1
    System.out.println(s1.indexOf("ll"));  // 2
    // 返回指定子字符串在此字符串中第一次出现处的索引，从指定索引开始
    System.out.println(s1.indexOf("ll", 5));  // -1

    // 返回指定子字符串在此字符串最右边出现的索引
    System.out.println(s1.lastIndexOf("o"));  // 6
    // 返回指定子字符串在此字符串最右边出现的索引，从指定索引开始反向搜索
    System.out.println(s1.lastIndexOf("o", 5));  // 4


    System.out.println("-------------------------------------");
    String s4 = "北京欢迎您! 北京欢迎您!";
    // String replace(char a, char b)
    // 返回一个新的字符串，它是通过b替此字符串中出现的所有a得到的
    System.out.println(s4.replace('北', '南'));  // 南京欢迎您! 南京欢迎您!
    // String replace(CharSequence a, CharSequence b)
    // 返回一个新的字符串，它是通过b替此字符串中出现的所有a得到的
    System.out.println(s4.replace("北京", "上海"));  // 上海欢迎您! 上海欢迎您!

    // String replaceAll(String regex, String b)
    // 返回一个字符串，它是通过b替换此字符串所有匹配的正则表达式得到的
    String s5 = "12hello34world5java7891mysql456";
    // hello,world,java,mysql
    System.out.println(s5.replaceAll("\\d+", ",").replaceAll("^,|,$", ""));
    // String replaceFirst(String regex, String b)
    // 返回一个字符串，它是通过b替换此字符串第一个匹配的正则表达式得到的
    // hello,world,java,mysql,
    System.out.println(s5.replaceAll("\\d+", ",").replaceFirst("^,|,$", ""));

    // boolean matches(String regrex)
    // 告知此字符串是否匹配给定的正则表达式
    System.out.println("12345".matches("\\d+"));  // true
    System.out.println("0571-4534289".matches("0571-\\d{7,8}"));  // true

    // String[] split(String regrex)
    // 根据给定正则表达式拆分此字符串
    String s6 = "  good    good study, day day up   ";
    // 去掉前后空格后用空格将字符串分开, \\s+ 会将多个空格看做一个
    String[] strs1 = s6.trim().split("\\s+");
    System.out.println(strs1.length);  // 6
    // String[] split(String regrex, int limit)
    // 根据给定正则表达式拆分此字符串, 最多不超过limit个, 如果超过了, 剩下的放到最后一个元素中
    String[] strs2 = s6.trim().split("\\s+", 3);
    System.out.println(strs2.length);  // 3


    System.out.println("-------------------------------------");
    System.out.println(Integer.parseInt("123"));  // String -> 基本数据类型/包装类
    System.out.println(Double.parseDouble("1.2e9"));  // String -> 基本数据类型/包装类
    System.out.println(String.valueOf(123));  // 基本数据类型/包装类 -> String
    System.out.println(123.1 + "");  // 基本数据类型/包装类 -> String
    // String -> char[]
    String s7 = "123abc";
    char[] chs = s7.toCharArray();
    System.out.println(Arrays.toString(chs));  // [1, 2, 3, a, b, c]
    // char[] -> String
    System.out.println(new String(chs));  // 123abc
    // String -> byte[]
    byte[] bs1 = s7.getBytes();  // 使用默认的字符集进行转化
    System.out.println(Arrays.toString(bs1));  // [49, 50, 51, 97, 98, 99]
    String s8 = "123abc中国";
    byte[] bs2 = s8.getBytes("gbk");  // 使用gbk进行编码
    System.out.println(Arrays.toString(bs2));  // [49, 50, 51, 97, 98, 99, -42, -48, -71, -6]
    // byte[] -> String
    System.out.println(new String(bs1));  // 123abc
    System.out.println(new String(bs2, "gbk"));  // 123abc中国
}

// StringBuilder/StringBuffer
@Test
public void test17() {

    // StringBuilder/StringBuffer和String相同的方法这里不演示了

    StringBuilder sb = new StringBuilder("abc");

    sb.append(1);
    sb.append('2');
    sb.append("345");
    System.out.println(sb);  // abc12345

    sb.delete(2, 4);
    System.out.println(sb);  // ab2345

    sb.replace(2, sb.length(), "hello");
    System.out.println(sb);  // abhello

    sb.insert(2, false);
    System.out.println(sb);  // abfalsehello

    sb.reverse();
    System.out.println(sb);  // olleheslafba

    String s = sb.substring(1, 3);
    System.out.println(s);  // ll
    System.out.println(sb);  // olleheslafba

    sb.setCharAt(0, 'a');
    System.out.println(sb);  // alleheslafba

    /**
     * 总结：
     * (1) 增：append(xxx)
     * (2) 删: delete(int start, int end)
     * (3) 改: setCharAt(int index, char ch) / replace
     * (4) 查: charAt(int index)
     * (5) 长度: length()
     * (6) 遍历: for (char c : sb.toString().toCharArray()) ...
     */
}

常用正则表达式

Java正则表达式校验数字、字母及特殊字符_java数字正则表达式校验-CSDN博客

ArrayList

public void test01() {
    // 定义 ArrayList
    // 定义一个空 ArrayList
    List<Integer> a = new ArrayList<>();
    // 定义一个空 ArrayList，初始容量为3
    List<Integer> b = new ArrayList<>(3);
    // 定义一个包含元素1,2,3 的 ArrayList
    ArrayList<Integer> c = new ArrayList<>(Arrays.asList(1, 2, 3));

    // 遍历 ArrayList
    for (int i = 0; i < c.size(); i++) System.out.print(c.get(i) + " ");
    System.out.println();
    for (int x : c) System.out.print(x + " ");
    System.out.println();

    // 获取 ArrayList 第一个和最后一个元素
    System.out.println(c.get(0));  // 第一个元素：c[0]常用
    System.out.println(c.get(c.size() - 1));  // 最后一个元素

    // 在 ArrayList 尾部添加、删除元素
    c.add(4);
    c.add(0,4);//在0处插入4
    c.remove(c.size() - 1); //参数是index


    // 清空 ArrayList
    c.clear();
    System.out.println(c.size());  // 0

    //转成数组
    //String型的
    List<String> list=new ArrayList<String>();  
	list.add("a");  
	list.add("b");  
	list.add("c");  
	int size=list.size();  
	String[] array = (String[])list.toArray(new String[size]);  
    //非包装类型的
    ArrayList<Integer> al = new ArrayList<>();
    al.add(1);
    al.add(3);
    al.add(5);
    int[] arr = al.stream().mapToInt(k->k).toArray();

}

方法	描述
add()	将元素插入到指定位置的 arraylist 中
addAll()	添加集合中的所有元素到 arraylist 中
clear()	删除 arraylist 中的所有元素
clone()	复制一份 arraylist
contains()	判断元素是否在 arraylist
get()	通过索引值获取 arraylist 中的元素
indexOf()	返回 arraylist 中元素的索引值
removeAll()	删除存在于指定集合中的 arraylist 里的所有元素
remove()	删除 arraylist 里的单个元素
size()	返回 arraylist 里元素数量
isEmpty()	判断 arraylist 是否为空
subList()	截取部分 arraylist 的元素
set()	替换 arraylist 中指定索引的元素
sort()	对 arraylist 元素进行排序
toArray()	将 arraylist 转换为数组
toString()	将 arraylist 转换为字符串
ensureCapacity()	设置指定容量大小的 arraylist
lastIndexOf()	返回指定元素在 arraylist 中最后一次出现的位置
retainAll()	保留 arraylist 中在指定集合中也存在的那些元素
containsAll()	查看 arraylist 是否包含指定集合中的所有元素
trimToSize()	将 arraylist 中的容量调整为数组中的元素个数
removeRange()	删除 arraylist 中指定索引之间存在的元素
replaceAll()	将给定的操作内容替换掉数组中每一个元素
removeIf()	删除所有满足特定条件的 arraylist 元素
forEach()	遍历 arraylist 中每一个元素并执行特定操作

Map：键值对

无序不重复：HashMap

注意是key的值不重复。

import java.util.HashMap;
import java.util.Map;
public class Main {

    public static void main(String[] args) {
        HashMap<Integer, Integer> hash = new HashMap<>();
        // map 中插入、删除元素
        hash.put(1, 11); 
        hash.put(1, 11); 
        hash.put(2, 11); 
        hash.put(1, 33);//注意，此时key为1的值更新为33了，以最新的保存在map中。
        hash.put(3, 33);
        hash.remove(3);
        // 遍历 map，不能使用fori进行遍历
        for (Map.Entry<Integer, Integer> p : hash.entrySet()) System.out.print(p + "\t");
        System.out.println();
        for (int k : hash.keySet()) System.out.print(k + ":" + hash.get(k) + "\t");
        System.out.println();
        for (int v : hash.values()) System.out.print(v + "\t");  // 只遍历值
        System.out.println();
        // map 中判断某元素是否存在
        System.out.println(hash.containsKey(1));  // true
        // 清空 map
        hash.clear();
        System.out.println(hash.size());  // 0
        System.out.println(hash.isEmpty());  // true 
    }
}


1=33    2=11
1:33    2:11
33      11
true
0
true

有序不重复：TreeMap

按key升序，key不重复。

import java.util.TreeMap;
import java.util.Iterator;
import java.util.Map;
public class Main {

    public static void main(String[] args) {
        TreeMap<Integer, Integer> a = new TreeMap<>();
        // map 中插入、删除元素
        a.put(1, 11); a.put(1, 11);a.put(3, 33); a.put(2, 11); a.put(1, 33);
        a.remove(4);
        // 返回第一个和最后一个元素
        System.out.println(a.firstEntry());  
        System.out.println(a.lastEntry());  
        System.out.println(a.firstKey());  // 没有 firstValue() !
        System.out.println(a.firstEntry().getKey());
        System.out.println(a.firstEntry().getValue());

        // 遍历 map，不能使用fori进行遍历
        for (Map.Entry<Integer, Integer> p : a.entrySet()) System.out.print(p + "\t");
        System.out.println();
        for (int k : a.keySet()) System.out.print(k + ":" + a.get(k) + "\t");
        System.out.println();
        for (int v : a.values()) System.out.print(v + "\t");  // 只遍历值
        System.out.println();
        Iterator<Map.Entry<Integer, Integer>> it = a.entrySet().iterator();
        while (it.hasNext()) {
            Map.Entry<Integer, Integer> e = it.next();
            System.out.print(e.getKey() + "~" + e.getValue() + "\t");
        }

        // map 中判断某元素是否存在
        System.out.println(a.containsKey(1));  // true
        // ceilingKey/higherKey
        System.out.println(a.ceilingKey(2));  // 返回大于等于 key为2的值 的最小元素
        System.out.println(a.higherKey(2));  // 返回大于key为2的值的最小元素
        // 补充：floorKey/lowerKey
        System.out.println(a.floorKey(3));  // 返回小于等于key为3的值的最大元素
        System.out.println(a.lowerKey(3));  // 返回小于key为3的值的最大元素
        
        // 清空 map
        a.clear();
        System.out.println(a.size());  // 0
        System.out.println(a.isEmpty());  // true 
    }
}

Map常用api（包括HashMap,TreeMap等）：

clear()	从 Map 中删除所有映射
remove(Object key)	从 Map 中删除键和关联的值
put(Object key, Object value)	将指定值与指定键相关联
putAll(Map t)	将指定 Map 中的所有映射复制到此 map
entrySet()	返回 Map 中所包含映射的 Set 视图。Set 中的每个元素都是一个 Map.Entry 对象，可以使用 getKey() 和 getValue() 方法（还有一个 setValue() 方法）访问后者的键元素和值元素
keySet()	返回 Map 中所包含键的 Set 视图。删除 Set 中的元素还将删除 Map 中相应的映射（键和值）
values()	返回 map 中所包含值的 Collection 视图。删除 Collection 中的元素还将删除 Map 中相应的映射（键和值）
getOrDefault()	获取指定 key 对应对 value，如果找不到 key ，则返回设置的默认值
containsKey(Object key)	如果 Map 包含指定键的映射，则返回 true
containsValue(Object value)	如果此 Map 将一个或多个键映射到指定值，则返回 true
isEmpty()	如果 Map 不包含键-值映射，则返回 true
size()	返回 Map 中的键-值映射的数目

集合与数组相互转换

List与数组

//一维
int[] arrays = list.stream().mapToInt((Integer i)->i).toArray();

//二维
List<int[]> merged = new ArrayList<int[]>();
//。。。。。。。。
int[][] res=merged.toArray(new int[merged.size()][]);

//String类型
String[] strs = (String[]) list.toArray(new String[0]);
ArrayList<String> arrayList = new ArrayList<String>(Arrays.asList(arrays));

//int[]转List
int[] data = {4, 5, 3, 6, 2, 5, 1};
        
// int[] 转 List<Integer>
List<Integer> list1 = Arrays.stream(data).boxed().collect(Collectors.toList());
// Arrays.stream(arr) 可以替换成IntStream.of(arr)。
// 1.使用Arrays.stream将int[]转换成IntStream。
// 2.使用IntStream中的boxed()装箱。将IntStream转换成Stream<Integer>。
// 3.使用Stream的collect()，将Stream<T>转换成List<T>，因此正是List<Integer>。

List，Set，Map之间

new ArrayList<>(hashSet);
new HashSet<>(list);
new ArrayList<>(map.values());

位运算
一篇搞定位运算——java位运算详解_java 位运算取第一个0_青癯的博客-CSDN博客https://blog.csdn.net/qq_42265220/article/details/118386893

n&（n-1）可以消去n最右边的1，也可以通过是否==0判断n是否是2的次方

王鹤淞

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java stl

注意是key的值不重复。
复制链接

扫一扫

java stl

String、StringBuilder、StringBuffer

常用正则表达式

ArrayList

Map：键值对

无序不重复：HashMap

有序不重复：TreeMap

Map常用api（包括HashMap,TreeMap等）：

集合与数组相互转换

List与数组

List，Set，Map之间

位运算一篇搞定位运算——java位运算详解_java 位运算 取第一个0_青癯的博客-CSDN博客https://blog.csdn.net/qq_42265220/article/details/118386893

位运算
一篇搞定位运算——java位运算详解_java 位运算取第一个0_青癯的博客-CSDN博客https://blog.csdn.net/qq_42265220/article/details/118386893