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

本文链接：https://blog.csdn.net/weixin_43845924/article/details/135971568

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

1. Java
2. Go
3. Python

由于最近频繁在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(list, new Comparator<User>() {
    @Override
    public 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
    }
}); // 按年龄排序


# 或者
// 按照区间右端点从小到大正向
Arrays.sort(list, Comparator.comparingInt(a -> a[1]));

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()等方式时，两个列表将指向不同的列表对象

1.3.5 list合并另外一个list

List<String> list1 = new ArrayList<String>();
List<String> list2 = new ArrayList<String>();
list2.addAll(list1);

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 string
   age 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
})

2.3.2 数据扩展、合并另一个数组

var arr1 = []int{1,2,3}
var arr2 = []int{4,5,6}
var s1 = append(arr1, arr2...)

2.3.2 切片扩展、合并另一个切片

newSlice := append(slice1, slice2...)

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)

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

或者

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},
]

# 按照指定的元素进行正向排序
result = sorted(list,key=lambda x:x[1])

# 按照指定的元素进行逆向排序
result = sorted(list,key=lambda x:x[1],reverse=True)

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]

2.3.8 两个数组合并成一个数组

list1 = [1,3]
list2 = [2,4]
list = list1 + list2
[1, 3, 2, 4]

总结

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