Java/Python/Go不同开发语言基础数据结构和相关操作总结-数组篇

Java/Python/Go不同开发语言基础数据结构和相关操作总结

  • 1. Java
    • 1.1 静态数组Object[]
      • 1.1.1 数据结构和定义方式
      • 1.1.2 增加
      • 1.1.3 修改
      • 1.1.4 查询
      • 1.1.5 删除
      • 1.1.6 获取元素的位置
      • 1.1.7 获取总长度
      • 1.1.8 正向排序
      • 1.1.9 逆向排序
    • 1.2 动态列表List\<Object>
      • 1.2.1 数据结构和定义方式
      • 1.2.2 增加
      • 1.2.3 修改
      • 1.2.4 查询
      • 1.2.5 删除
      • 1.2.6 获取元素的位置
      • 1.2.7 获取总长度
      • 1.2.8 正向排序
      • 1.2.9 逆向排序
    • 1.3 常用其他方法
      • 1.3.1 []Object转List\<Object>
      • 1.3.2 List\<Object>转[]Object
      • 1.3.3 指定元素排序
      • 1.3.4 数据拷贝
        • 1.3.4.1 赋值实现浅拷贝
        • 1.3.4.2 遍历循环复制实现深拷贝
        • 1.3.4.3 使用List实现类的构造方法实现深拷贝
        • 1.3.4.4 使用list.addAll()方法实现深拷贝
  • 2. Go
    • 2.1 静态数组[]Object
      • 2.1.1 数据结构和定义方式
      • 2.1.2 增加
      • 2.1.3 修改
      • 2.1.4 查询
      • 2.1.5 删除
      • 2.1.6 获取元素的位置
      • 2.1.7 获取总长度
      • 2.1.8 正向排序
      • 2.1.9 逆向排序
    • 2.2 切片
      • 2.2.1 数据结构和定义方式
      • 2.2.1 增加
      • 2.2.3 修改
      • 2.2.4 查询
      • 2.2.5 删除
      • 2.2.6 获取元素的位置
      • 2.2.7 获取总长度
      • 2.2.8 正向排序
      • 2.2.9 逆向排序
    • 2.3 常用其他方法
      • 2.3.1 数据拷贝
        • 2.3.1.1 数组指针实现浅拷贝
        • 2.3.1.2 数组赋值实现深拷贝
        • 2.3.1.3 切片赋值实现浅拷贝
        • 2.3.1.4 切片赋值实现深拷贝
        • 2.3.1.5 指定元素排序
  • 3. Python
    • 3.1 列表
      • 3.1.1 数据结构和定义方式
      • 3.1.2 增加
      • 3.1.3 修改
      • 3.1.4 查询
      • 3.1.5 删除
      • 3.1.6 获取元素的位置
      • 3.1.7 获取总长度
      • 3.1.8 正向排序
      • 3.1.9 逆向排序
    • 3.2 切片
      • 3.2.1 数据结构和定义方式
    • 2.3 常用其他方法
      • 2.3.1 数组扩展另一个数组
      • 2.3.2 数组反转
      • 2.3.5 指定元素排序
      • 2.3.6 sort()和sorted()的区别
      • 2.3.7 数据拷贝
        • 2.3.7.1 赋值实现浅拷贝
        • 2.3.7.2 copy()方法实现浅拷贝
        • 2.3.7.3 list()方法实现深拷贝
        • 2.3.7.4 索引重新构造实现深拷贝
        • 2.3.7.5 列表生成实现深拷贝

由于最近频繁在java、python、go三种开发语言中不断切换,有时候针对基础的数据结构和日常操作搞混了,因此本文进行相关梳理。文中涉及的相关数据结构和日常操作并不复杂,权当增强记忆和理解。


1. Java

在这三种语言中,java已经实现的数据结构是最多,功能最丰富的,这归功于java社区的不断发展,相关的开发者能够不断的利用更方便、更使用的数据结构。相应的,在引用一个陌生的数据结构时,应当重视底层的实现,避免有意想不到的情况出现,导致程序的运行不符合预期。

1.1 静态数组Object[]

  • 静态数组的长度一旦定义就不能更改,无法动态扩容数组的长度。如果需要更改数组长度,通常的做法是创建一个新的数组,并将相关的数据拷贝到新数据上
  • 由于定义了数组长度,因此每个元素可以通过下标获取,读取的成本比较小,时间长度是O(1)
  • 如果需要再指定位置增、删元素,需要移动后续的相关元素,因此写的成本较大,时间长度是O(n)
  • 返回Go静态数组
  • 返回Python静态数组

1.1.1 数据结构和定义方式

# 定义空数据
int[] list = new int[5];# 初始化定义数组
int[] list = new int[]{1,2,3,4,5,9};

1.1.2 增加

由于数组Object[]在初始化的时候,已经确定了数组的长度,因此不能进行增加操作,只能在现有的数组基础上做数据调整。如果需要添加元素

  • 需要复制一个新数据,并且size+1
  • 复制原有数组,根据情况拷贝相关的值到新数据中
  • 根据需要添加的位置,并将后续的元素进行移动

如下方法可以在指定位置,在list数组中添加新元素,实现的效果等于List<Object>的void add(int index, E element);

# 指定index后添加元素
int index = 2;
int value = 5;
int[] array = new int[]{1,2,3,4};
int[] newArray = new int[array.length + 1];
for (int i = 0; i < array.length; i++) {newArray[i] = array[i];
}
# 从后往前移动位置,并在index位置留空,便于后续调整index位置的值
for (int i = newArray.length - 1; i > index; i--) {newArray[i] = newArray[i - 1];
}
newArray[index] = value;
array = newArray;

1.1.3 修改

# 设置index的值
list[int index] = element;
list[1]=2;

1.1.4 查询

# 获取index的值
list[int index];
list[1];

1.1.5 删除

由于数组Object[]在初始化的时候,已经确定了数组的长度,因此不能进行增加操作,只能在现有的数组基础上做数据调整。如果需要添加元素

  • 需要复制一个新数据,并且size-1
  • 复制原有数组,根据情况拷贝相关的值到新数据中
  • 根据需要删除的位置,并将后续的元素进行移动

如下方法可以在指定位置,在list数组中添加新元素,实现的效果等于List<Object>的void remove(int index);

# 指定index后删除元素
int index = 2;
int value = 5;
int[] array = new int[]{1,2,3,4};
int[] newArray = new int[array.length + 1];
for (int i = 0; i < array.length; i++) {# 移除index位置的元素if(i != 2) {newArray[i] = array[i];}	
}
array = newArray;

1.1.6 获取元素的位置

没有原生的方法能够直接获取元素的位置,需要通过遍历查找的方法进行获取

# 获取object的索引位置,-1表示没有该元素
int index = Arrays.binarySearch(Object[] list, Object key);
int index = Arrays.binarySearch(list, Object key)

1.1.7 获取总长度

# 获取list的总长度
int length = list.length

1.1.8 正向排序

Arrays.sort(list);

1.1.9 逆向排序

Arrays.sort(list, Collections.reverseOrder());

1.2 动态列表List<Object>

声明不固定长度的列表,因此能够提供更加丰富的api和操作方法,也是最常用的数据结构。

1.2.1 数据结构和定义方式

# 定义空列表
List<Integer> list = new ArrayList<>();# 初始化定义数组
ArrayList<Integer> obj = new ArrayList<Integer>() {{add(Object o1);add(Object o2);
}};# 初始化定义数组,T对象
ArrayList<T> obj = new ArrayList<T>() {{add(Object o1);add(Object o2);
}};

1.2.2 增加

# 指定index后添加元素
void add(int index, E element);
list.add(1,2);# 默认在最后添加元素
void add(E element);
list.add(1);

1.2.3 修改

# 设置index的值
list.set(int index, E element);
list.set(1, 2);

1.2.4 查询

# 获取index的值
list.get(int index);
list.get(1);

1.2.5 删除

# 指定index后删除元素
list.remove(int index);
list.remove(1);

1.2.6 获取元素的位置

# 获取object的索引位置,-1表示没有该元素
int index = list.indexOf(Object o);
int index = list.indexOf(1);

1.2.7 获取总长度

# 获取list的总长度
int length = list.size();
int length = list.size();

1.2.8 正向排序

Collections.sort(list);

1.2.9 逆向排序

Collections.sort(list,Collections.reverseOrder());

1.3 常用其他方法

1.3.1 []Object转List<Object>

String[] strArray = new String[10];
List<String> arrayList = new ArrayList<>(strArray.length);
Collections.addAll(arrayList, strArray);

1.3.2 List<Object>转[]Object

List<String> arrayList = new ArrayList<Integer>() {{add(String o1);add(String o2);
}};Strng[] strArray = arrayList.toArray(new String[arrayList.size()]);

1.3.3 指定元素排序

# 定义元素类
class User {String name;int age;
}
# 定义相关列表
List<User> list = new ArrayList<>();
list.add(new User{"张三", 3});
list.add(new User{"李四", 4});
list.add(new User{"王五", 5});# 或者使用如下方式进行
List<User> list = new ArrayList<User>(){{add(new User{"张三", 3});add(new User{"李四", 4});add(new User{"王五", 5});
}};;# 进行排序
Collections.sort(list3, new Comparator<User>() {@Overridepublic int compare(User u1, User u2) {int diff = u1.getAge() - u2.getAge();if (diff > 0) {return 1;} else if (diff < 0) {return -1;}return 0; //相等为0}
}); // 按年龄排序

1.3.4 数据拷贝

浅拷贝:只拷贝源对象的地址,所以新对象与老对象共用一个地址,当该地址变化时,两个对象也会随之改变
深拷贝:拷贝对象的所有值,即使源对象发生任何改变,拷贝的值也不会变化。
由于日常使用数组的场景较少,因此在这里不做讨论,只讨论列表的拷贝情况,日常使用比较多是深拷贝,因此需要注意

1.3.4.1 赋值实现浅拷贝
List<String> src = new ArrayList<String>() {{add("a");add("b");add("c");}};
List<String> dst = src;
1.3.4.2 遍历循环复制实现深拷贝
List<String> src = new ArrayList<String>() {{add("a");add("b");add("c");}};
List<String> dst=new ArrayList<String>(src.size());  
for(String s : src){  dst.add(s);  
}
1.3.4.3 使用List实现类的构造方法实现深拷贝
List<String> src = new ArrayList<String>() {{add("a");add("b");add("c");}};
List<String> dst=new ArrayList<String>(src); 
1.3.4.4 使用list.addAll()方法实现深拷贝
List<String> src = new ArrayList<String>() {{add("a");add("b");add("c");}};
List<String> dst=new ArrayList<String>();
dst.addAll(src); 

总结

  • 使用赋值操作,此时两个列表将指向同一个列表对象
  • 使用遍历、List()构造、list.addAll()等方式时,两个列表将指向不同的列表对象

2. Go

go语言没有java语言的数据结构丰富,只有简单的几种基础类型,如果希望引入复杂的数据结构实现类似java一样复杂多样的功能,需要引入第三方库。不过,在引入第三方库时,一定要确保对引用的库底层的实现是足够了解的,避免有意想不到的情况出现,导致程序的运行不符合预期。

go语言中在列表是实现上通常是分为数组和切片2种方式。两者在声明上很贴近,差别就是数组声明是指定长度,而切片声明是不指定长度

2.1 静态数组[]Object

go语言定义的数组特性和java是一样的,可以参考 Java静态数组

2.1.1 数据结构和定义方式

声明时必须指定长度,注意跟切片的区别。 查看Go切片

# 定义空数据
var list [5]int;
list :=[5]int;# 初始化定义数组
var list = [5]int{1, 2, 3, 4, 5}

2.1.2 增加

由于数组[]Object在初始化的时候,已经确定了数组的长度,因此不能进行增加操作,只能在现有的数组基础上做数据调整。如果需要添加元素

  • 需要复制一个新数据,并且size+1
  • 复制原有数组,根据情况拷贝相关的值到新数据中
  • 根据需要添加的位置,并将后续的元素进行移动

如下方法可以在指定位置,在list数组中添加新元素

# 指定index后添加元素
int index = 2;
int value = 5;
var array = [5]int{1, 2, 3, 4, 5}
var newArray = [len(array)]int{}
for (int i = 0; i < len(array); i++) {newArray[i] = array[i];
}
# 从后往前移动位置,并在index位置留空,便于后续调整index位置的值
for (int i = newArray.length - 1; i > index; i--) {newArray[i] = newArray[i - 1];
}
newArray[index] = value;
array = newArray;

2.1.3 修改

# 设置index的值
list[int index] = element;
list[1]=2;

2.1.4 查询

# 获取index的值
list[int index];
list[1];

2.1.5 删除

由于数组[]Object在初始化的时候,已经确定了数组的长度,因此不能进行增加操作,只能在现有的数组基础上做数据调整。如果需要添加元素

  • 需要复制一个新数据,并且size-1
  • 复制原有数组,根据情况拷贝相关的值到新数据中
  • 根据需要删除的位置,并将后续的元素进行移动

如下方法可以在指定位置,在list数组中添加新元素

# 指定index后删除元素
int index = 2;
int value = 5;
var array = [5]int{1, 2, 3, 4, 5}
var newArray = [len(array)]int{}
for (int i = 0; i < len(array); i++) {# 移除index位置的元素if(i != 2) {newArray[i] = array[i];}	
}
array = newArray;

2.1.6 获取元素的位置

没有提供原生的方法,需要自己实现。

var test = [5]int{1,2,3,4,5};
for index, v := range test {if v == 1 {return index}
}

2.1.7 获取总长度

# 获取list的总长度
var length = len(list)

2.1.8 正向排序

没有提供原生的方法,需要自己实现。

// 冒泡正向排序
var test = [5]int{1, 2, 3, 4, 5}
for i := 0; i < len(test)-1; i++ {for j := i + 1; j < len(test); j++ {if test[i] > test[j] {var tmp = test[j]test[j] = test[i]test[i] = tmp}}
}

2.1.9 逆向排序

没有提供原生的方法,需要自己实现。

// 冒泡逆向排序
var test = [5]int{1, 2, 3, 4, 5}
for i := 0; i < len(test)-1; i++ {for j := i + 1; j < len(test); j++ {if test[i] < test[j] {var tmp = test[j]test[j] = test[i]test[i] = tmp}}
}

2.2 切片

声明不固定长度的列表,因此能够提供更加丰富的api和操作方法,也是最常用的数据结构。声明不指定长度,注意跟数组的区别。 查看Go静态数组

2.2.1 数据结构和定义方式

# 定义空数据
var list []int;
list := []int{};# 初始化定义数组var list = []int{1, 2, 3, 4, 5}

2.2.1 增加

# 指定index后添加元素
index := 2 //需要插入的位置
copy(list[index+1:], list[index:])
list[index] = 100# 默认在最后添加元素
list = append(list, E element)
list = append(list, 1)# 默认在最后增加一个新的切片
list = append(list, list2)

2.2.3 修改

# 设置index的值
list.set(int index, E element);
list[index] = 100

2.2.4 查询

# 获取index的值
list[index]

2.2.5 删除

没有原生的方法,需要自己实现,巧妙利用append方法

# 指定index后删除元素
list = append(list[:index], list[index+1:]...)

2.2.6 获取元素的位置

没有提供原生的方法,需要自己实现。

var test = []int{1,2,3,4,5};
for index, v := range test {if v == 1 {return index}
}

2.2.7 获取总长度

# 获取list的总长度
int length = len(list)

2.2.8 正向排序

sort.Ints(list)

2.2.9 逆向排序

sort.Sort(sort.Reverse(sort.IntSlice(list)))

2.3 常用其他方法

2.3.1 数据拷贝

2.3.1.1 数组指针实现浅拷贝
src := [3]int{1,2,3}
dst := []int// 赋值指针,形成浅拷贝,任意数组调整,都会导致2个数组发生调整
dst := &src
2.3.1.2 数组赋值实现深拷贝
src := [3]int{1,2,3}
dst := [3]int// 赋值数组,形成深拷贝,无论调整s还是dst的值,都会导致2个切片被改变
dst := src
2.3.1.3 切片赋值实现浅拷贝
# 数组拷贝给切片
dst := make([]int)
s:= []int{1,2,3}
# 无论调整s还是dst的值,都会导致2个切片被改变
dst := s
2.3.1.4 切片赋值实现深拷贝
# 注意,拷贝过程以长度小的切片为准,只能拷贝切片长度小的区间,因此需要注意申请切片时设置切片长度,否则会无法赋值
copy(dst,src)dst:= [3]int{1,2,3}
//如果加入的两个数组切片不一样大,就会按其中较小的那个数组切片的元素个数进行复制所以要先声明slice切片的长度,否则会无法赋值。
s := make([]int, len(dst))
copy(s,dst[:])

总结

  • 数组实现浅拷贝使用指针,实现深拷贝使用复制
  • 切片浅拷贝使用复制,深拷贝使用copy
2.3.1.5 指定元素排序
type aStructure struct {name stringage int
}# 指定年龄正向排序
list := []aStructure{}
sort.Slice(list, func(i, j int) bool {return  list[i].age < mySlice[j].age
})# 指定年龄逆向排序
list := []aStructure{}
sort.Slice(list, func(i, j int) bool {return  list[i].age > mySlice[j].age
})

3. Python

python语言中没有定义数组这个数据结构,而是定义了 列表和切片,列表和切片的长度是不固定,因此能够支持很多丰富的api。这个一点跟go、java有区别。

3.1 列表

声明不固定长度的列表,因此能够提供更加丰富的api和操作方法,也是最常用的数据结构。

3.1.1 数据结构和定义方式

list = [1, 2, 3, 4, 5 ]

3.1.2 增加

# 默认在最后添加元素
list.append(self, *args, **kwargs)
list = append(1)# 指定位置增加元素
list.insert(self, *args, **kwargs)
list.insert(3,6)

3.1.3 修改

# 设置index的值
list[index] = 100

3.1.4 查询

# 设置index的值
list[index]

3.1.5 删除

# 删除最后一个元素
list.pop()
# 删除index的值,如果index不存在,会返回报错
list.pop(index)# 删除第一个匹配的元素,如果值不存在,会返回报错
list.remove(object)
list.remove(3)

3.1.6 获取元素的位置

list.index(self, *args, **kwargs)
# 返回第一个匹配的元素的索引值,如果值不存在,会返回报错
index = list.index(3)

3.1.7 获取总长度

len(list)

3.1.8 正向排序

# 逆向排序
list.sort(reverse=True)

3.1.9 逆向排序

# 逆向排序
list.sort(reverse=True)

3.2 切片

在python中,列表已经声明了不固定长度,因此各种丰富的api都能够使用。而切片本质上也是列表,只不过在现有的列表上做数据切分,切分后返回一个新的数组,因此操作的api跟数组是相同的。

3.2.1 数据结构和定义方式

# 定义列表
list = [1, 2, 3, 4, 5 ]# 按照index进行切片
list2 = list[index:index+2]# 从左往右切片
list2 = list[:]
list2 = list[::]# 从右往左切片
list3 = list[::-1] 

2.3 常用其他方法

2.3.1 数组扩展另一个数组

list.extend(list)

2.3.2 数组反转

# 使用数组的原始方法
list.reverse()# 使用切片实现
list2 = list[::-1]

2.3.5 指定元素排序

# 按照指定的元素进行排序
list = [{'language': 'Python', 'year': 1991},{'language': 'Swift', 'year': 2014},{'language': 'Java', 'year': 1995},{'language': 'C++', 'year': 1985},{'language': 'Go', 'year': 2007},{'language': 'Rust', 'year': 2010},
]def get_year(element):return element['year']list.sort(key=get_year)

2.3.6 sort()和sorted()的区别

  • sort()是列表/切片的2个基础方法,能够进行排序,只针对当前的列表/切片进行排序,操作对象只能是列表。其他类型的数据结构如果不提供sort()方法,则不能操作。
  • sorted()是原生的提供的基础方法,也能够实现排序,但是返回排序后的新列表,对原始的列表/切片不造成影响。操作的对象可以是列表或者其他对象
# 使用sort()进行排序
list.sort()# 使用sorted()操作,返回一个新的列表
list2 = sorted(list)

2.3.7 数据拷贝

2.3.7.1 赋值实现浅拷贝
src = {"Name": "HaiCoder", "Age": 100, "Score": 99.5}
dst = src
2.3.7.2 copy()方法实现浅拷贝
src = [1,2,3]
dst=src.copy()
2.3.7.3 list()方法实现深拷贝
src = [1,2,3]
dst=list(src)
2.3.7.4 索引重新构造实现深拷贝
src = [1,2,3]
dst=src[start:end]
2.3.7.5 列表生成实现深拷贝
src = [1,2,3]
dst=[ i for i in src]

总结

  • 使用赋值操作,此时两个列表将指向同一个列表对象
  • 使用索引,列表构造函数,列表生成式,copy()等方式时,两个列表将指向不同的列表对象

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

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

相关文章

如何实现冻干机和产品全生命周期的验证和监测?

为什么冻干需要工艺优化和合规性 冻干是制药和生物技术产品的关键工艺&#xff0c;需要精确控制关键的温度和压力参数。通过遵守 GMP 和 FDA 合规性等监管准则&#xff0c;您可以生产出更高质量的产品&#xff0c;避免不必要的浪费&#xff0c;并缩短产品上市时间。 要想在冻干…

Java on Azure Tooling 2024年1月更新|Azure Key Vault 支持、示例项目创建支持及更多

作者&#xff1a;Jialuo Gan - Program Manager, Developer Division At Microsoft 排版&#xff1a;Alan Wang 大家好&#xff0c;欢迎来到 2024 年 Java on Azure 工具的首次更新。在本次更新中&#xff0c;我们将介绍对于 Azure Key Vault 支持、基于 Azure 示例项目的创建支…

Python入门指北二十六

Python中如何实现静态类型检查和动态类型检查&#xff1f;你有哪些工具推荐&#xff1f; Python中有许多常用的Web开发框架&#xff0c;每个框架都有其独特的特点和适用场景。以下是一些常用的Web开发框架及其特点&#xff1a; Django&#xff1a; 特点&#xff1a;Django是一…

更换服务器是否需要更换SSL证书?

在互联网时代&#xff0c;随着企业和网站的发展&#xff0c;更换服务器是一种常见的需求。然而&#xff0c;许多网站管理员在更换服务器时是否需要更换SSL证书存在疑虑。本文将就此问题进行探讨&#xff0c;帮助您了解在更换服务器时是否需要更换SSL证书。 1、SSL证书的绑定 SS…

【面试】冲刺春招!每天三十道面试题——Java基础篇(一)

目录 一 JDK 和 JRE 的区分 二 简述编码的作用以及记事本的实现原理 三 基本类型有哪些&#xff1f;分别占据多少空间&#xff1f; 四 java中布尔类型的空间大小是怎么定下来的&#xff1f;为什么不是1bit&#xff0c; 把考虑因素说一下 五 int类型和float类型哪一个精度更…

nohost本地部署

1、安装node Node.js 官方网站下载&#xff1a;https://nodejs.org/en/download/ 2、安装whistle 安装命令为 npm install -g whistle 或 npm install -g cnpm --registryhttps://registry.npm.taobao.org 后&#xff0c;使用 cnpm install -g whistle 来安装 3、插件修改 官方…

线性矩阵不等式LMI与李雅普诺夫Lyapunov稳定性

文章目录 线性矩阵不等式&#xff08;Linear Matrix Inequality&#xff0c;LMI&#xff09;例子 Lyapunov稳定性Schur Complement定义Schur Complement作用/性质利用Schur Complement将LMI和Lyapunov联系起来 线性矩阵不等式&#xff08;Linear Matrix Inequality&#xff0c;…

BUG:docker启动之后直接退出问题

示例如下&#xff1a; 问题排查&#xff1a; 启动命令 sudo docker run --privilegedtrue --runtimenvidia --shm-size80g -v /mmm_data_center:/mmm_data_center -v /imagecenter_new/:/imagecenter_new -v /data1:/data1 -v /mnt/offline_data/:/mnt/offline_data/ --neth…

cesium-测量高度垂直距离

cesium做垂直测量 完整代码 <template><div id"cesiumContainer" style"height: 100vh;"></div><div id"toolbar" style"position: fixed;top:20px;left:220px;"><el-breadcrumb><el-breadcrumb-i…

【51单片机】直流电机实验和步进电机实验

目录 直流电机实验直流电机介绍ULN2003 芯片介绍硬件设计软件设计实验现象 步进电机实验步进电机简介步进电机的工作原理步进电机极性区分双极性步进电机驱动原理单极性步进电机驱动原理细分驱动原理 28BYJ-48 步进电机简介软件设计 橙色 直流电机实验 在未学习 PWM 之前&…

理解Jetpack Compose中的`remember`和`mutableStateOf`

理解Jetpack Compose中的remember和mutableStateOf 在现代Android开发中&#xff0c;Jetpack Compose已经成为构建原生UI的首选工具。它引入了一种声明式的编程模式&#xff0c;极大地简化了UI开发。在Compose的世界里&#xff0c;remember和mutableStateOf是两个非常关键的函…

智慧城市:打造低碳未来,引领城市数字化转型新篇章

在“万物皆可数字化”的新时代浪潮下&#xff0c;智慧城市作为未来城市发展的先锋方向&#xff0c;正在以前所未有的速度和规模重塑我们的城市面貌。 智慧城市不仅是一个技术革新的标志&#xff0c;更是城市治理、民生服务等领域全面升级的重要引擎。 一、智慧城市的多元应用领…

玩家笔记:幻兽帕鲁搭建服务器开服教程

玩转幻兽帕鲁服务器&#xff0c;阿里云推出新手0基础一键部署幻兽帕鲁服务器教程&#xff0c;傻瓜式一键部署&#xff0c;3分钟即可成功创建一台Palworld专属服务器&#xff0c;成本仅需26元&#xff0c;阿里云服务器网aliyunfuwuqi.com分享2024年新版基于阿里云搭建幻兽帕鲁服…

高频一体式读写器现场应用

一体式读写器将所有组件集成在一个设备内&#xff0c;具有设计紧凑、安装简单、一体读写的特点&#xff0c;可在生产、仓库等领域中应用。高频一体式读写器现场应用 一体式读写器可以在在工业生产线上应用&#xff0c;读取产线设备的各种信息并记录&#xff0c;实现自动化控制和…

从零开始 TensorRT(4)命令行工具篇:trtexec 基本功能

前言 学习资料&#xff1a; TensorRT 源码示例 B站视频&#xff1a;TensorRT 教程 | 基于 8.6.1 版本 视频配套代码 cookbook 参考源码&#xff1a;cookbook → 07-Tool → trtexec 官方文档&#xff1a;trtexec 在 TensorRT 的安装目录 xxx/TensorRT-8.6.1.6/bin 下有命令行…

kubectl命令

kubenetes部署服务的流程 以部署一个nginx服务来说明kubernetes系统各个组件调用关系&#xff1a; 1. 首先要明确&#xff0c;一旦kubernetes环境启动之后&#xff0c;master和node都会将自身的信息存储到etcd数据库中 2. 一个nginx服务的安装请求会首先被发送到master节点的ap…

C++ dfs 与图有关的知识(四十七)【第七篇】

今天我们接着来学习树上搜索&#xff08;dfs深度优先搜索&#xff09; 1.树的深度与子树大小 树的深度&#xff1a;规定根结点是树的第一层&#xff0c;树根的孩子结点是树的第二层&#xff0c;以此类推&#xff0c;树的深度就是结点的最大层数。 根据定义&#xff0c;如果我们…

c语言实现greedy snake(贪吃蛇)

##第一个小项目 大一学生寒假项目 最终实现效果如图 一.以C语言实现个人小项目 在我们快速学完了一个高级编程语言&#xff0c;就应该写一个小项目来加以巩固自己的学习成果。 所以今天&#xff0c;我们来尝试写一写greedy snake&#xff0c;对于大学生来说也是可以加强能…

Gateway API 实践之(七)FSM Gateway 的负载均衡算法

FSM Gateway 流量管理策略系列&#xff1a; 故障注入黑白名单访问控制限速重试会话保持健康检查负载均衡算法TLS 上游双向 TLS 在微服务和 API 网关架构中&#xff0c;负载均衡是至关重要的&#xff0c;它确保每个服务实例都能平均地处理请求&#xff0c;同时也为高可用性和故…

python 基础知识点(蓝桥杯python科目个人复习计划34)

今日复习内容&#xff1a;以做题为主 例题1&#xff1a;Alice 和 Bob的爱恨情仇 题目描述&#xff1a; Alice和Bob最近正在学习博弈论&#xff0c;为了学以致用&#xff0c;他们找来了一大堆的小饼干 &#xff0c;并通过博弈的方式来吃掉这些小饼干。他们轮流对这些饼干进行…