1. Toy模板网首页
  2. > Toy博客

Rust 原始类型之数组array内置方法

10月前 作者：Hann Yang 分类：Toy博客 阅读(49) 违法举报

这篇具有很好参考价值的文章主要介绍了Rust 原始类型之数组array内置方法。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

Rust 原始类型之数组array内置方法

目录

数组 array

声明

访问

引用 Reference

切片 Slice

方法

题目实例

数组 array

在 Rust 中，数组是一种固定大小的数据结构，用于存储具有相同数据类型的元素的有序集合。

“固定大小”是指数组中的元素的类型和数量确定，也就确定了整数数组的大小。

声明

数组可以在声明时指定长度，声明语法：[T; N]，T为数组中元素的类型，N为元素的个数。这两个类型参数在编译时就必须确定下来，数组长度是固定的、不可变的。数组中的元素可以通过索引来访问和修改，索引从 0 开始，最大值为 N-1。

声明语法举例：

let array: [u16; 3] = [1, 2, 3];

在上面的示例中，声明了一个名为 `array` 的数组，其元素类型为 `u16`，并指定长度为 3。

也可以使用以下省略语法来初始化数组：

let array = [1, 2, 3];

在这种情况下，编译器会自动推断数组的长度，同时默认的元素类型为 `i32`。

访问

使用索引访问数组元素：

let array = [1, 2, 3];
println!("{}", array[0]); // 输出 1
println!("{}", array[1]); // 输出 2
println!("{}", array[2]); // 输出 3

使用循环遍历数组元素：

let array = [1, 2, 3];
for i in 0..array.len() {
    println!("{}", array[i]);
}

引用 Reference

引用是 Rust 中最常见的指针类型。引用是指向其他数据类型（如数组、切片或结构）的不可变或可变引用。以下是 Rust 中引用的语法：

let array = [1, 2, 3, 4, 5];
let reference = &array;

上例创建了一个不可变的引用，并将其指向数组 `array`。由于 Rust 具有所有权模型，因此引用的生命周期必须在引用的数据所有权范围内。如果引用的数据被释放，则引用将不再有效。

在 Rust 中，数组访问需要注意一些细节。由于 Rust 非常注重内存安全，因此它限制了数组访问的类型。具体来说，数组索引必须是 usize 类型或可以转换为 usize 类型的类型。以下是 Rust 中用于数组索引的数据类型：

- usize：代表指针大小的无符号整数类型。
- isize：代表指针大小的有符号整数类型。
- u8、u16、u32、u64、u128：无符号整数类型。
- i8、i16、i32、i64、i128：有符号整数类型。

在进行数组访问时，如果使用的数据类型不是上述类型之一，则编译器将显示错误。如果数组下标超过数组范围，则会发生访问越界错误。在 Rust 中，数组访问越界是一种非常严重的错误，因为它可能会导致对未初始化或未知内存进行访问。

为了避免访问越界错误，在 Rust 中，建议使用 `get` 方法来访问数组，而不是使用直接索引：

let array = [1, 2, 3];
match array.get(4) {
    Some(value) => println!("{}", value),
    None => println!("Value not found!")
}

在上面的示例中，我们使用 `get` 方法来访问数组的第 4 个元素。如果元素存在，则输出其值。如果元素不存在，则输出“Value not found!”消息。

切片 Slice

在 Rust 中，数组是栈分配的内存，因此访问数组元素的速度非常快。但是，由于它们具有固定的大小，因此不能动态添加或删除元素。在实际开发中，这通常是不够灵活的。这就是 Rust 中的切片的用武之地。

在 Rust 中，切片是一种指向数组一部分或全部元素的动态长度引用。切片可以包含任何类型的元素，因此可以作为通用的数据结构。由于切片是动态长度的，因此它们可以增长和缩小，从而提供更大的灵活性。

切片的语法与数组相似，但我们不需要在定义时指定长度。以下是 Rust 中切片声明的语法：

let array = [1, 2, 3, 4, 5];
let slice = &array[1..4];

上例创建了一个名为 `slice` 的切片，它引用了数组 `array` 的第 1、2 和 3 个元素。注意，我们使用 `&` 符号创建一个指向数组一部分元素的引用。如果我们不使用 `&`，则会将切片视为静态数组。

有了切片，就可以轻松地对其进行遍历、截取、拼接和传递给函数等操作。

示例：使用切片进行循环遍历

let array = [1, 2, 3, 4, 5];
let slice = &array[1..4];
for i in slice {
    println!("{}", i);
}

在 Rust 中，切片不仅限于数组。我们还可以从其他集合类型（如向量）中创建切片。以下是从向量中创建切片的示例代码：

let vector = vec![1, 2, 3, 4, 5];
let slice = &vector[1..4];

Rust 的切片还可以用作返回值，以允许函数返回指向某个区域的引用而不是分配新的数据结构。这可以提高性能并减少内存使用。

总之，Rust 的数组是一种简单、高效的数据结构，适合处理固定长度的数据。如果需要处理动态大小的数据，建议使用 Vector(Vec之后再讨论)。

属性、方法和函数

len()：返回数组的长度。

let arr = [1, 2, 3, 4, 5];
assert_eq!(arr.len(), 5);

is_empty()：判断数组是否为空，如果长度为 0 返回 true，否则返回 false。

let arr: [i32; 0] = [];
assert_eq!(arr.is_empty(), true);

first()：返回数组的第一个元素的引用，如果数组为空返回 None。

let arr = [1, 2, 3];
assert_eq!(arr.first(), Some(&1));

first_mut()：返回数组的第一个元素的可变引用，如果数组为空，则返回 None。

let mut arr = [1, 2, 3];
if let Some(n) = arr.first_mut() {
    *n *= 2;
}
assert_eq!(arr, [2, 2, 3]);

last()：返回数组的最后一个元素的引用，如果数组为空返回 None。

let arr = [1, 2, 3];
assert_eq!(arr.last(), Some(&3));

last_mut()：返回数组的最后一个元素的可变引用，如果数组为空，则返回 None。

let mut arr = [1, 2, 3];
if let Some(n) = arr.last_mut() {
    *n *= 2;
}
assert_eq!(arr, [1, 2, 6]);

get()：通过索引获取数组元素的引用，如果索引越界返回 None。

let arr = [1, 2, 3];
assert_eq!(arr.get(1), Some(&2));
assert_eq!(arr.get(3), None);

get_mut()：返回给定索引处的元素的可变引用，如果索引越界，则返回 None。

let mut arr = [1, 2, 3];
if let Some(n) = arr.get_mut(1) {
    *n *= 2;
}
assert_eq!(arr, [1, 4, 3]);

 contains()：判断数组是否包含指定的元素。

let arr = [1, 2, 3, 4, 5];
assert!(arr.contains(&3));
assert!(!arr.contains(&6));

​​​​​​​starts_with()：判断数组是否以指定的前缀开头。

let arr = [1, 2, 3, 4, 5];
assert!(arr.starts_with(&[1, 2, 3]));
assert!(!arr.starts_with(&[2, 3, 4]));

​​​​​​​ends_with()：判断数组是否以指定的后缀结尾。

let arr = [1, 2, 3, 4, 5];
assert!(arr.ends_with(&[4, 5]));
assert!(!arr.ends_with(&[3, 4, 5]));

repeat()：创建重复指定次数的数组。

let arr = [1, 2];
let repeated: Vec<i32> = arr.repeat(3);
assert_eq!(repeated, [1, 2, 1, 2, 1, 2]);

fill()：将数组中所有元素替换为给定的值。

let mut arr = [1, 2, 3];
arr.fill(0);
assert_eq!(arr, [0, 0, 0]);

 ​​​​​​​swap()：交换数组中两个元素的位置。

let mut arr = [1, 2, 3];
arr.swap(0, 2);
assert_eq!(arr, [3, 2, 1]);

​​​​​​​binary_search()：在有序数组中搜索（二分查找算法）指定的元素，在找到元素时返回其索引，否则返回应该插入元素的位置的索引，维持数组的有序状态。

let arr = [1, 2, 3, 4, 5];
assert_eq!(arr.binary_search(&3), Ok(2));
assert_eq!(arr.binary_search(&6), Err(5));

let arr = [1, 3, 5, 7, 9];
assert_eq!(arr.binary_search(&5), Ok(2));
assert_eq!(arr.binary_search(&4), Err(2));
assert_eq!(arr.binary_search(&10), Err(5));

​​​​​​​binary_search_by()：在有序数组中使用指定的比较函数搜索指定的元素，在找到元素时返回其索引，否则返回应该插入元素的位置的索引，维持数组的有序状态。

let arr = ["apple", "banana", "cherry", "pear", "watermelon"];
assert_eq!(arr.binary_search_by(|&x| x.cmp("banana")), Ok(1));
assert_eq!(arr.binary_search_by(|&x| x.cmp("orange")), Err(2));

​​​​​​​binary_search_by_key()：在有序数组中搜索指定键的元素，在找到元素时返回其索引，否则返回应该插入元素的位置的索引，维持数组的有序状态。

let arr = [(1, "one"), (3, "three"), (5, "five"), (7, "seven"), (9, "nine")];
let result = arr.binary_search_by_key(&7, |&(key, _)| key);
assert_eq!(result, Ok(3));

let arr = [(1, "apple"), (3, "banana"), (5, "cherry"), (7, "pear"), (9, "watermelon")];
assert_eq!(arr.binary_search_by_key(&5, |&(k, _)| k), Ok(2));
assert_eq!(arr.binary_search_by_key(&4, |&(k, _)| k), Err(2));
assert_eq!(arr.binary_search_by_key(&10, |&(k, _)| k), Err(5));

iter()：返回数组的迭代器，可用于遍历数组中的元素。

let arr = [1, 2, 3];
for i in arr.iter() {
    println!("{}", i);
}
// 输出：1 2 3

iter_mut()：返回一个可变的迭代器，可以用于遍历和修改数组中的元素。

let mut arr = [1, 2, 3];
for i in arr.iter_mut() {
    *i += 1;
}
assert_eq!(arr, [2, 3, 4]);

​​​​​​​into_iter()：返回一个消耗性迭代器，可对数组进行所有权转移，在迭代过程中释放数组的所有权。

let arr = [1, 2, 3];
let v: Vec<i32> = arr.into_iter().map(|x| x * 2).collect();
assert_eq!(v, vec![2, 4, 6]);

​​​​​​​as_mut()：返回一个可变引用的切片，可以修改数组中的元素。

let mut arr = [1, 2, 3];
let s = arr.as_mut();
s[1] = 4;
assert_eq!(arr, [1, 4, 3]);

​​​​​​​as_ptr()：返回数组的指针。

let arr = [1, 2, 3];
let p = arr.as_ptr();
unsafe {
    println!("{}", *p.offset(1));
}
// 输出：2

split()：根据条件分割数组，返回一个可迭代的切片集合。

let arr = [1, 2, 3, 4, 5];
let mut splits = arr.split(|x| x % 2 == 0);
let s1 = splits.next().unwrap();
let s2 = splits.next().unwrap();
let s3 = splits.next().unwrap();
assert_eq!(s1, [1]);
assert_eq!(s2, [3]);
assert_eq!(s3, [5]);

​​​​​​​split_at()：从数组中分割出两个切片，将数组分成两部分。

let arr = [1, 2, 3, 4, 5];
let (left, right) = arr.split_at(2);
assert_eq!(left, [1, 2]);
assert_eq!(right, [3, 4, 5]);

​​​​​​​split_first()：返回数组中的第一个元素。

let arr = [1, 2, 3, 4, 5];
let (first, rest) = arr.split_first().unwrap();
assert_eq!(*first, 1);
assert_eq!(rest, &[2, 3, 4, 5]);

​​​​​​​split_first_mut()：返回一个数组的第一个可变引用。

let mut arr = [1, 2, 3, 4, 5];
let (first, rest) = arr.split_first_mut().unwrap();
*first = 0;
assert_eq!(arr, [0, 2, 3, 4, 5]);

​​​​​​​split_last()：返回数组中的最后一个元素。

let arr = [1, 2, 3, 4, 5];
let (last, rest) = arr.split_last().unwrap();
assert_eq!(*last, 5);
assert_eq!(rest, &[1, 2, 3, 4]);

​​​​​​​split_last_mut()：返回一个数组的最后一个可变引用。

let mut arr = [1, 2, 3, 4, 5];
let (last, rest) = arr.split_last_mut().unwrap();
*last = 0;
assert_eq!(arr, [1, 2, 3, 4, 0]);

chunks()：返回一个可迭代的切片集合，每个切片包含指定大小的元素。

let arr = [1, 2, 3, 4, 5];
let mut chunks = arr.chunks(2);
let c1 = chunks.next().unwrap();
let c2 = chunks.next().unwrap();
let c3 = chunks.next().unwrap();
assert_eq!(c1, [1, 2]);
assert_eq!(c2, [3, 4]);
assert_eq!(c3, [5]);

​​​​​​​chunks_mut()：返回一个可变的可迭代切片集合，每个切片包含指定大小的元素。

let mut arr = [1, 2, 3, 4, 5];
for chunk in arr.chunks_mut(2) {
    chunk[0] += 1;
}
assert_eq!(arr, [2, 2, 4, 4, 5]);

​​​​​​​chunks_exact()：返回一个可迭代的切片集合，每个切片包含指定大小的元素，最后不足一个切片的部分将被忽略。

let arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];
let mut chunks = arr.chunks_exact(3);
let c1 = chunks.next().unwrap();
let c2 = chunks.next().unwrap();
let c3 = chunks.next().unwrap();
let c4 = chunks.next().unwrap();
assert_eq!(c1, [1, 2, 3]);
assert_eq!(c2, [4, 5, 6]);
assert_eq!(c3, [7, 8, 9]);
assert_eq!(c4, [10, 11]);

​​​​​​​chunks_exact_mut()：返回可变的可迭代的切片集合，每个切片包含指定大小的元素，最后不足一个切片的部分将被忽略。

let mut arr = [1, 2, 3, 4, 5, 6, 7, 8, 9];
for chunk in arr.chunks_exact_mut(3) {
    chunk[0] += 1;
}
assert_eq!(arr, [2, 2, 4, 5, 6, 8, 7, 8, 9]);

​​​​​​​join()：将数组中的元素按指定的分隔符连接成一个字符串。

let arr = [1, 2, 3];
let joined = arr.join(", ");
assert_eq!(joined, "1, 2, 3");

let arr = ["one", "two", "three"];
let s = arr.join(", ");
assert_eq!(s, "one, two, three");

​​​​​​​reverse()：反转数组中元素的顺序。

let mut arr = [1, 2, 3, 4, 5];
arr.reverse();
assert_eq!(arr, [5, 4, 3, 2, 1]);

​​​​​​​sort()：对数组进行排序，按元素大小升序排序。

let mut arr = [3, 1, 4, 2, 5];
arr.sort();
assert_eq!(arr, [1, 2, 3, 4, 5]);

sort_by()：对数组进行排序，按指定的比较函数进行排序。

let mut arr = ["apple", "banana", "cherry", "pear", "watermelon"];
arr.sort_by(|a, b| a.len().cmp(&b.len()));
assert_eq!(arr, ["pear", "apple", "banana", "cherry", "watermelon"]);

​​​​​​​sort_by_key()：对数组进行排序，按指定的键进行排序。

let mut arr = [(3, "banana"), (1, "apple"), (5, "cherry"), (7, "pear"), (9, "watermelon")];
arr.sort_by_key(|&(k, _)| k);
assert_eq!(arr, [(1, "apple"), (3, "banana"), (5, "cherry"), (7, "pear"), (9, "watermelon")]);

逆序排列：

fn main() {
    let mut nums = [3, 1, 4, 2, 5];
    nums.sort();
    nums.reverse();
    println!("{:?}", nums);

    let mut nums = [3, 1, 4, 2, 5];
    nums.sort_by(|a, b| b.cmp(a)); 
    println!("{:?}", nums);
}

map()：将数组中的每个元素应用给定的函数，并返回一个新的数组。

let arr = [1, 2, 3];
let arr2 = arr.map(|n| n * 2);
assert_eq!(arr2, [2, 4, 6]);

 ​​​​​​​rotate_left()：循环移动数组元素，将第一个元素移动到数组末尾。

let mut arr = [1, 2, 3, 4, 5];
arr.rotate_left(2);
assert_eq!(arr, [3, 4, 5, 1, 2]);

​​​​​​​rotate_right()：循环移动数组元素，将最后一个元素移动到数组开头。

let mut arr = [1, 2, 3, 4, 5];
arr.rotate_right(2);
assert_eq!(arr, [4, 5, 1, 2, 3]);

​​​​​​​to_string()：将数组转换为字符串类型。

let arr = [1, 2, 3];
let s = arr.to_string();
assert_eq!(s, "[1, 2, 3]");

​​​​​​​to_vec()：将数组转换为向量类型（Vec）。

let arr = [1, 2, 3];
let vec = arr.to_vec();
assert_eq!(vec, vec![1, 2, 3]);

​​​​​​​to_slice()：将数组转换为切片类型，并且可以指定开始和结束位置。

let arr = [1, 2, 3, 4, 5];
let slice = arr.to_slice();
assert_eq!(slice, &[1, 2, 3, 4, 5]);

into_iter()：返回一个将数组转换为迭代器的方法。

let arr = [1, 2, 3];
for n in arr.into_iter() {
    println!("{}", n);
}

​​​​​​​try_fold()：对数组中的每个元素应用给定的函数，并且在每次应用后返回一个 Result 类型，最后将所有 Ok 类型的值聚合在一起。

let arr = ["1", "2", "three", "4", "five"];
let result = arr.try_fold(0, |acc, n| {
    if let Ok(num) = n.parse::<i32>() {
        Ok(acc + num)
    } else {
        Err(())
    }
});
assert_eq!(result, Err(()));

​​​​​​​try_for_each()：对数组中的每个元素应用给定的函数，并且在每次应用后返回一个 Result 类型，如果所有应用都成功，则返回 Ok(())。

let arr = ["1", "2", "3"];
let result = arr.try_for_each(|n| {
    if n.parse::<i32>().is_ok() {
        Ok(())
    } else {
        Err(())
    }
});
assert_eq!(result, Ok(()));

permutations()：返回一个可迭代的集合，包含数组中所有元素的所有可能的排列组合。

let arr = [1, 2, 3];
let mut permutations = arr.permutations();
assert_eq!(permutations.next(), Some([1, 2, 3]));
assert_eq!(permutations.next(), Some([1, 3, 2]));
assert_eq!(permutations.next(), Some([2, 1, 3]));
assert_eq!(permutations.next(), Some([2, 3, 1]));
assert_eq!(permutations.next(), Some([3, 1, 2]));
assert_eq!(permutations.next(), Some([3, 2, 1]));

​​​​​​​zip()：将两个数组压缩成一个元组的集合。

let arr1 = [1, 2, 3];
let arr2 = [4, 5, 6];
let result: Vec<_> = arr1.iter().zip(arr2.iter()).collect();
assert_eq!(result, [(1, 4), (2, 5), (3, 6)]);

windows()：返回一个可迭代的集合，包含指定大小的滑动窗口，每个窗口的元素由数组中相邻的元素组成。

let arr = [1, 2, 3, 4, 5];
let mut windows = arr.windows(2);
assert_eq!(windows.next(), Some(&[1, 2][..]));
assert_eq!(windows.next(), Some(&[2, 3][..]));
assert_eq!(windows.next(), Some(&[3, 4][..]));
assert_eq!(windows.next(), Some(&[4, 5][..]));

let arr = [1, 2, 3, 4, 5];
let mut windows = arr.windows(3);
let w1 = windows.next().unwrap();
let w2 = windows.next().unwrap();
let w3 = windows.next().unwrap();
assert_eq!(w1, [1, 2, 3]);
assert_eq!(w2, [2, 3, 4]);
assert_eq!(w3, [3, 4, 5]);

let arr = [1, 2, 3, 4, 5, 6];
let mut windows = arr.windows(3);
assert_eq!(windows.next(), Some(&[1, 2, 3][..]));
assert_eq!(windows.next(), Some(&[2, 3, 4][..]));
assert_eq!(windows.next(), Some(&[3, 4, 5][..]));
assert_eq!(windows.next(), Some(&[4, 5, 6][..]));
assert_eq!(windows.next(), None);

题目实例

长度最小的子数组

题目描述：

给定一个含有 n 个正整数的数组和一个正整数 target 。

找出该数组中满足其和 ≥ target 的长度最小的连续子数组 [numsl, numsl+1, ..., numsr-1, numsr] ，并返回其长度。如果不存在符合条件的子数组，返回 0 。

示例：

输入：s = 7, nums = [2,3,1,2,4,3]
输出：2
解释：子数组 [4,3] 是该条件下的长度最小的子数组。

示例：

输入：s = 4, nums = [1,4,4]
输出：1

代码：

使用array方法windows()非常方便，不用写滑动窗口的具体代码

fn min_sub_array_len(target: i32, nums: &[i32]) -> i32 {
    for len in 1..=nums.len() {
        for window in nums.windows(len) {
            if target == window.iter().sum::<i32>() {
                return len as i32;
            }
        }
    }
    0
}

fn main() {
    let nums = [2, 3, 1, 2, 4, 3];
    println!("{}", min_sub_array_len(7, &nums));
    let nums = [1, 4, 4];
    println!("{}", min_sub_array_len(4, &nums));
}

暂时更新至此，Array数组还有更多的方法有待补充，一晚上习惯性地误按了三次Ctrl-Z，杯具啊文章来源地址https://www.toymoban.com/news/detail-498678.html

到了这里，关于Rust 原始类型之数组array内置方法的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

分享到：
领支付宝红包 赞助服务器费用

相关文章

  • 十、go语言Array（数组）基本使用方法

    Go 语言提供了数组类型的数据结构。 数组是具有相同唯一类型的一组已编号且长度固定的数据项序列，这种类型可以是任意的原始类型例如整形、字符串或者自定义类型。 数组元素可以通过索引（位置）来读取（或者修改），索引从0开始，第一个元素索引为 0，第二个索引

    2024年02月08日
    浏览(53)

  • Java 连接合并两个数组(Array)的五种方法

    T可以是基础类型，也是类类型

    2024年02月05日
    浏览(58)

  • Array.from()方法之什么是类数组对象

    Array.from()方法就是将一个类数组对象或者可遍历对象转换成一个真正的数组。 那么什么是类数组对象呢？所谓类数组对象，最基本的要求就是具有length属性的对象。 1、将类数组对象转换为真正数组： 那么，如果将上面代码中length属性去掉呢？实践证明，答案会是一个长度为

    2024年02月14日
    浏览(43)

  • Python中列表（list）与数组（array）的相互转换方法介绍

    在Python编程中，列表（list）和数组（array）是常见的数据结构，它们在存储和处理数据时具有不同的特点和用途。有时候我们需要在列表和数组之间进行相互转换。本文将介绍如何在Python中实现列表与数组之间的相互转换，并提供相应的源代码示例。 列表（list）转换为数组

    2024年02月05日
    浏览(45)

  • Python的数据类型的内置方法

    可变与不可变数据类型 字典的内置方法 元组的内置方法 集合的内置方法

    2024年02月10日
    浏览(35)

  • 各个数据类型的内置方法（字符串和列表）

    数字类型主要就是用来做数学运算与比较运算，因此数字类型除了与运算符结合使用之外，并无需要掌握的内置方法 strip, lstrip, rstrip lower(), upper() startswith, endswith 格式化输出之format format的其他使用方式 split,rsplit join replace isdigit

    2024年02月10日
    浏览(44)
  • 【Java基础教程】（三十八）常用类库篇 · 第八讲：数组操作类——解析Arrays类中的全部操作方法，解锁Java数组操作技巧~

    【Java基础教程】（三十八）常用类库篇 · 第八讲：数组操作类——解析Arrays类中的全部操作方法，解锁Java数组操作技巧~

    前言：在学习本文之前，应该先学习并清楚了解Java基础部分的数组相关的概念和知识。 若还不具备学习条件，请先前往学习数组部分的基础知识： 《【Java基础教程】（八）面向对象篇 · 第二讲：Java 数组全面解析——动态与静态初始化、二维数组、方法参数传递、排序与转

    2024年02月15日
    浏览(62)

  • Java中合并两个数组的4种方法(How to Merge Two Arrays in Java)

    int[] arr1={1, 2, 3, 4, 5, 6}; //first array int[] arr2={7, 8, 9, 0}; //second array int[] arr3={1, 2, 3, 4, 5, 6, 7, 8, 9, 0} //resultant array There are following ways to merge two arrays: 1.Java arraycopy() method 2.Without using arraycopy() method 3.Java Collections 4.Java Stream API Java arraycopy() is the method of System class which belongs to java.la

    2024年02月11日
    浏览(42)

  • JavaScript Es6_2笔记 （深入对象 + 内置构造函数 + 包装类型）+包含实例方法

    了解面向对象编程的基础概念及构造函数的作用，体会 JavaScript 一切皆对象的语言特征，掌握常见的对象属性和方法的使用。 了解面向对象编程中的一般概念 能够基于构造函数创建对象 理解 JavaScript 中一切皆对象的语言特征 理解引用对象类型值存储的的

    2024年02月12日
    浏览(47)
  • Rust 标准库字符串类型String及其46种常用方法

    Rust 标准库字符串类型String及其46种常用方法

    Rust主要有两种类型的字符串：str和String str 由[u8]表示，UTF-8编码的字符串的引用，字符串字面值，也称作字符串切片。＆str用于查看字符串中的数据。它的大小是固定的，即它不能调整大小。 String String 类型来自标准库，它是可修改、可变长度、可拥有所有权的同样使用UTF

    2024年02月07日
    浏览(98)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包