集合和映射

最新推荐文章于 2023-07-28 16:27:16 发布
最新推荐文章于 2023-07-28 16:27:16 发布
阅读量148 收藏
点赞数
分类专栏： 学生 java 数据结构 文章标签： 数据结构 集合和映射
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42479155/article/details/89429978
版权
学生 同时被 3 个专栏收录
112 篇文章 0 订阅
订阅专栏
java
91 篇文章 1 订阅
订阅专栏
数据结构
59 篇文章 0 订阅
订阅专栏

集合和映射

集合

  • 和数学里面定义一样：无序，不重复

  • 里面的具体的包装类BST：二分搜索树和链表之前已经发过

    package 数据结构.set;

import 数据结构.BST.BST;
//使用二分搜索树来进行集合表达
public class BSTSet<E extends Comparable<E>> implements Set<E> {
    private BST<E> bst;
    public BSTSet(){
        bst=new BST<>();
    }

    @Override
    public int getSize() {
        return bst.getSize();
    }

    @Override
    public boolean isEmpty() {
        return bst.isEmpty();
    }

    @Override
    public void add(E e) {
        bst.add(e);
    }

    @Override
    public boolean contains(E e) {
        return  bst.contains(e);
    }

    @Override
    public void remove(E e) {
        bst.remove(e);
    }
}
package 数据结构.set;

import 数据结构.LinkedList.LinkedList;

import java.util.ArrayList;
//使用链表进行表示集合
public class LinkedListSet<E> implements Set<E> {
    private LinkedList<E> list;
    public LinkedListSet(){
        list = new LinkedList<>();
    }

    @Override
    public int getSize() {
        return list.getSize();
    }
    public boolean isEmpty(){
        return list.isEmpty();
    }

    @Override
    public boolean contains(E e) {
        return  list.contains(e);
    }

    @Override
    public void add(E e) {
        if(!list.contains(e))
            list.addFirst(e);
    }

    @Override
    public void remove(E e) {
        list.removeElement(e);
    }
    public static void main(String[] args) {
        System.out.println("Pride and Prejudice");
        ArrayList<String> words1 = new ArrayList<>();
        FileOperation.readFile("C:\\Users\\admin\\IdeaProjects\\untitled1\\src\\数据结构\\set\\pride-and-prejudice.txt",words1);
        LinkedListSet<String> set1 = new LinkedListSet<>();
        for (String word:words1) {
            set1.add(word);
        }
        System.out.println(set1.getSize());
        System.out.println(words1.size());
    }
}

  • 通过复杂度分析：我们可以明显知道，以二叉树来表示集合，速度更快，而使用链表时间复杂度高的多

映射(map)

  • 俗称：字典或者键值对

  • 也有两种处理方式：链表映射和二叉树映射

  • 链表映射：

    package 数据结构.map;

import 数据结构.LinkedList.LinkedList;

import java.security.Key;
import java.util.ArrayList;
import java.util.Set;
import java.util.function.ToDoubleBiFunction;

public class LinkedListMap<K,V>implements Map<K,V> {
    public class Node{
        public K key;
        public V value;
        public Node next;
        public Node(K key,V value,Node next){
            this.key = key;
            this.value = value;
            this.next = next;
        }
        public Node(K key)
        {
            this(key,null,null);
        }
        public Node(){
            this(null,null,null);
        }

        @Override
        public String toString() {
            return  key.toString()+":"+value.toString();
        }
    }
    private Node dummyHead;
    private int size;
    public LinkedListMap(){
        dummyHead = new Node();
        size=0;
    }

    @Override
    public int getSize() {
        return size;
    }

    @Override
    public boolean isEmpty() {
        return size==0;
    }
    private Node getNode(K key){
        Node cur = dummyHead.next;
        while (cur !=null)
        {
            if(cur.key.equals(key))
                return cur;
            cur = cur.next;
        }
        return null;
    }

    @Override
    public boolean contains(K key) {
        return getNode(key)!=null;
    }

    @Override
    public V get(K key) {
        Node node = getNode(key);
        return node==null?null:node.value;
    }

    @Override
    public void add(K key, V value) {
        Node node = getNode(key);
        if(node==null){
            dummyHead.next = new Node(key,value,dummyHead.next);
            size++;
        }
        else {
            node.value = value;
        }
    }

    @Override
    public void set(K key, V newValue) {
        Node node = getNode(key);
        if(node==null)
            throw new IllegalArgumentException(key+"doesn't exist!");
        node.value = newValue;
    }

    @Override
    public V remove(K key) {
        Node prev = dummyHead;
        while (prev.next!=null)
        {
            if(prev.next.key.equals(key))
                break;
            prev = prev.next;
        }
        if(prev.next!=null){
            Node delNode = prev.next;
            prev.next = delNode.next;
            delNode.next = null;
            size--;
            return delNode.value;
        }
        return null;
    }

    public static void main(String[] args) {
        System.out.println("Pride and Prejudice");
        ArrayList<String> words = new ArrayList<>();
        if(FileOperation.readFile("C:\\Users\\admin\\IdeaProjects\\untitled1\\src\\数据结构\\map\\pride-and-prejudice.txt",words))
        {
            System.out.println("Total words: "+words.size());
            LinkedListMap<String,Integer> map = new LinkedListMap<>();
            for (String word:words)
            {
                if (map.contains(word))
                {
                    map.set(word,map.get(word)+1);
                }
                else{
                    map.add(word,1);
                }
            }
            System.out.println(map.getSize());
        }

    }
}

  • 二分搜索树映射

    package 数据结构.map;

import java.nio.channels.ClosedSelectorException;
import java.security.PublicKey;
import java.util.ArrayList;

public class BSTMap<K extends Comparable<K>,V>implements Map<K,V> {
    private class Node{
        public K key;
        public V value;
        public Node left,right;
        public Node(K key,V value){
            this.key = key;
            this.value = value;
            left = null;
            right=null;
        }
    }
    private  Node root;
    private  int size;
    public BSTMap(){
        root = null;
        size = 0;
    }

    @Override
    public int getSize() {
        return size;
    }

    @Override
    public boolean isEmpty() {
        return size==0;
    }
//向二分搜索树中添加新的元素
    @Override
    public void add(K key, V value) {
        root = add(root,key,value);
    }

    //向以node为根的二分搜索树中插入元素，使用递归算法
    //返回插入新节点后的二分搜索树的根
    private Node add(Node node,K key,V value)
    {
        if(node == null)
        {
            size++;
            return new Node(key,value);
        }
        if (key.compareTo(node.key)<0)
        {
            node.left = add(node.left,key,value);
        }
        else if (key.compareTo(node.key)>0)
        {
            node.right  = add(node.right,key,value);
        }
        else{
            node.value = value;
        }
        return node;
    }
    //返回以node为根节点的二分搜索树中，key所在的节点
    private Node getNode(Node node,K key){
        if(node==null)
            return null;
        if(key.compareTo(node.key)==0)
            return node;
        else if(key.compareTo(node.key)<0)
            return getNode(node.left,key);
        else
            return getNode(node.right,key);
    }

    @Override
    public boolean contains(K key) {
        return getNode(root,key)!=null;
    }

    @Override
    public V get(K key) {
        Node node = getNode(root,key);
        return node ==null?null:node.value;
    }

    @Override
    public void set(K key, V newValue) {
        Node node = getNode(root,key);
        if(node.left == null)
            throw  new IllegalArgumentException(key+"doesn't exist!");
        node.value = newValue;
    }
    //返回以node为根的二分搜索树的最小值所在节点
    private Node minimum(Node node){
        if(node.left == null)
            return node;
        return minimum(node.left);
    }
    //删除最小节点
    private Node removeMin(Node node){
        if(node.left == null){
            Node rightNode = node.right;
            node.right = null;
            size--;
            return rightNode;
        }
        node.left = removeMin(node.left);
        return node;
    }
    //在树中删除节点的方法

    @Override
    public V remove(K key) {
        Node node = getNode(root,key);
        if(node!=null)
        {
            root = remove(root,key);
            return node.value;
        }
        return null;
    }
    //删除掉某一结点
    //返回删除节点后新的二分搜索树的根
    private  Node remove(Node node,K key) {
        if (node == null)
            return null;
        if (key.compareTo(node.key) < 0) {
            node.left = remove(node.left, key);
            return node;
        } else if (key.compareTo(node.key) > 0) {
            node.right = remove(node.right, key);
            return node;
        } else {//k==node.e
            //待删除节点左子树为空
            if (node.left == null) {
                Node rightNode = node.right;
                node.right = null;
                size--;
                return rightNode;
            }
            //待删除节点右子树为空
            if (node.right == null) {
                Node leftNode = node.left;
                node.left = null;
                size--;
                return leftNode;
            }
            //待删除节点左右子树均不为空的情况
            //找到比待删除节点大的最小节点，即待删除节点右子树的最小节点
            //用这个节点替换待删除节点的位置
            Node successor = minimum(node.right);
            successor.right = removeMin(node.right);
            successor.left = node.left;
            node.left = node.right = null;
            return successor;
        }
        }
        public static void main(String[] args) {
            System.out.println("Pride and Prejudice");
            ArrayList<String> words = new ArrayList<>();
            if(FileOperation.readFile("C:\\Users\\admin\\IdeaProjects\\untitled1\\src\\数据结构\\map\\pride-and-prejudice.txt",words))
            {
                System.out.println("Total words: "+words.size());
                BSTMap<String,Integer> map = new BSTMap<>();
                for (String word:words)
                {
                    if (map.contains(word))
                    {
                        map.set(word,map.get(word)+1);
                    }
                    else{
                        map.add(word,1);
                    }
                }
                System.out.println(map.getSize());
            }

        }
    }

  • 集合和映射，使用原理大概一样

胖虎艾春辉
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
集合与映射
weixin_56165759的博客
01-11 1926
集合与映射
映射和集合
money_monkey的博客
09-06 312
映射和集合
集合映射
尉微的博客专栏
12-12 1779
集合映射 在持久化类中，有时会使用到值类型的对象属性。所谓值类型的对象属性，是指它对应的类没有对象标识符属性，只能作为一个持久化类的属性使用。如果持久化类中有一个值类型的集合，那么就需要一张额外的数据库表来保存这个值类型集合的数据，这张表被称为集合表。 1、  选择集合接口 Hibernate支持大部分重要的JDK集合接口映射，主要有以下几种。 （1）、元素：可以映射类型为java.uti
Java底层基于链表实现集合和映射--集合Set操作详解
08-19
主要介绍了Java底层基于链表实现集合和映射集合Set操作,结合实例形式详细分析了Java使用链表实现集合和映射相关原理、操作技巧与注意事项,需要的朋友可以参考下
Java底层基于二叉搜索树实现集合和映射/集合Set功能详解
08-19
主要介绍了Java底层基于二叉搜索树实现集合和映射/集合Set功能,结合实例形式分析了Java使用二叉搜索树实现集合和映射相关操作技巧,需要的朋友可以参考下
课7 - 集合和映射类型.mhtml
05-22
课7 - 集合和映射类型.mhtml
集合和映射表（一）
weixin_52273794的博客
03-13 785
介绍Java合集框架中的集合和映射表。
映射集合(Mapping a Collection)
watano_cc的专栏
03-01 909
在Hibernate配置文件中使用, , , , 和 等元素来定义集合,而是最典型的一个。 <map name="propertyName" (1) table="table_name" (2) s
学习总结-映射集合
u013470578的专栏
02-18 694
映射 映射的组成：键-值对(key-value)，在一个Map中，键key是不可以重复的，是唯一的，value是可以重复的，一个键key对应一个值value 有HashMap,TreeMap,LinkedHashMap三种，特点与Set类似 格式：Map love = new HashMap();  //JDK6    格式与List相同 常用方法： love.put("天天",
六、映射 -- 集合映射
weixin_45602227的博客
05-13 1057
一、主表与外键表的映射关系 +++ 外键表与主键表的关系 外键表的外键受到主键表的主键所约束。 +++ 集合映射 描述外键表与主键表的映射关系，有好几种方式。 本文只是讲解了集合映射。集合映射只能映射主键表的简单字段。 list集合映射： 映射的主键表只能有三个字段（主键、序列字段、简单字段） array映射： 映射的主键表只能有三个字段（主键、序列字段、简单字段） set映射： 映射的主键表只能有两个字段
9.集合与映射
EdSheeran的博客
08-02 786
文章目录*集合**9.1Java集合框架**9.1.1集合接口与实现分离**9.1.2`Collection`接口**9.1.3迭代器**9.2集合框架中的接口**9.3具体集合**9.3.1链表**9.3.3散列集**9.3.4树集**9.3.5队列与双端队列**9.3.6优先队列(典型用法是任务调度)**9.4映射**9.4.1基本映射操作**9.4.2更新映射条目**9.4.3映射视图**9.4.4弱散列映射(使用弱引用保存键)**9.4.5链接散列集与映射(记住插入元素项的顺序)**9.4.6枚举集
集合映射详解
Shirley_John_Thomas的博客
09-11 4946
一、集合映射   1.1 集合小介      集合映射也是基本的映射，但在开发过程中不会经常用到，所以不需要深刻了解，只需要理解基本的使用方法即可，等在开发过程中遇到了这种问题时能够查询到解决方法就可以了。对应集合映射它其实是指将java中的集合映射到对应的表中，是一种集合对象的映射，在java中有四种类型的集合，分别是Set、Map、List还有普通的数组，它们之
集合论知识总结——映射
最新发布
m0_62249876的博客
07-28 4735
定理3 设f:X→Y，g:Y→Z，若f和g都是可逆的，则gf也是可逆的且(gf)-1=f-1g-1，（f–1)-1=f。若|S|=n，则S上的置换称为n次置换。：设f:X→Y，A⊆X，由f和Ａ可以唯一的确定Ｙ 中的一个子集，记为f(A)，f(A)={f(x)|x。A，h(x)=g(f(x))，则称h为映射f与g的合成。1.限制与扩张：设f:Ｘ→Y，A⊆X，当把f的定义域限制在Ａ上时，就得到了一个j:A→Y，"x。(2)若存在一个映射h:Y→X,使得fh=IY，则称f是右可逆的，而h称为f的右逆映射。
xFire开发webService返回复杂对象
溺水的鱼 - Later equals never.
07-21 5207
XFire开发时，在返回数据类型时遇到了一些麻烦，查到这样一篇文单，非常不错，故收藏之。翻译：zilong3927  原文地址：http://docs.codehaus.org/display/XFIRE/Mapping+collections调用Web Services时，经常需要返回集合（collection）作为结果，或者接受col
集合与映射基础讲解
本文将详细探讨集合、映射和函数的基本概念，这是数学中的基础理论，尤其在计算机科学和信息技术领域有着广泛的应用。 首先，我们来看集合的定义。集合是由具有某种特定性质的事物组成的整体，这些事物称为元素。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值