Python与Java容器总结

Python数据容器

1、List（列表）

1、列表可以一次性存储多个元素，且可以为不同的数据类型，支持嵌套(列表里再存储列表),支持每个容器同名，相当于每次都是新容器。列表的每一个元素，都有编号，称之为下标索引：
2、从前往后的方向，编号从0开始递增 从后往前的方向，编号从-1开始递减
3、通过列表下标，即可取出元素。要注意下标索引的取值范围，超出范围无法取出元素，并且会报错。

# 1、list初始化定义
my_list = ["a", "b", "c"]
print(my_list)
print(type(my_list))
# 2、list支持多种类型元素存储
my_list = ["a", True, 666, 777]
print(my_list)
print(type(my_list[0]))
print(type(my_list[1]))
print(type(my_list[2]))
# 3、此处my_list里面的list获取的是上次最新的list容器，容器之间支持嵌套
my_list = ["a", True, 666, my_list]
print(my_list)
# 4、错误示范；通过下标索引取数据，一定不要超出范围,且索引下标同Java一样，从0开始
# print(my_list[4])
# 5、支持倒序索引下标获取元素,最后一个下标元素为-1，其次往前负数值递增
print(my_list[-1])
print(my_list[-2])
print(my_list[-3])
print(my_list[-4])
# 6、 取出嵌套元素
my_list = [[1, 2, 3], [4, 5, 6]]
print(my_list[1][2])
"""
数据容器的list列表方法操作
语法：[元素，元素，。。。。]
"""
import copy

my_list = ["a", "b", "c"]
# 1、统计列表内某元素的数量
count = my_list.count("a")
print(count)

# 2、list元素追加
# 单个元素追加
my_list.append("d")
# 在列表的尾部追加```一批```新元素
my_list2 = ["1", "2", "3"]
my_list.extend(my_list2)
print(my_list)
# 插入元素最多在列表最后一个元素位置插入
my_list.insert(10, "A")
index = my_list.index("A")
print(f"my_list.index(5) = {index}")
print(my_list)

# 3、list元素移除
# 指定下标方式移除list元素
my_list.pop(0)
print(my_list)
# 指定下标删除list元素
del my_list[0]
print(my_list)
# 根据元素名移除list该元素
my_list.remove("A")
print(my_list)

# 4、llist元素倒置
my_list.reverse()
print(my_list)
# 清空list链表内的元素
my_list.clear()

# 5、拷贝元素
# 对于List来说，其第一层，是实现了深拷贝，但对于其内嵌套的List，仍然是浅拷贝。
# 因为嵌套的List保存的是地址，复制过去的时候是把地址复制过去了，
# 嵌套的List在内存中指向的还是同一个。
my_list04 = [1, [1, 2, 3], 3]
my_list3 = my_list04.copy()
print(my_list3)

# 如果用deepcopy()方法，则无论多少层，无论怎样的形式，得到的新列表都是和原来无关的，
# 这是最安全最清爽最有效的方法。
# 需要import copy
my_list05 = [1, [1, 2, 3], 3, 4, 5, 6]
my_list06 = copy.deepcopy(my_list05)
print(my_list06)

# 6、元素排序
# sort(cmp, key, reverse) 函数用于对原列表进行排序，如果指定参数，则使用比较函数指定的比较函数。
# cmp -- 可选参数, 如果指定了该参数会使用该参数的方法进行排序。
# key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
# reverse -- 排序规则，reverse = True 降序， reverse = False 升序（默认）。
aList = ['123', 'Google', 'Runoob', 'Taobao', 'Facebook'];
aList.sort()
print(f"List : {aList}")

2、Tuple（元组）

"""
演示tuple元组的定义和操作
"""

# 定义元组
t1 = (1, "Hello", True)
t2 = ()
t3 = tuple()
print(f"t1的类型是：{type(t1)}, 内容是：{t1}")
print(f"t2的类型是：{type(t2)}, 内容是：{t2}")
print(f"t3的类型是：{type(t3)}, 内容是：{t3}")

# 定义单个元素的元素
t4 = ("hello", )
print(f"t4的类型是：{type(t4)}, t4的内容是：{t4}")
# 元组的嵌套
t5 = ( (1, 2, 3), (4, 5, 6) )
print(f"t5的类型是：{type(t5)}, 内容是：{t5}")

# 下标索引去取出内容
num = t5[1][2]
print(f"从嵌套元组中取出的数据是：{num}")

# 元组的操作：index查找方法
t6 = ("传智教育", "黑马程序员", "Python")
index = t6.index("黑马程序员")
print(f"在元组t6中查找黑马程序员，的下标是：{index}")
# 元组的操作：count统计方法
t7 = ("传智教育", "黑马程序员", "黑马程序员", "黑马程序员", "Python")
num = t7.count("黑马程序员")
print(f"在元组t7中统计黑马程序员的数量有：{num}个")
# 元组的操作：len函数统计元组元素数量
t8 = ("传智教育", "黑马程序员", "黑马程序员", "黑马程序员", "Python")
num = len(t8)
print(f"t8元组中的元素有：{num}个")
# 元组的遍历：while
index = 0
while index < len(t8):
print(f"元组的元素有：{t8[index]}")
# 至关重要
index += 1

# 元组的遍历：for
for element in t8:
print(f"2元组的元素有：{element}")

# 修改元组内容
# t8[0] = "itcast"

# 定义一个元组
t9 = (1, 2, ["itheima", "itcast"])
print(f"t9的内容是：{t9}")
t9[2][0] = "黑马程序员"
t9[2][1] = "传智教育"
print(f"t9的内容是：{t9}")

3、Str(字符串)

数据容器的切片

"""
演示对序列进行切片操作
"""
# 对list进行切片，从1开始，4结束，步长1
my_list = [0, 1, 2, 3, 4, 5, 6]
result1 = my_list[1:4]      # 步长默认是1，所以可以省略不写
print(f"结果1：{result1}")

# 对tuple进行切片，从头开始，到最后结束，步长1
my_tuple = (0, 1, 2, 3, 4, 5, 6)
result2 = my_tuple[:]     # 起始和结束不写表示从头到尾，步长为1可以省略
print(f"结果2：{result2}")

# 对str进行切片，从头开始，到最后结束，步长2
my_str = "01234567"
result3 = my_str[::2]
print(f"结果3：{result3}")

# 对str进行切片，从头开始，到最后结束，步长-1
my_str = "01234567"
result4 = my_str[::-1]          # 等同于将序列反转了
print(f"结果4：{result4}")

# 对列表进行切片，从3开始，到1结束，步长-1
my_list = [0, 1, 2, 3, 4, 5, 6]
result5 = my_list[3:1:-1]
print(f"结果5：{result5}")

# 对元组进行切片，从头开始，到尾结束，步长-2
my_tuple = (0, 1, 2, 3, 4, 5, 6)
result6 = my_tuple[::-2]
print(f"结果6：{result6}")

结果1：[1, 2, 3]
结果2：(0, 1, 2, 3, 4, 5, 6)
结果3：0246
结果4：76543210
结果5：[3, 2]
结果6：(6, 4, 2, 0)

4、Set（集合）

"""
演示数据容器集合的使用
"""

# 定义集合
my_set = {"传智教育", "黑马程序员", "itheima", "传智教育", "黑马程序员", "itheima", "传智教育", "黑马程序员", "itheima"}
my_set_empty = set()        # 定义空集合
print(f"my_set的内容是：{my_set}, 类型是：{type(my_set)}")
print(f"my_set_empty的内容是：{my_set_empty}, 类型是：{type(my_set_empty)}")

# 添加新元素
my_set.add("Python")
my_set.add("传智教育")      #
print(f"my_set添加元素后结果是：{my_set}")
# 移除元素
my_set.remove("黑马程序员")
print(f"my_set移除黑马程序员后，结果是：{my_set}")
# 随机取出一个元素
my_set = {"传智教育", "黑马程序员", "itheima"}
element = my_set.pop()
print(f"集合被取出元素是：{element}, 取出元素后：{my_set}")

# 清空集合, clear
my_set.clear()
print(f"集合被清空啦，结果是：{my_set}")

# 取2个集合的差集
set1 = {1, 2, 3}
set2 = {1, 5, 6}
set3 = set1.difference(set2)
print(f"取出差集后的结果是：{set3}")
print(f"取差集后，原有set1的内容：{set1}")
print(f"取差集后，原有set2的内容：{set2}")

# 消除2个集合的集
set1 = {1, 2, 3}
set2 = {1, 5, 6}
set1.difference_update(set2)
print(f"消除差集后，集合1结果：{set1}")
print(f"消除差集后，集合2结果：{set2}")

# 2个集合合并为1个
set1 = {1, 2, 3}
set2 = {1, 5, 6}
set3 = set1.union(set2)
print(f"2集合合并结果：{set3}")
print(f"合并后集合1：{set1}")
print(f"合并后集合2：{set2}")

# 统计集合元素数量len()
set1 = {1, 2, 3, 4, 5, 1, 2, 3, 4, 5}
num = len(set1)
print(f"集合内的元素数量有：{num}个")

# 集合的遍历
# 集合不支持下标索引，不能用while循环
# 可以用for循环
set1 = {1, 2, 3, 4, 5}
for element in set1:
print(f"集合的元素有：{element}")


my_set的内容是：{'黑马程序员', '传智教育', 'itheima'}, 类型是：<class 'set'>
my_set_empty的内容是：set(), 类型是：<class 'set'>
my_set添加元素后结果是：{'黑马程序员', 'Python', '传智教育', 'itheima'}
my_set移除黑马程序员后，结果是：{'Python', '传智教育', 'itheima'}
集合被取出元素是：黑马程序员, 取出元素后：{'传智教育', 'itheima'}
集合被清空啦，结果是：set()
取出差集后的结果是：{2, 3}
取差集后，原有set1的内容：{1, 2, 3}
取差集后，原有set2的内容：{1, 5, 6}
消除差集后，集合1结果：{2, 3}
消除差集后，集合2结果：{1, 5, 6}
2集合合并结果：{1, 2, 3, 5, 6}
合并后集合1：{1, 2, 3}
合并后集合2：{1, 5, 6}
集合内的元素数量有：5个
集合的元素有：1
集合的元素有：2
集合的元素有：3
集合的元素有：4
集合的元素有：5

5、Dict（字典、映射）

"""
演示字典的常用操作
"""
my_dict = {"周杰轮": 99, "林俊节": 88, "张学油": 77}
# 新增元素
my_dict["张信哲"] = 66
print(f"字典经过新增元素后，结果：{my_dict}")
# 更新元素
my_dict["周杰轮"] = 33
print(f"字典经过更新后，结果：{my_dict}")
# 删除元素
score = my_dict.pop("周杰轮")
print(f"字典中被移除了一个元素，结果：{my_dict}, 周杰轮的考试分数是：{score}")

# 清空元素, clear
my_dict.clear()
print(f"字典被清空了，内容是：{my_dict}")

# 获取全部的key
my_dict = {"周杰轮": 99, "林俊节": 88, "张学油": 77}
keys = my_dict.keys()
print(f"字典的全部keys是：{keys}")
# 遍历字典
# 方式1：通过获取到全部的key来完成遍历
for key in keys:
print(f"字典的key是:{key}")
print(f"字典的value是：{my_dict[key]}")

# 方式2：直接对字典进行for循环，每一次循环都是直接得到key
for key in my_dict:
print(f"2字典的key是:{key}")
print(f"2字典的value是：{my_dict[key]}")

# 统计字典内的元素数量, len()函数
num = len(my_dict)
print(f"字典中的元素数量有：{num}个")

运行结果：
字典经过新增元素后，结果：{'周杰轮': 99, '林俊节': 88, '张学油': 77, '张信哲': 66}
字典经过更新后，结果：{'周杰轮': 33, '林俊节': 88, '张学油': 77, '张信哲': 66}
字典中被移除了一个元素，结果：{'林俊节': 88, '张学油': 77, '张信哲': 66}, 周杰轮的考试分数是：33
字典被清空了，内容是：{}
字典的全部keys是：dict_keys(['周杰轮', '林俊节', '张学油'])
字典的key是:周杰轮
字典的value是：99
字典的key是:林俊节
字典的value是：88
字典的key是:张学油
字典的value是：77
2字典的key是:周杰轮
2字典的value是：99
2字典的key是:林俊节
2字典的value是：88
2字典的key是:张学油
2字典的value是：77
字典中的元素数量有：3个

数据容器的通用操作：

Java集合

1、List

ArrayList and LinkList

ArrayList用法同LinkList相同，仅底层数据存储方式差异：

package Java容器.List;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;

public class ArrayListDemo  {
    public static void main(String[] args) {
        //1、List容器定义与特性
//采用面向接口编程
        //向上转型时，子类单独定义的方法会丢失。比如上面Dog类中定义的run方法，当animal引用指向Dog类实例时是访问不到run方法的，animal.run()会报错。
        //子类引用不能指向父类对象。Cat c = (Cat)new Animal()这样是不行的。
        Collection c = new ArrayList();
        //最好不要这样写，最好面向接口编程
        ArrayList arrayList = new ArrayList();
        //面向接口编程
        List l = new ArrayList();
        //自动装箱，适合于 jdk1.5
l.add(1);
l.add(3);
//jdk1.5 以前，必须如下使用
l.add(new Integer(2));
    l.add(new Integer(4));
    //可以加入重复数据,但不再能加入字符串
    l.add(2);

        /**
         * 1、遍历循环第一种
         * */
        for (int i = 0; i < l.size(); i++) {
        //将 Object 强制转换为 Integer
            Integer e = (Integer)l.get(i);
            System.out.println(e);
        }
        System.out.println("--------------------------------------------------");
        /**
         * 2、遍历循环第二种
         * */
        //调用 remove 删除集合中的元素,如果元素重复会 remove 掉第一个匹配的
        l.remove(2);
        //采用 Iterator 遍历数据（while 循环）,Iterator 是一种模式，主要可以统一数据结构的访问方式
        Iterator iter = l.iterator();
        while( iter.hasNext() ) {
            Integer v = (Integer)iter.next();
            System.out.println(v);
        }
        System.out.println("---------------------------------------------------");
        /**
         * 3、遍历循环第三种,与第二种类同
         * */
        //采用 Iterator 遍历数据（for 循环）
        for (Iterator iter1 = l.iterator(); iter1.hasNext();) {
            Integer v = (Integer)iter1.next();
            System.out.println(v);
        }
        //在集合中是否包含 3，输出为：true
        System.out.println(l.contains(3));
        //集合是否为空，输出：false
        System.out.println(l.isEmpty());
        System.out.println("------------------------------------------------------");


        //转换成对象数组
        Object[] oArray1 = l.toArray();
        for (int i = 0; i < oArray1.length; i++) {
            Integer v = (Integer)oArray1[i];
            System.out.println(v);
        }
        System.out.println("--------------------------------------------------------");
        //运行时自动创建相应类型的数组
        Integer[] iArray = new Integer[l.size()];
        l.toArray(iArray);
        for (int i = 0; i < iArray.length; i++) {
            int v = iArray[i];
            System.out.println(v);
        }
    }
}

2、Set

HashSet

//HashSet存储自定义类对象，重写hashCode和equals
package Java容器.Set;

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

public class HashSetDemo {
        public static void main(String[] args) {
            Person p1 = new Person();
            p1.name = "张三";
            p1.age = 20;
            Person p2 = new Person();
            p2.name = "李四";
            p2.age = 30;
            Person p3 = new Person();
            p3.name = "张三";
            p3.age = 40;
            System.out.println("p1 equals p2," + p1.equals(p2));
            System.out.println("p1 equals p3," + p1.equals(p3));
            Set set = new HashSet();
            set.add(p1);
            set.add(p2);
            set.add(p3);
            for (Iterator iter = set.iterator(); iter.hasNext();) {
                Person p = (Person)iter.next();
                System.out.println("name=" + p.name + ", age=" + p.age);
            }
            System.out.println("p1.hashCode=" + p1.hashCode());
            System.out.println("p2.hashCode=" + p2.hashCode());
            System.out.println("p3.hashCode=" + p3.hashCode());
        }
    }
    class Person {
        String name;
        int age;
        //覆盖 hashCode
        public int hashCode() {
            return (name==null)?0:name.hashCode();
        }
        //覆盖 equals
        public boolean equals(Object obj) {
            if (this == obj) {
                return true;
            }
            if (obj instanceof Person) {
                Person p = (Person)obj;
                return this.name.equals(p.name);
            }
            return false;
        }
}

总结：

为何前面所写的程序大多没有进行hashCode和equals方法：
场景1：加载数据时使用HashMap存取数据对象，已经能够保证数据对象中唯一，不重写hashCode已足够判断是不同对象；

场景2：程序中普遍直接使用Set numbers = new HashSet();//存储去重后的号码,
Numbers.add（），这里利用的Set存储去重的特性，存取的元素也只保留key号码的唯一性，不重写hashCode足以。
场景3：但仅仅存储临时数据时，而非存储类对象，此时不需要。如果存在情况如下：

1、假设key得出的hashCode相等，不重写equals，则a,b两个不同地址，判定为两个不同的数据。存入集合。

2、假设key得出的hashCode相等，重写equals，则a之间相等，判定为两个相同的数据，这种情况下最好hashcode与equals都不重写。

理由：

1、 hashCode由于开放定址等一些散列函数仍会出现hash值相同的情况，在此场景下存在对象类value不相等时，重写equals方法。
2、但仅仅存储临时数据时，而非存储类对象，此时不需要。

TreeSet

package Java容器.Set;

import java.util.Comparator;
import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;

public class TreeSetDemo {
    public static void main(String[] args) {
        Person p1 = new Person();
        p1.name = "张三";
        p1.age = 20;
        Person p3 = new Person();
        p3.name = "张三";
        p3.age = 40;
        Person p2 = new Person();
        p2.name = "李四";
        p2.age = 30;
        Comparator personComparator = new PersonComparator();
        Set set = new TreeSet(personComparator);
        set.add(p1);
        set.add(p2);
        set.add(p3);
        for (Iterator iter = set.iterator(); iter.hasNext();) {
            Person p = (Person)iter.next();
            System.out.println("name=" + p.name + ", age=" + p.age);
        }
    }
}

class Person {
    String name;
    int age;
}

//实现 Person 的比较器
//Comparator 和 Comparable 的区别？
//Comparable 是默认的比较接口，Comparable 和需要比较的对象紧密结合到一起了
//Comparator 可以分离比较规则，所以它更具灵活性
class PersonComparator implements Comparator {
    public int compare(Object o1, Object o2) {
        if (!(o1 instanceof Person)) {
            throw new IllegalArgumentException("非法参数，o1=" + o1);
        }
        if (!(o2 instanceof Person)) {
            throw new IllegalArgumentException("非法参数，o2=" + o2);
        }
        Person p1 = (Person)o1;
        Person p2 = (Person)o2;
        return p1.age - p2.age;
    }
}

//匿名内部类方式实现
package Java容器.Set;

import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;

public class TreeSet匿名内部类01 {
    public static void main(String[] args) {
        Person03 p1 = new Person03();
        p1.name = "张三";
        p1.age = 20;
        Person03 p3 = new Person03();
        p3.name = "张三";
        p3.age = 40;
        Person03 p2 = new Person03();
        p2.name = "李四";
        p2.age = 30;
        Set set = new TreeSet();
        set.add(p1);
        set.add(p2);
        set.add(p3);
        for (Iterator iter=set.iterator(); iter.hasNext();) {
            Person03 p = (Person03)iter.next();
            System.out.println("name=" + p.name + ", age=" + p.age);
        }
    }
}
class Person03 implements Comparable {
    String name;
    int age;
    //如果覆盖了 equals，最好保证 equals 和 compareto 在
    //相等情况下的比较规则是一致的
    public int compareTo(Object o) {
        if (o instanceof Person03) {
            Person03 p = (Person03)o;
            //升序
            //return (this.age - p.age);
            //降序
            return (p.age-this.age);
        }
        throw new IllegalArgumentException("非法参数，o=" + o);
    }
}

3、Map

//HashMap存储数据示例；
package Java容器.Map;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class HashMap存储数据 {
    public static void main(String[] args) {
        Map map = new HashMap();
        map.put("1001", "张三");
        map.put("1002", "李四");
        map.put("1003", "王五");
        //采用 entrySet 遍历 Map
        Set entrySet = map.entrySet();
        for (Iterator iter=entrySet.iterator(); iter.hasNext();) {
            Map.Entry entry = (Map.Entry)iter.next();
            System.out.println(entry.getKey() + ", " + entry.getValue());
        }
        System.out.println("");
        //取得 map 中指定的 key
        Object v = map.get("1003");
        System.out.println("1003==" + v);
        System.out.println("");
        //如果存在相同的条目，会采用此条目替换
        //但 map 中始终保持的是不重复的数据
        //主要依靠 key 开判断是否重复，和 value 没有任何关系
        map.put("1003", "赵柳");
        //采用 keySet 和 get 取得 map 中的所有数据
        for (Iterator iter = map.keySet().iterator(); iter.hasNext();) {
            String k = (String)iter.next();
            System.out.println(k + ", " + map.get(k));
        }
    }
}

HashMap存储数据类对象示例：

package Java容器.Map;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

public class HashMap存储对象 {
    public static void main(String[] args) {
        IdCard idCard1 = new IdCard();
        idCard1.cardNo = 223243244243243L;
        Person person1 = new Person();
        person1.name = "张三";
        IdCard idCard2 = new IdCard();
        idCard2.cardNo = 223243244244343L;
        Person person2 = new Person();
        person2.name = "李四";
        IdCard idCard3 = new IdCard();
        idCard3.cardNo = 223243244243243L;
        Person person3 = new Person();
        person3.name = "张三";
        Map map = new HashMap();
        map.put(idCard1, person1);
        map.put(idCard2, person2);
        map.put(idCard3, person3);
        for (Iterator iter = map.entrySet().iterator(); iter.hasNext();) {
            Map.Entry entry = (Map.Entry)iter.next();
            IdCard idCard = (IdCard)entry.getKey();
            Person person = (Person)entry.getValue();
            System.out.println(idCard.cardNo + ", " + person.name);
        }
    }
}

class IdCard {
    long cardNo;
    //.........
    public boolean equals(Object obj) {
        if (obj == this) {
            return true;
        }
        if (obj instanceof IdCard) {
            IdCard idCard = (IdCard)obj;
            if (this.cardNo == idCard.cardNo) {
                return true;
            }
        }
        return false;
    }
    public int hashCode() {
        return new Long(cardNo).hashCode();
    }
}

class Person {
    String name;
}

TreeMap

//TreeMap存储数据示例;如果存储数据类对象，见上面TreeSet
import java.util.TreeMap;

public class TreeMapDemo {
    public static void main(String[] args) {
        Map map = new TreeMap();
        map.put("1003", "王五");
        map.put("1001", "张三");
        map.put("1002", "李四");
        for (Iterator iter = map.entrySet().iterator(); iter.hasNext();) {
            Map.Entry entry = (Map.Entry)iter.next();
            System.out.println(entry.getKey() + ", " + entry.getValue());
        }
    }
}

容器使用选择