Java基础学习（九）- 集合

面向对象开发时应该储存多个对象，而要储存多个对象就不能是基本变量了，应该是一个容器变量，这时候集合的出现就解决了我们现在的问题。

Collection

概述

• 是单例集合的顶层接口，Collection表示一组对象，这些对象也称为Collection的元素。
• JDK不提供接口的任何实现，实现：它提供更具体的子接口（如Set和List）的实现
• 创建Collection集合
  • 多态
  • 具体实现类ArrayList()
• 添加元素
  • add

创建一个collection集合

Collection<String> c = new ArrayList<String>();

添加元素

public static void main(String[] args) {

Collection<String> c = new ArrayList<String>();

c.add("lisa");
c.add("leon");
c.add("hello");

System.out.println(c);
}

删除集合中的元素

c.remove("leon");

清除集合中的所有元素

c.clear()

获取集合的长度

System.out.println(c.size());

判断集合中是否存在元素

boolean isContain = c.contains("leon");

判断集合是否为空

boolean isEmpty = c.isEmpty();

遍历Collection集合

//迭代器
Iterator<String> it = c.iterator();

//如果迭代器还有next值就继续
while (it.hasNext()){
    String s = it.next();
    System.out.println(s);
}

新建一个Student类，添加3个对象到Collection集合中，并且遍历输出

//Student
public class Student {
    private String name;
    private int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

//main
public static void main(String[] args) {
        Collection<Student> collection = new ArrayList<Student>();

        Student s1 = new Student("Leon",18);
        Student s2 = new Student("sisi",19);
        Student s3 = new Student("giva",20);

        collection.add(s1);
        collection.add(s2);
        collection.add(s3);

        //新建一个迭代器
        Iterator<Student> it = collection.iterator();

        while (it.hasNext()){
            Student showStudent = it.next();
            System.out.println(showStudent.toString());
        }
    }

List集合

public static void main(String[] args) {
        List<String> list = new ArrayList<String>();

        list.add("Leon");
        list.add("Lisa");
        list.add("Giva");
        list.add("Giva");

        Iterator<String> it = list.iterator();

        while (it.hasNext()){
            System.out.println(it.next());
        }
    }

特点
有序的，可重复的。其他的与collection差不多。既然是有序的那么插入的时候可以在某一个下标下添加或者删除元素。

添加

list.add(1,"NICE");

删除

list.remove(1);

获取某一个下标的值

list.get(1);

修改某下标的元素

list.set(1,"heha");

遍历

第一种：遍历

for (int i = 0; i < list.size(); i++){
    System.out.println(list.get(i));
}

第二种：迭代器

Iterator<String> it = list.iterator();
while (it.hasNext()){
    System.out.println(it.next());
}

ArrayList和LinkedList

ArrayList
底层数据结构是数组，查询快，增删慢

LinkedList
底层数据结构是链表，查询慢，增删块

Set

定义
一个不包含重复元素的Collection集合

HashSet: 不保证set的迭代顺序，特别是它不保证该顺序恒久不变。

一个简单的Set

public static void main(String[] args) {
        Set<String> set = new HashSet<String>();
        set.add("leon");
        set.add("sisi");
        set.add("giva");

        for (String s : set){
            System.out.println(s);
        }
    }

HashSet底层实现

1. 首先比较对象的哈希值是否相同，这个哈希值是根据对象的Hashcode（）计算出来的。
2. 如果哈希值不同，则添加到集合中
3. 如果哈希值相同，则继续执行equal()进行比较
4. 返回是true，说明元素重复，不添加
5. 返回是false，说明元素不重复，添加

注意
如果是将对象添加到集合中，必须要注意重写equal和hashcode方法，因为集合中是根据这两个方法来判断集合中的元素是否相等。所以在对象中必须要添加：

@Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age &&
                name.equals(student.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }

这知识一个简单的student类，里面包含一个string name和一个int age属性，具体的还需要看你要声明的具体属性来定，Eclpise和IntelliJ应该都能自动生成这两个方法。

Map

定义
将键值映射到值得对象，一个映射不能包含重复的键，没个键最多映射到一个值

Map<String,String> map = new HashMap<String,String>();

添加一个映射

map.put("001","leon");

删除一个映射

map.remove("003");

清除所有的元素

map.clear();

判断集合中是否包含指定的键

boolean ishasKey = map.containsKey("003");

判断集合中是否包含指定的值

boolean ishasValue = map.containsValue("leon");

判断集合是否为空

boolean isEmpty = map.isEmpty();

返回集合的长度

int length = map.size();

根据键获取值

map.get("001");

获取所有的键

Set<String> set = map.keySet();

for (String key : set){
    System.out.println(key);
}

获取所有值的集合

Collection<String> values = map.values();

for (String v : values){
    System.out.println(v);
}

Map的遍历

第一种:根据键找值

• 获取所有键的集合
• 遍历键的集合，找到每一个值
• 根据键找值

Set<String> set = map.keySet();

for (String key : set){
    String values = map.get(key);
    System.out.println("key====>"+key+"------ values====>"+values);
}

第二种：根据键值对对象找键和值

• 获取所有键值对象的集合
• 遍历键值对对象的集合，获取到每一个键值对对象
• 根据键值对对象找键和值

Set<Map.Entry<String,String>> set = map.entrySet();

for (Map.Entry<String,String> me :set){
    String key = me.getKey();
    String value = me.getValue();
    System.out.println("Key is "+ key + " Value is "+value);
}