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

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

  • 1. Java
      • 1.1 基础操作
        • 1.1.1 数据结构和定义方式
        • 1.1.2 增加
        • 1.1.3 修改
        • 1.1.4 查询
        • 1.1.5 删除
        • 1.1.6 获取总长度
        • 1.1.7 按key排序
        • 1.1.8 按value排序
        • 1.1.9 遍历
      • 1.2 常用其他方法
        • 1.2.1 几种数据结构的对比
  • 2. Go
      • 2.1基础操作
        • 2.1.1 数据结构和定义方式
        • 2.1.2 增加
        • 2.1.3 修改
        • 2.1.4 查询
        • 2.1.5 删除
        • 2.1.6 获取总长度
        • 2.1.7 按key排序
        • 2.1.8 按value排序
        • 1.1.9 遍历
  • 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 按key排序
      • 3.1.8 按value排序
      • 3.1.9 遍历

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


1. Java

Java 自带了各种 Map 类。这些 Map 类可归为三种类型:

  • 通用Map,用于在应用程序中管理映射,通常在 java.util 程序包中实现
    HashMap、Hashtable、Properties、LinkedHashMap、IdentityHashMap、TreeMap、WeakHashMap、ConcurrentHashMap

  • 专用Map,通常我们不必亲自创建此类Map,而是通过某些其他类对其进行访问
    java.util.jar.Attributes、javax.print.attribute.standard.PrinterStateReasons、java.security.Provider、java.awt.RenderingHints、javax.swing.UIDefaults

  • 一个用于帮助我们实现自己的Map类的抽象类
    AbstractMap

类型 说明 线程安全
HashMap 最常用的Map,它根据键的HashCode 值存储数据,根据键可以直接获取它的值,具有很快的访问速度; HashMap最多只允许一条记录的键为Null(多条会覆盖); 允许多条记录的值为 Null 线程不安全
TreeMap 能够把它保存的记录根据键(key)排序,默认是按升序排序,也可以指定排序的比较器,当用Iterator 遍历TreeMap时,得到的记录是排过序的。TreeMap不允许key的值为null 线程不安全
HashTable 与 HashMap类似,不同的是:key和value的值均不允许为null; 它支持线程的同步,即任一时刻只有一个线程能写Hashtable,因此也导致了Hashtale在写入时会比较慢。 线程安全
LinkedHashMap 保存了记录的插入顺序,在用Iterator遍历LinkedHashMap时,先得到的记录肯定是先插入的.在遍历的时候会比HashMap慢。key和value均允许为空 线程不安全

其中HashMap是最常用的,其他类型的Map根据使用,本文重点介绍HashMap

1.1 基础操作

1.1.1 数据结构和定义方式
# 定义空
Map<String, String> map = new HashMap<>();

# 初始化
  Map<String, String> map = new HashMap<String, String>() {{
      put("a", "b");
      put("b", "b");
  }};
1.1.2 增加
map.put(K key, V value);
map.put("key1", "value1");
1.1.3 修改
map.put(K key, V value);
map.put("key", "value");
1.1.4 查询
# 获取key的值
map.get(Object key);
map.get("key")
1.1.5 删除
map.remove(Object key);
map.remove("key");
1.1.6 获取总长度
# 获取总长度
int length = map.size();
1.1.7 按key排序

HashMap本身本身无序,如果需要排序,可以单独整理出key作为列表,然后形成排序,通过有序的key获取对应的value。

List<Map.Entry<String, String>> list = new ArrayList<>(map.entrySet());
list.sort(new Comparator<Map.Entry<String, String>>() {
    @Override
    public int compare(Map.Entry<String, String> o1, Map.Entry<String, String> o2) {
        return o1.getKey().compareTo(o2.getKey());
    }
});
1.1.8 按value排序
List<Map.Entry<String, String>> list = new ArrayList<>(map.entrySet());
list.sort(new Comparator<Map.Entry<String, String>>() {
    @Override
    public int compare(Map.Entry<String, String> o1, Map.Entry<String, String> o2) {
        return o1.getValue().compareTo(o2.getValue());
    }
});
1.1.9 遍历
# 整体遍历
for (Map.Entry<String, String> mapping: map.entrySet()) {
    System.out.println(mapping.getKey() + ":" + mapping.getValue());
}

1.2 常用其他方法

1.2.1 几种数据结构的对比

Java/Python/Go不同开发语言基础数据结构和相关操作总结-Map篇_第1张图片

2. Go

go没有定义复杂的数据结构,只有map一种类型,并且不设置容量,能够自动扩容。

2.1基础操作

2.1.1 数据结构和定义方式
# 定义空数据
m := make(map[string]int)
m := map[string]int{}

# 创建一个初始容量为 10 的 Map
m := make(map[string]int, 10)

# 初始化
m1 := map[string]int{
	"张三": 3,
	"李四": 4,
	"王五": 5,
};

2.1.2 增加
# 指定index后添加元素
m["key"]="value"
2.1.3 修改
# 指定index后添加元素
m["key"]="value"
2.1.4 查询
# 指定key后添加元素
var value = m["key"]
2.1.5 删除
# 指定key后删除元素
delete(m, "key")
2.1.6 获取总长度
# 获取list的总长度
var length = len(list)
2.1.7 按key排序

没有提供原生的方法,需要自己实现,将key生成切片,完成切片排序。可以参考Java/Python/Go不同开发语言基础数据结构和相关操作总结-数组篇

// 按照key排序
var keys []int
for k := range m {
    keys = append(keys, k)
}
sort.Ints(keys)

for _, k := range keys {
    fmt.Println("Key:", k, "Value:", m[k])
}
2.1.8 按value排序

没有提供原生的方法,需要自己实现,将value生成切片,完成切片排序。可以参考Java/Python/Go不同开发语言基础数据结构和相关操作总结-数组篇

 mapInfo := map[string]int32{
     "roy":18,
     "kitty":16,
     "hugo":21,
     "tina":35,
     "jason":23,
 }

 type peroson struct {
     Name string
     Age int32
 }

 // 生成切片
 var lstPerson []peroson
 for k, v := range mapInfo {
     lstPerson = append(lstPerson, peroson {k, v})
 }

 // 切片排序
 sort.Slice(lstPerson, func(i, j int) bool {
     return lstPerson[i].Age < lstPerson[j].Age  // 升序
 })
 fmt.Println(lstPerson)
1.1.9 遍历
for key, value := range m {
	fmt.Printf("key=%s, value=%d\n", key, value)
}

3. Python

3.1 列表

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

3.1.1 数据结构和定义方式

# 定义空数据
m = { }

# 初始化
m = {"key1" : "value1", "key2" : "value2" }

3.1.2 增加

# 指定key
m["key"]="value"
m.add({"key": "value"})

3.1.3 修改

# 指定key
m["key"]="value"
m.update({"key": "value"})

3.1.4 查询

# 指定key
m.get("key")

3.1.5 删除

# 指定key
del m["key"]

3.1.6 获取总长度

len(m)

3.1.7 按key排序

# 按key排序
m1 = sorted(m)

3.1.8 按value排序

# 按value排序
m1 = sorted(m.items(), key = lambda kv:(kv[1], kv[0]))

3.1.9 遍历

for key, value in m.items():
    print(key, value)

你可能感兴趣的:(Python,Go,Java,python,java,开发语言)