集合(复习)

最新推荐文章于 2020-08-25 15:05:35 发布

waectr

最新推荐文章于 2020-08-25 15:05:35 发布

阅读量182

点赞数

分类专栏： Java基础文章标签：集合

本文链接：https://blog.csdn.net/waectr/article/details/81259162

版权

Java基础专栏收录该内容

12 篇文章 0 订阅

订阅专栏

本文介绍了集合数据结构中的List、Set接口及其常见实现，包括ArrayList、LinkedList、HashSet、LinkedHashSet。同时，讲解了Map接口及HashMap、LinkedHashMap的键值对存储方式，强调了集合中元素的唯一性和存储结构的影响。

摘要由CSDN通过智能技术生成

首先来明确一下关系

接口：用来明确所有集合中该具有的功能，相当于在定义集合功能标准；
抽象类：把多个集合中功能实现方式相同的方法，抽取到抽象类实现，具体集合不再遍写，继承使用即可；
具体类：继承抽象类，实现接口，重写所有抽象方法，达到具备指定功能的集合。每个具体集合类，根据自身的数据存储结构方式，对接口中的功能方法，进行不同方式的实现。

List接口

List接口常用的子类有：

ArrayList 和 LinkedList

ArrayList的存储结构是数组

LinkedList的存储结构是链表，他提供了大量的首尾操作的方法

LinkedList集合可以作为堆栈，队列使用，这在平时的使用中很重要

import java.util.LinkedList;

public class LinkedListDemo {

    public static void main(String[] args) {
        LinkedList<String> link=new LinkedList<String>();
        link.addFirst("abc");//将元素插入到此列表的开头
        link.add("abc2");//如果不指定，就会默认添加到尾部
        link.addFirst("abc3");
//        System.out.println(link.getFirst());
//        System.out.println(link.getLast());
        while(!link.isEmpty()){ //判断集合是否为空
            System.out.println(link.pop()); //弹出集合中的栈顶元素
        }
    }
}

Set接口

Hashset

Hashset集合的储存数据的结构是哈希表

哈希表：当向哈希表中存储数据时，会会调用对象的hashCode方法，这个方法是Object类中的，计算出哈希码，两个一样的数据一定会算出一样的哈希码，但是两个不同的数据可能会算出相同的哈希码，所以，在哈希码相同的情况下，系统会调用equals()函数来进行对比，确认值是否重复，它保证了集合元素的唯一性

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

public class HashSetDemo {

    public static void main(String[] args) {
        HashSet<String> hs=new HashSet<String>();
        hs.add("wang");
        hs.add("zhao");
        hs.add("haha");
        hs.add("haha");//最终的结果只有一个haha，说明hashSet可以自动查重
        hs.add("abc");
        //使用迭代器取出集合中的每一个元素
        Iterator<String> it=hs.iterator();
        while(it.hasNext()){
            String s=it.next();
            System.out.println(s);
        }
    }
}

通过这个例子可以了解到迭代器的使用和HashSet的自动查重，API中还介绍道，HashSet输出不保证有序

HashSet还可以存储自定义元素类型

我们先创建一个学生类：

import java.util.Objects;

public class Student {
    private String name;
    private int age;
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + 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 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 &&
                Objects.equals(name, student.name);
    }
    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

在这里我们分别测试了HashSet的存储时的各种不同形式

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

public class HashSetDemo1 {
    public static void main(String[] args) {
        HashSet<Student> hs=new HashSet<Student>();
        hs.add(new Student("a",1));//相同年龄，不同名字
        hs.add(new Student("li",1));
        hs.add(new Student("a",2));//相同名字 不同年龄
        hs.add(new Student("a",1));//相同名字年龄

        Iterator it=hs.iterator();
        while(it.hasNext()){
            Student s=(Student) it.next();
            System.out.println(s);
        }
    }
}

经过输出，我们可以看到，相同名字，相同年龄的数据没有进入

LinkedHashSet

HashSet可以保证元素的唯一性，但是存放进去却没有顺序，使用LinkedHashSet可以是它存储起来有序，而且也有查重功能

import java.util.*;

public class LinkedHashSetDemo {
    public static void main(String[] args) {
        Set<String> set = new LinkedHashSet<String>();
        set.add("bbb");
        set.add("aaa");
        set.add("abc");
        set.add("bbb");
        Iterator it = set.iterator();
        while (it.hasNext()) {
            System.out.println(it.next());
        }
    }
}

Map集合

刚才我们所看到的List 和 Set都是Collection接口的集合，他们都是单集存在的

而Map接口下的集合们，都是以键值对的形式存在的

Map下常用的集合为HashMap集合和LinkedHashMap集合

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

public class MapDemo {

    public static void main(String[] args) {
        Map<String,String> map=new HashMap<String,String>();
        map.put("星期一","Monday");
        map.put("星期日","Sumday");
        System.out.println(map);

        //先取出key
        String en=map.get("星期日");
        System.out.println(en);

        //根据键值删除元素 返回对应key的value值
        String value=map.remove("星期日");
        System.out.println(value);
    }
}

Map集合找值得方法是，先找到它的键，利用keySet（）方法获得键，然后通过键在集合中找值

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

public class MapDemo1 {

    public static void main(String[] args) {
        Map<String,String> map=new HashMap<String, String>();
        //给map添加值
        map.put("a","b");
        map.put("c","d");
        map.put("e","f");
        map.put("g","h");

        //创建一个用于接收键Set的集合
        Set<String> keySet=map.keySet();
        //使用迭代器迭代它
        Iterator<String> it=keySet.iterator();
        while(it.hasNext()){
            String key=it.next(); //从集合中取出键
            String value=map.get(key);//通过键取出值
            System.out.println(key+"="+value);
        }
    }
}

还有一种方法来获得它的键值对

import java.util.*;

public class MapDemo2 {
    //创建Map对象
    Map<String, String> map = new HashMap<String,String>();
    //给map中添加元素
      map.put("aa", "bb");
      map.put("cc", "dd");
        map.put("ee", "ff");
        //获取Map中的所有key与value的对应关系
        Set<Map.Entry<String,String>> entrySet = map.entrySet();
        //遍历Set集合
        Iterator<Map.Entry<String,String>> it =entrySet.iterator();
     	 while(it.hasNext()){
            //得到每一对对应关系
            Map.Entry<String,String> entry = it.next();
            //通过每一对对应关系获取对应的key
            String key = entry.getKey();
            //通过每一对对应关系获取对应的value
            String value = entry.getValue();
            System.out.println(key+"="+value);
        }
}
}
}

Map不能直接用迭代器或者超级for进行遍历，需要转为Set

它也可以存储自定义类型的键值对，刚才我们已经创建了一个Student类，就使用它

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

public class HashMapTest {

    public static void main(String[] args) {
        Map<Student,String> map=new HashMap<Student, String>();
        map.put(new Student("list",9),"haha");
        map.put(new Student("ad",12),"cvvx");

        //此处将Student取出来存到Set集合中
        Set<Student> keySet=map.keySet();
        for(Student key:keySet){
            String value=map.get(key);
            System.out.println(key.toString()+" "+value);
        }

        //取出元素
        Set<Map.Entry<Student,String>> entrySet=map.entrySet();
        for(Map.Entry<Student,String> entry:entrySet){
            Student key=entry.getKey();
            String value=entry.getValue();
            System.out.println(key.toString()+" "+value);
        }
    }
}

总结一下：List : ArrayList和LinkedList 分别相当于数组和链表

Set：HashSet和LinkedHashSet 他们都遵循哈希表，元素具有唯一性 HashSet存储方式不确保顺序

Map: HashMap 它是以键值对形式存储的

waectr

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
集合(复习)

首先来明确一下关系接口：用来明确所有集合中该具有的功能，相当于在定义集合功能标准；抽象类：把多个集合中功能实现方式相同的方法，抽取到抽象类实现，具体集合不再遍写，继承使用即可；具体类：继承抽象类，实现接口，重写所有抽象方法，达到具备指定功能的集合。每个具体集合类，根据自身的数据存储结构方式，对接口中的功能方法，进行不同方式的实现。 List接口List接口常用的子类有：...
复制链接

扫一扫

专栏目录