Java刷题常见的集合类,各种函数的使用以及常见的类型转化等等

前言

相信大家在刷算法题的过程中,好不容易想出来大概的思路,也知道去用哪个集合类,但各个集合类的一些命令都长得太像,很容易将他们弄错,并且在各集合之间的转化也是特别烦人,还有很多实用的函数都知道可以去用,但总是会忘记。

本篇将会把刷题中常见的,实用的集合类的功能和各类函数都将详细说明(后续遇到慢慢补充)


集合类

ArrayList

1. 创建和初始化 ArrayList

ArrayList<Integer> list = new ArrayList<>();

默认容量为10

2.添加元素  add

添加单个元素(常用)

        list.add(1);list.add(2);list.add(3);list.add(4);list.add(5);//list{1 2 3 4 5}

在指定位置添加元素: 

        list.add(1);list.add(2);list.add(3);list.add(4);list.add(5);list.add(0,10);  // [10, 1, 2, 3, 4, 5]

3.获取元素 get

获取指定索引位置的元素

        list.add(1);list.add(2);list.add(3);list.add(4);list.add(5);int element = list.get(1);  // 获取索引为 1 的元素  2

4.删除元素 remove

boolean contains = list.contains(10);  // 检查是否包含值为 10 的元素 false
        list.add(1);list.add(2);list.add(3);list.add(4);list.add(5);list.remove(0); // 2 3 4 5list.remove(list.size()-1); // 2 3 4

5.检查元素

1)检查集合是否包含某个元素

boolean contains = list.contains(10);  // 检查是否包含值为 10 的元素 false

 2)检查集合是否为空

boolean isEmpty = list.isEmpty();  // 检查 ArrayList 是否为空

 6.遍历 ArrayList

1)使用普通 for 循环遍历

for (int i = 0; i < list.size(); i++) {System.out.println(list.get(i));  // 访问每一个元素
}

2)使用增强 for 循环遍历: 

for (Integer num : list) {System.out.println(num);
}

3)使用迭代器遍历: 

Iterator<Integer> iterator = list.iterator();
while (iterator.hasNext()) {System.out.println(iterator.next());
}

LinkedList

LinkedList和ArrayList命令上大体相同,他们都实现了List<E>接口

LinkedList 实现了 QueueDeque 接口,可以用作队列(FIFO)和栈(LIFO):


Stack

1. 创建Stack对象

用于创建一个新的栈,常用于存储数字、字符或其他对象。

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

2. 压入元素 (push

push(E item)方法用于将元素推入栈顶。

stack.push(10);
stack.push(20);
stack.push(30);
// 10 20 30

 3. 弹出元素 (pop)

pop()方法用于移除并返回栈顶元素。如果栈为空,调用该方法会抛出EmptyStackException异常。需要注意栈为空时使用时需检查栈是否为空,避免异常。

int topElement = stack.pop(); // 30

 4. 查看栈顶元素 (peek)

peek()方法用于查看栈顶元素,但不会移除它。如果栈为空,同样会抛出EmptyStackException异常。

int topElement = stack.peek(); // stack{10,20} 20 

 5. 检查栈是否为空 (empty)

 empty()方法返回true如果栈为空,false如果栈不为空。这个方法在判断栈是否可以继续操作时非常有用。

boolean isEmpty = stack.empty(); // false

Queue

1. 创建队列对象

Queue<Integer> queue = new LinkedList<>();
// 或使用 ArrayDeque,性能更好
Queue<Integer> queue = new ArrayDeque<>();

2. 添加元素 (add 和 offer

在刷题中,offer 比较常用 

queue.add(10);  // 抛出异常:如果队列已满,则抛出 IllegalStateException
queue.offer(20); // 返回 true/false:如果队列已满,返回 false

 3. 移除元素 (poll 和 remove)

 poll() 更常用

int element = queue.poll();  // 移除并返回队列头部的元素,队列为空时返回 null
int element = queue.remove();  // 移除并返回队列头部的元素,队列为空时抛出 NoSuchElementException

4. 查看队列头部元素 (peek 和 element

peek() 方法更常用,因为它更安全,不会抛出异常。

int element = queue.peek();  // 返回队列头部的元素,队列为空时返回 null
int element = queue.element();  // 返回队列头部的元素,队列为空时抛出 NoSuchElementException

5. 队列大小 (size

返回队列中元素的数量,通常用于判断队列是否为空。

int size = queue.size();  // 获取队列中元素的数量

6. 检查队列是否为空 (isEmpty

 返回 true 如果队列为空,false 如果队列不为空。常用于循环前检查队列是否有元素。

boolean isEmpty = queue.isEmpty();  // 判断队列是否为空

 


PriorityQueue

PriotyQueue跟Queue命令大体相似,但它也是刷题中经常遇到的,因为它可以创建大小根堆

  • 大根堆(Max-Heap):每个父节点的值大于或等于其子节点的值,根节点为最大元素。
  • 小根堆(Min-Heap):每个父节点的值小于或等于其子节点的值,根节点为最小元素。

小根堆:

 // 创建小根堆//默认就是小根堆PriorityQueue<Integer> minHeap = new PriorityQueue<>();// 向小根堆插入元素minHeap.offer(10);minHeap.offer(20);minHeap.offer(5);minHeap.offer(30);// 输出堆顶元素(最小元素)System.out.println("小根堆堆顶元素:" + minHeap.peek()); // 输出 5// 删除堆顶元素(最小元素)System.out.println("删除堆顶元素:" + minHeap.poll()); // 输出 5// 输出删除堆顶后的堆顶元素System.out.println("删除后堆顶元素:" + minHeap.peek()); // 输出 10

 大根堆

 // 创建大根堆(使用自定义的比较器实现降序排列)PriorityQueue<Integer> maxHeap = new PriorityQueue<>((a,b)-> b - a);//        PriorityQueue<Integer> max = new PriorityQueue<>(Comparator.reverseOrder());// 向大根堆插入元素maxHeap.offer(10);maxHeap.offer(20);maxHeap.offer(5);maxHeap.offer(30);// 输出堆顶元素(最大元素)System.out.println("大根堆堆顶元素:" + maxHeap.peek()); // 输出 30// 删除堆顶元素(最大元素)System.out.println("删除堆顶元素:" + maxHeap.poll()); // 输出 30// 输出删除堆顶后的堆顶元素System.out.println("删除后堆顶元素:" + maxHeap.peek()); // 输出 20

Set

1.创建 Set 实例

3种方法任选一种

Set<Integer> set = new HashSet<>();
Set<Integer> linkedSet = new LinkedHashSet<>();
Set<Integer> treeSet = new TreeSet<>();

2. 添加元素 

set.add(1);  // 添加元素,如果元素已存在,返回 false
set.add(2);
set.add(3);

3. 删除元素 

set.remove(2);  // 删除元素2

4. 检查是否包含某个元素 

boolean contains = set.contains(3);  // 返回 true 如果包含元素3

5. 获取集合的大小 

int size = set.size();  // 返回集合的元素个数

 6. 判断集合是否为空

boolean isEmpty = set.isEmpty();  // 如果集合为空,返回 true

7.遍历 

1)使用迭代器遍历

Iterator<Integer> iterator = set.iterator();
while (iterator.hasNext()) {System.out.println(iterator.next());
}

2)使用增强型 for 循环遍历 

for (Integer num : set) {System.out.println(num);
}

7.Set 转换为 List 

List<Integer> list = new ArrayList<>(set);  // 转换为 List

Map

 1. 基本创建 Map

Map<K, V> map = new HashMap<>();
  • K 是键的类型,V 是值的类型。
  • 可以使用 HashMapTreeMapLinkedHashMap 等不同实现类。
  • 经常使用HashMap类,O(1)
        Map<Integer,Integer> map = new HashMap<>();Map<Integer,Integer> map1 = new TreeMap<>();Map<Integer,Integer> map2= new LinkedHashMap<>();

2. 插入/更新元素 

map.put(K key, V value);  // 插入或更新元素,如果key已经存在,值会被更新

3. 获取元素 

V value = map.get(K key);  // 根据键获取对应的值,若键不存在返回 null

4. 检查键或值是否存在 

boolean containsKey(Object key);  // 判断map中是否存在指定的key
boolean containsValue(Object value);  // 判断map中是否存在指定的value

5. 删除元素 

map.remove(K key);  // 根据key删除键值对

6. 获取键集合、值集合和键值对集合(重)

Set<K> keySet = map.keySet();  // 获取所有键
Collection<V> values = map.values();  // 获取所有值
Set<Map.Entry<K, V>> entrySet = map.entrySet();  // 获取所有的键值对
        Map<String,Integer> hash = new HashMap<>();hash.put("hhh",1);hash.put("ggg",2);hash.put("www",3);Set<String> keySet = hash.keySet();System.out.println(keySet);Collection<Integer> values = hash.values();System.out.println(values);Set<Map.Entry<String, Integer>> entrySet = hash.entrySet();System.out.println(entrySet);

 7. 遍历 Map

// 使用增强for循环遍历entrySet
for (Map.Entry<K, V> entry : map.entrySet()) {K key = entry.getKey();V value = entry.getValue();
}// 使用lambda表达式遍历
map.forEach((key, value) -> {System.out.println(key + ": " + value);
});

 

        Map<String,Integer> hash = new HashMap<>();hash.put("hhh",1);hash.put("ggg",2);hash.put("www",3);//遍历keyfor(String key :hash.keySet()) {System.out.print(key+" ");}System.out.println();//遍历valuesfor(Integer value :hash.values()) {System.out.print(value+" ");}System.out.println();//遍历整个mapfor (Map.Entry<String,Integer> entry :hash.entrySet()) {System.out.println(entry.getKey() + ":" + entry.getValue());}//lambda 遍历mapSystem.out.println();hash.forEach((key,value)->{System.out.println(key + ":" + value);});

8. 默认值处理 

V value = map.getOrDefault(K key, V defaultValue);  // 如果key存在,返回对应的值,否则返回默认值

String类

1.字符串连接

String.concat(String str)

将给定的字符串拼接到当前字符串的末尾。相当于 + 操作符,但效率较高。 

String str = "Hello";
str = str.concat(" World");  // str = "Hello World"

2.字符串比较

1)  判断当前字符串和指定字符串是否相等。比较的是字符序列是否相同。

String.equals(Object obj)
String str1 = "Hello";
String str2 = "hello";
boolean isEqual = str1.equals(str2);  // false

2) 忽略大小写比较两个字符串是否相等。

String.equalsIgnoreCase(String anotherString)
String str1 = "Hello";
String str2 = "hello";
boolean isEqual = str1.equalsIgnoreCase(str2);  // true

 3)字符串按字典顺序比较,返回一个整数:

  • 0 表示两个字符串相等;
  • < 0 表示当前字符串在字典序中小于给定字符串;
  • > 0 表示当前字符串在字典序中大于给定字符串。
String.compareTo(String anotherString)
String str1 = "apple";
String str2 = "banana";
int result = str1.compareTo(str2);  // result < 0

 4)忽略大小写进行字典序比较。

String str1 = "apple";
String str2 = "APPLE";
int result = str1.compareToIgnoreCase(str2);  // result == 0

3.字符串查找 

1)返回指定子字符串首次出现的索引位置。如果没有找到,返回 -1

String.indexOf(String str)
String str = "Hello, World!";
int index = str.indexOf("W");  // index = 7
int index = str.indexOf("M");  // index = -1

 2)返回指定子字符串最后一次出现的索引位置。

String.lastIndexOf(String str)
        String str = "aaaaabbbbba";int index = str.lastIndexOf("a"); //index=10

3)判断当前字符串是否包含指定的子字符串,返回布尔值。 

String.contains(CharSequence sequence)
String str = "Hello, World!";
boolean contains = str.contains("World");  // true

4)判断当前字符串是否以指定的前缀开头。 

String.startsWith(String prefix)
String str = "Hello";
boolean startsWith = str.startsWith("He");  // true

5)判断当前字符串是否以指定的后缀结尾。

String.endsWith(String suffix)
String str = "Hello";
boolean endsWith = str.endsWith("lo");  // true

4.字符串替换和修改 

1)替换字符串中的字符。返回一个新的字符串,原字符串不变。

String.replace(char oldChar, char newChar)
String str = "hello";
String newStr = str.replace('l', 'p');  // newStr = "heppo"

 2)字符串截取

1)返回从指定索引开始到字符串末尾的子字符串

String.substring(int beginIndex)
String str = "Hello World!";
String subStr = str.substring(6);  // subStr = "World!"

2) 返回从 beginIndexendIndex 之间的子字符串。

String.substring(int beginIndex, int endIndex)
String str = "Hello World!";
String subStr = str.substring(0, 5);  // subStr = "Hello"

 5.字符串转换

 1)将字符串转换为小写字母。

String.toLowerCase()
String str = "HELLO";
String lowerStr = str.toLowerCase();  // lowerStr = "hello"

 2)将字符串转换为大写字母。

String.toUpperCase()
String str = "hello";
String upperStr = str.toUpperCase();  // upperStr = "HELLO"

 3)去掉字符串前后的空白字符。

String.trim()
String str = "   Hello World!   ";
String trimmedStr = str.trim();  // trimmedStr = "Hello World!"

 4)将其他类型的数据(如 intbooleanchar 等)转换为字符串。

String.valueOf()
int num = 100;
String str = String.valueOf(num);  // str = "100"

 6.其他常用方法

1)根据正则表达式将字符串拆分成数组。

String.split(String regex)
String str = "apple,banana,orange";
String[] arr = str.split(",");  // arr = ["apple", "banana", "orange"]

2) 将多个字符串连接成一个字符串,中间用指定的分隔符。

String.join(CharSequence delimiter, CharSequence... elements)
String result = String.join(",", "apple", "banana", "orange");  // "apple,banana,orange"

StringBuffer(重)

1.追加字符串:append

将指定的内容追加到 StringBuffer 末尾。

        StringBuffer stringBuffer = new StringBuffer(); // 默认容量为16stringBuffer.append("hello");stringBuffer.append(" ");stringBuffer.append("world!"); // hello world!

2.插入字符串:insert 

将指定的内容插入到指定位置。 

        StringBuffer stringBuffer = new StringBuffer(); // 默认容量为16stringBuffer.append("hello");stringBuffer.append(" ");stringBuffer.append("world!");stringBuffer.insert(6,"hi ");  // hello hi world!

 3.删除字符串:delete 和 deleteCharAt

  • delete(start, end):删除从 start 到 end(不包括 end)的字符。
  • deleteCharAt(index):删除指定索引处的字符。
        StringBuffer stringBuffer = new StringBuffer(); // 默认容量为16stringBuffer.append("hello");stringBuffer.append(" ");stringBuffer.append("world!");stringBuffer.delete(0,5);  //  world!
        stringBuffer.append("hello");stringBuffer.deleteCharAt(stringBuffer.length()-1); // hell

 4.反转字符串:reverse

StringBuffer 中的字符序列反转。

        stringBuffer.append("hello");stringBuffer.reverse(); // olleh

5.转换为 StringtoString 

        stringBuffer.append("hello");String str = stringBuffer.toString(); //hello

 ..................

StringBuilder(线程不安全) 跟StringBuffer(线程安全)类似 功能基本一致

String -> integer  -> char数组


Math类

列举一些主要的数学函数

1.绝对值:abs

返回参数的绝对值。

Math.abs(-5);  // 5
Math.abs(3.14);  // 3.14

 平方根:sqrt

返回参数的平方根。如果参数为负数,则返回 NaN

Math.sqrt(16);  // 4.0
Math.sqrt(2);   // 1.4142135623730951

幂运算:pow 

返回第一个参数的第二个参数次方。

Math.pow(2, 3);  // 8.0
Math.pow(3, 0);  // 1.0
最大值和最小值:max 和 min

返回两个数中的最大值或最小值。

Math.max(5, 10);  // 10
Math.min(5, 10);  // 5

四舍五入:round 

 返回最接近的整数(四舍五入),并将结果作为 long 类型返回。

Math.round(3.6);  // 4
Math.round(3.4);  // 3

向上取整:ceil

返回大于或等于参数的最小整数值,结果是 double 类型。 

Math.ceil(3.1);  // 4.0
Math.ceil(3.9);  // 4.0
指数运算:exp

计算 e 的 x 次方,等效于 Math.pow(Math.E, x)

Math.exp(1);  // 2.718281828459045

数组(Arrays)类

1.数组的排序

1)默认是以升序状态

Arrays.sort(array)
        int[] arr = {10,5,12,45,32,20,18};Arrays.sort(arr);System.out.println(Arrays.toString(arr));

 

2)用于自定义排序规则。适用于对象类型的数组  降序排序

        Integer[] arr = {10,5,12,45,32,20,18};Arrays.sort(arr,(a,b)-> b - a);System.out.println(Arrays.toString(arr));//[45, 32, 20, 18, 12, 10, 5]

2.数组转化字符串

1)一维数组(常用)

Arrays.toString(array)
int[] arr = {1, 2, 3};
String str = Arrays.toString(arr);  // "[1, 2, 3]"

 2)二维数组

Arrays.deepToString(array)
int[][] arr = {{1, 2}, {3, 4}};
String str = Arrays.deepToString(arr);  // "[[1, 2], [3, 4]]"

3.数组复制

1)创建一个新数组,包含原数组的前 newLength 个元素。如果新长度大于原数组长度,则新增元素会被填充为默认值(如 0)。

Arrays.copyOf(array, newLength)
int[] arr = {1, 2, 3};
int[] newArr = Arrays.copyOf(arr, 5);  // [1, 2, 3, 0, 0]

2) 创建一个新数组,复制原数组指定范围的元素(from 包含,to 不包含)。 

Arrays.copyOfRange(array, from, to)
int[] arr = {1, 2, 3, 4, 5};
int[] subArr = Arrays.copyOfRange(arr, 1, 4);  // [2, 3, 4]

4.数组填充

1)将数组中的所有元素设置为指定的值。 

Arrays.fill(array, value)
int[] arr = new int[5];
Arrays.fill(arr, 7);  // [7, 7, 7, 7, 7]

 2)将数组中从 fromIndextoIndex 范围内的元素设置为指定值。 

Arrays.fill(array, fromIndex, toIndex, value) 
int[] arr = new int[5];
Arrays.fill(arr, 1, 4, 9);  // [0, 9, 9, 9, 0]

5.数组比较

判断两个数组是否相等。数组相等的标准是数组的长度相同且对应位置的元素相等。 

Arrays.equals(array1, array2)
int[] arr1 = {1, 2, 3};
int[] arr2 = {1, 2, 3};
boolean isEqual = Arrays.equals(arr1, arr2);  // true

其他操作 :

常见数据类型的最大值和最小值

Integer.MAX_VALUE / Integer.MIN_VALUE
Long.MAX_VALUE / Long.MIN_VALUE
Float.MAX_VALUE / Float.MIN_VALUE
Double.MAX_VALUE / Double.MIN_VALUE

 集合转化成数组

        // 将 List 转换为数组String[] array = list.toArray(new String[0]);// 将 Set 转换为数组String[] array = set.toArray(new String[0]);// 将 Queue 转换为数组String[] array = queue.toArray(new String[0]);// 将 Map 的键转换为数组String[] keys = map.keySet().toArray(new String[0]);// 将 Map 的值转换为数组String[] values = map.values().toArray(new String[0]);
  • 对于 ListSet 和 Queue,可以使用 toArray() 方法直接将其转换为数组。
  • 对于 Map,你可以选择将其键、值或条目转换为数组,使用 keySet()values() 或 entrySet() 方法。

字符与字符串的转换 

1)字符数组转字符串String.valueOf() 或 String 构造函数。

char[] charArray = {'a', 'b', 'c'};
String str = new String(charArray);  // str = "abc"

2)字符串转字符:使用 charAt() 获取指定位置的字符。

String str = "hello";
char ch = str.charAt(0);  // ch = 'h'

 字符串和整型之间的转化

1)字符串转整型(String -> int)

要将字符串转换为整型,可以使用 Integer.parseInt()Integer.valueOf() 方法。

String str = "123";
int num = Integer.parseInt(str);
System.out.println(num);  // 输出:123
String str = "123";
int num = Integer.valueOf(str);  // 返回的是 Integer 对象
System.out.println(num);  // 输出:123

 2)整型转字符串(int -> String)

要将整型转换为字符串,可以使用 String.valueOf()Integer.toString() 方法。

int num = 123;
String str = String.valueOf(num);
System.out.println(str);  // 输出:"123"
int num = 123;
String str = Integer.toString(num);
System.out.println(str);  // 输出:"123"

 .............................

 还有遗留的等遇到会慢慢补充,这个会长期更新...

感谢大家的支持!!!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.rhkb.cn/news/483793.html

如若内容造成侵权/违法违规/事实不符,请联系长河编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

【机器学习】机器学习的基本分类-监督学习-决策树-CART(Classification and Regression Tree)

CART&#xff08;Classification and Regression Tree&#xff09; CART&#xff08;分类与回归树&#xff09;是一种用于分类和回归任务的决策树算法&#xff0c;提出者为 Breiman 等人。它的核心思想是通过二分法递归地将数据集划分为子集&#xff0c;从而构建一棵树。CART …

《船舶物资与市场》是什么级别的期刊?是正规期刊吗?能评职称吗?

问题解答 问&#xff1a;《船舶物资与市场》是不是核心期刊&#xff1f; 答&#xff1a;不是&#xff0c;是知网收录的正规学术期刊。 问&#xff1a;《船舶物资与市场》级别&#xff1f; 答&#xff1a;国家级。主管单位&#xff1a;中国船舶集团有限公司 主办单…

「Mac畅玩鸿蒙与硬件41」UI互动应用篇18 - 多滑块联动控制器

本篇将带你实现一个多滑块联动的控制器应用。用户可以通过拖动多个滑块&#xff0c;动态控制不同参数&#xff08;如红绿蓝三色值&#xff09;&#xff0c;并实时显示最终结果。我们将以动态颜色调节为例&#xff0c;展示如何结合状态管理和交互逻辑&#xff0c;打造一个高级的…

利用红黑树封装map,和set,实现主要功能

如果不知道红黑树是什么的时候可以去看看这个红黑树 思路 首先我们可以把封装分为两个层面理解&#xff0c;上层代码就是set,和map&#xff0c;底层就是红黑树 就相当于根据红黑树上面套了两个map,set的壳子&#xff0c;像下面这张图一样 对于map和set&#xff0c;map里面存…

汽车网络安全 -- IDPS如何帮助OEM保证车辆全生命周期的信息安全

目录 1.强标的另一层解读 2.什么是IDPS 2.1 IDPS技术要点 2.2 车辆IDPS系统示例 3.车辆纵深防御架构 4.小结 1.强标的另一层解读 在最近发布的国家汽车安全强标《GB 44495》,在7.2节明确提出了12条关于通信安全的要求,分别涉及到车辆与车辆制造商云平台通信、车辆与车辆…

R语言机器学习论文(二):数据准备

禁止商业或二改转载,仅供自学使用,侵权必究,如需截取部分内容请后台联系作者! 文章目录 介绍加载R包数据下载导入数据一、数据描述二、数据预处理(一)修改元素名称(二)剔除无关变量(三)缺失值检查(四)重复值检查(五)异常值检查三、描述性统计(一)连续变量数据情…

java基础语法光速入门

前言 欢迎来到我的博客 个人主页:北岭敲键盘的荒漠猫-CSDN博客 本文整理Java的基础语法部分 适合有编程基础的人快点掌握语法使用 没学过一两门语言的话。。还是不建议看了 极致的浓缩没有一点解释 注释 单行注释 // 多行注释 /**/ 数据类型 布尔型:true false 整型:int,lon…

【Linux】常用命令二

声明&#xff1a;以下内容均学习自《Linux就该这么学》一书。 1、cat 用于查看内容较少的纯文本文件。 参数-n可以显示行号。 2、more 用于查看内容较多的纯文本文件。 它会在最下面使用百分比的形式来提示你已经月读了多少内容&#xff0c;你可以使用空格键或回车键向下翻…

springboot利用easypoi实现简单导出Excel

vue springboot利用easypoi实现简单导出 前言一、easypoi是什么&#xff1f;二、使用步骤 1.传送门2.前端vue3.后端springboot 3.1编写实体类&#xff08;我这里是dto,也一样&#xff09;3.2控制层结尾 前言 今天玩了一下springboot利用easypoi实现excel的导出&#xff0c;以前…

合规性要求对漏洞管理策略的影响

讨论漏洞管理中持续面临的挑战&#xff0c;包括确定漏洞的优先级和解决修补延迟问题。 介绍合规性要求以及自动化如何简化漏洞管理流程。 您认为为什么尽管技术不断进步&#xff0c;但优先考虑漏洞和修补延迟等挑战仍然存在&#xff1f; 企业基础设施日益复杂&#xff0c;攻…

【NLP高频面题 - LLM架构篇】旋转位置编码RoPE相对正弦位置编码有哪些优势?

【NLP高频面题 - LLM架构篇】旋转位置编码RoPE相对正弦位置编码有哪些优势&#xff1f; 重要性&#xff1a;⭐⭐⭐ &#x1f4af; NLP Github 项目&#xff1a; NLP 项目实践&#xff1a;fasterai/nlp-project-practice 介绍&#xff1a;该仓库围绕着 NLP 任务模型的设计、训练…

STM32 PWM波形详细图解

目录 前言 一 PWM介绍 1.1 PWM简介 1.2 STM32F103 PWM介绍 1.3 时钟周期与占空比 二.引脚映像关系 2.1引脚映像与寄存器 2.2 复用功能映像 三. PWM 配置步骤 3.1相关原理图 3.2配置流程 3.2.1 步骤一二&#xff1a; 3.2.2 步骤三&#xff1a; 3.2.3 步骤四五六七&#xff1a; …

洛谷 B2029:大象喝水 ← 圆柱体体积

【题目来源】https://www.luogu.com.cn/problem/B2029【题目描述】 一只大象口渴了&#xff0c;要喝 20 升水才能解渴&#xff0c;但现在只有一个深 h 厘米&#xff0c;底面半径为 r 厘米的小圆桶 &#xff08;h 和 r 都是整数&#xff09;。问大象至少要喝多少桶水才会解渴。 …

使用docker部署GBase8s数据库(jdk安装,docker安装,GBase部署)

jdk安装步骤 1.将压缩包上传到/opt/software 2.解压到/opt/module tar -zxvf jdk-8u212-linux-x64.tar.gz -C /opt/module 3.配置环境变量 3.1 在/etc/profile.d目录下创建my_env.sh sudo touch my_env.sh 3.2在文件中添加内容 sudo vim my_env…

嵌入式 C 编程:const 关键字 —— 打造稳定的常量空间

目录 一、const关键字的基本含义与用法 1.1. 修饰基本数据类型 1.2. 修饰指针 1.3. 修饰数组 1.4. 修饰结构体 二、const关键字在嵌入式编程中的优势 2.1. 提升代码可读性 2.2. 增强代码安全性 2.3. 优化内存使用 2.4. 促进模块化设计 2.5. 支持静态分析和测试 三、…

【k8s】kubelet 的相关证书

在 Kubernetes 集群中&#xff0c;kubelet 使用的证书通常存放在节点上的特定目录。这些证书用于 kubelet 与 API 服务器之间的安全通信。具体的位置可能会根据你的 Kubernetes 安装方式和配置有所不同&#xff0c;下图是我自己环境【通过 kubeadm 安装的集群】中的kubelet的证…

USB 声卡全解析:提升音频体验的得力助手

在当今数字化的时代&#xff0c;音频领域的追求愈发多元。无论是热衷聆听高品质音乐的爱好者&#xff0c;还是在专业音频工作中精雕细琢的人士&#xff0c;亦或是在游戏世界里渴望极致音效沉浸的玩家&#xff0c;都始终在寻觅能让音频体验更上一层楼的妙法。而 USB 声卡&#x…

git查看本地库对应的远端库的地址

git查看本地库对应的远端库的地址 git remote -v 如果想要查看特定的远端库的url地址&#xff0c;可以使用如下命令&#xff0c;其中origin是默认的远端库的名称&#xff0c;可以使用其他远端库的名称 get remote get-url origin

深入解析级联操作与SQL完整性约束异常的解决方法

目录 前言1. 外键约束与级联操作概述1.1 什么是外键约束1.2 级联操作的实际应用场景 2. 错误分析&#xff1a;SQLIntegrityConstraintViolationException2.1 错误场景描述2.2 触发错误的根本原因 3. 解决方法及优化建议3.1 数据库级别的解决方案3.2 应用层的解决方案 4. 友好提…

社区团购中 2+1 链动模式商城小程序的创新融合与发展策略研究

摘要&#xff1a;本文聚焦于社区团购这一新兴零售模式的发展态势&#xff0c;深入探讨 21 链动模式商城小程序与之融合的创新机制与应用策略。通过剖析社区团购的运营模式、优势特点以及发展现状&#xff0c;结合 21 链动模式商城小程序的功能特性&#xff0c;研究二者协同作用…