精华内容
下载资源
问答
  • 一对多关系通过外键关系连接个表,而没有中间的表。 首先先引用一段对集合的释义:   Bag:对象集合,每个元素可以重复。例如{1,2,2,6,0,0},在.Net中相当于IList或者IList实现。 Set:对象集合,每个元素...

    一对多关系通过外键关系连接两个表,而没有中间的表。

    首先先引用一段对集合的释义:

     

    Bag:对象集合,每个元素可以重复。例如{1,2,2,6,0,0},在.Net中相当于IList或者IList<T>实现。

    Set:对象集合,每个元素必须唯一。例如{1,2,5,6},在.Net中相当于ISet或者ISet<T>实现,Iesi.Collections.dll程序集提供ISet集合。

    List:整数索引对象集合,每个元素可以重复。例如{{1,"YJingLee"},{2,"CnBlogs"},{3,"LiYongJing"}},在.Net中相当于ArraryList或者List<T>实现。

    Map:键值对集合。例如{{"YJingLee",5},{"CnBlogs",7},{"LiYongJing",6}},在.Net中相当于HashTable或者IDictionary<Tkey,TValue>实现。

     

    持久类:

    (一)Customer

    public class Customer

    {

    public virtual int Unid { get; set; }

    public virtual FllName Name { get; set; }

    public virtual DateTime CreateTime { get; set; }

    public virtual string Address { get; set; }

    public virtual int Version { get; set; }

     

    private IList<Call> _list = new List<Call>();

    public virtual IList<Call> Phones

    {

    get { return _list; }

    set { _list = value; }

    }

    }

     

    public class FllName

    {

    public string FirstName { get; set; }

    public string LastName { get; set; }

    public string Names

    {

           get

    {

    return (FirstName+"·"+LastName);

    }

    }

    }

    这个类我要用于component,和一对多关系应用,所以多了个FullName复合属性。

    (二)Call

    public class Call

    {

    public virtual int Unid { get; set; }

    public virtual string Phone { get; set; }

     

    public virtual Customer Customer { get; set; }

    }

    这个类就是onetomany中的many一方

    (三)Customer mapping

    <bagname="Phones"table="Calls"cascade="all"inverse="true">

          <keycolumn="CustomerId"></key>

          <one-to-manyclass="Domain.Entities.Call,Domain"/>

    </bag>

    (四)Call mapping

       <many-to-onename="Customer"column="CustomerId"

    class="Domain.Entities.Customer,Domain"not-null="true"/>

     

    说明一下:

    ·对于数据库表之间的关联关系,nhibernate也是mapping过来了(自己理解),所以不必在数据库中为数据表人为的建立关系,如果那样的话,nhibernate中就不必建立一对多关系了(这个我还没有测试)。

    ·对于一对多关系中的两方:一的一方带一个集合属性,而这个集合是多的那一方的集合;而多的一方带有一个一方的类型的属性,可以这样描述:一个父亲带有一群孩子,而一个孩子心中(现实也是)也有一个父亲。而对于对象的nhb,数据库中的外键由对象来描述。

     

    其实在这里,关系已经建立起来了,要做的就是进行curd了。

    (一)查询

    [Test]

    public void TestGetOne()

    {

        Customer cc = hh.GetElementById(38); 

     

        foreach (Call call in cc.Phones)

        {

    Console.WriteLine(call.Phone);

        }

    }

    其中的GetElementById方法就是查询一个Customer持久数据而已,但因为关系的建立,使得它的Phones属性得以填充。查看它的sql语句为:

    SELECT customer0_.Unid as Unid0_0_, customer0_.Version as Version0_0_, customer0_.FirstName as FirstName0_0_, customer0_.LastName as LastName0_0_, customer0_.CreateTime as CreateTime0_0_, customer0_.Address as Address0_0_ FROM Customer customer0_ WHERE customer0_.Unid=@p0;@p0 = 38

    SELECT phones0_.CustomerId as CustomerId1_, phones0_.Unid as Unid1_, phones0_.Unid as Unid1_0_, phones0_.Phone as Phone1_0_, phones0_.CustomerId as CustomerId1_0_ FROM Calls phones0_ WHERE phones0_.CustomerId=@p0;@p0 = 38

    分别查询两个表中的数据

    (二)添加

    public void TestAdd()

    {

        Customer c = new Customer

        {

    Name = new FllName { FirstName = "", LastName = "" },

    Address = "清河县1"

        };

     

        Call phones = new Call { Phone = "7777778" };

        Call phones1 = new Call { Phone = "9999978" };

        phones.Customer = c;

        phones1.Customer = c;

        try

        {

    c.Phones.Add(phones);

    c.Phones.Add(phones1);

        }

        catch

        { }

     

        hh.AddUpdateDelete(Domain.Enums.eOperation.Add, c);

    }

    这里的Customer的Phones是一个Call的集合。

    (三)删除

    public void TestDelete()

    {

        Customer c = new Customer {Unid=38};

        hh.AddUpdateDelete(Domain.Enums.eOperation.Delete, c);

    }

    直接删除就行了。

    (四)更新

    public void TestUpdate()

    {

        Customer c;

        c = hh.GetElementById(40);

        c.Phones[0].Phone = "55555555";

       

        hh.AddUpdateDelete(Domain.Enums.eOperation.Update, c);

    }

    博客园大道至简

    http://www.cnblogs.com/jams742003/

    转载请注明:博客园

    展开全文
  • Java集合详解--什么是List

    万次阅读 多人点赞 2016-10-19 22:20:47
    简述上章简单介绍了什么是集合集合有哪几种种类。 在这章中我们主要介绍Collection的其中一种实现方式,List。 什么是List在上一章,我们已经了解了List主要分为3类,ArrayList, LinkedList和Vector。 为了...

    简述


    上章简单介绍了什么是集合,集合有哪几种种类。
    在这章中我们主要介绍Collection的其中一种实现方式,List。



    什么是List


    在上一章,我们已经了解了List主要分为3类,ArrayList, LinkedList和Vector。
    为了进一步清晰List的结构,我在这手工画了一张图,用于回顾下

    这里写图片描述

    AbstarctCollection在上一张Java集合详解–什么是集合已经有简单的介绍,它是Collection接口的部分实现

    1.List接口

    首先看下List的官方定义

    这里写图片描述

    这段描述解决了许多公司经常问的两个问题List有什么特点和Set有什么区别。
    上面清楚的说明了List是一个有序的集合,和set不同的是,List允许存储项的值为空,也允许存储相等值的存储项,还举了e1.equal(e2)的例子。

    List是继承于Collection接口,除了Collection通用的方法以外,扩展了部分只属于List的方法。

    这里写图片描述

    从上图可以发现,List比Collection主要多了几个add(…)方法和remove(…)方法的重载,还有几个index(…), get(…)方法。
    而AbstractList也只是实现了List接口部分的方法,和AbstractCollection是一个思路,这里就不具体介绍了,有兴趣的同学可以自行研究下。

    2.ArraryList

    ArrayList是一个数组实现的列表,由于数据是存入数组中的,所以它的特点也和数组一样,查询很快,但是中间部分的插入和删除很慢。我们来看几段关键的代码。

    首先是ArrayList的类关系和成员变量

    //ArrayList继承了Serializable并且申明了serialVersionUID,表示ArrayList是一个可序列化的对象,可以用Bundle传递
    public class ArrayList<E> extends AbstractList<E>
            implements List<E>, RandomAccess, Cloneable, java.io.Serializable
    {
        private static final long serialVersionUID = 8683452581122892189L;
    
        /**
         * Default initial capacity.
         */
        private static final int DEFAULT_CAPACITY = 10;
    
        /**
         * Shared empty array instance used for empty instances.
         */
        private static final Object[] EMPTY_ELEMENTDATA = {};
    
        /**
         * The array buffer into which the elements of the ArrayList are stored.
         * The capacity of the ArrayList is the length of this array buffer. Any
         * empty ArrayList with elementData == EMPTY_ELEMENTDATA will be expanded to
         * DEFAULT_CAPACITY when the first element is added.
         */
         //从这里可以看到,ArrayList的底层是由数组实现的,并且默认数组的默认大小是10
        private transient Object[] elementData;
    
        /**
         * The size of the ArrayList (the number of elements it contains).
         *
         * @serial
         */
        private int size;
    

    然后是构造函数

    //ArrayList有2个构造函数,一个是默认无参的,一个是传入数组大小的
    //在JavaEffect书中明确提到,如果预先能知道或者估计所需数据项个数的,需要传入initialCapacity
    //因为如果使用无参的构造函数,会首先把EMPTY_ELEMENTDATA赋值给elementData
    //然后根据插入个数于当前数组size比较,不停调用Arrays.copyOf()方法,扩展数组大小
    //造成性能浪费
    /**
         * Constructs an empty list with the specified initial capacity.
         *
         * @param  initialCapacity  the initial capacity of the list
         * @throws IllegalArgumentException if the specified initial capacity
         *         is negative
         */
        public ArrayList(int initialCapacity) {
            super();
            if (initialCapacity < 0)
                throw new IllegalArgumentException("Illegal Capacity: "+
                                                   initialCapacity);
            this.elementData = new Object[initialCapacity];
        }
    
        /**
         * Constructs an empty list with an initial capacity of ten.
         */
        public ArrayList() {
            super();
            this.elementData = EMPTY_ELEMENTDATA;
        }

    然后是add()操作

    //首先看到,不过是指定index执行add操作,还是在尾部执行add操作,都会先确认当前的数组空间是否够插入数据
    //并且从
    //int oldCapacity = elementData.length;
    //int newCapacity = oldCapacity + (oldCapacity >> 1);
    //if (newCapacity - minCapacity < 0)
    //            newCapacity = minCapacity;
    //看出,ArrayList默认每次都是自增50%的大小再和minCapacity比较,如果还是不够,就把当的
    //size扩充至minCapacity
    //然后,如果是队尾插入,也简单,就把数组向后移动一位,然后赋值
    //如果是在中间插入,需要用到System.arraycopy,把index开始所有数据向后移动一位
    //再进行插入
    /**
         * Appends the specified element to the end of this list.
         *
         * @param e element to be appended to this list
         * @return <tt>true</tt> (as specified by {@link Collection#add})
         */
        public boolean add(E e) {
            ensureCapacityInternal(size + 1);  // Increments modCount!!
            elementData[size++] = e;
            return true;
        }
    
        /**
         * Inserts the specified element at the specified position in this
         * list. Shifts the element currently at that position (if any) and
         * any subsequent elements to the right (adds one to their indices).
         *
         * @param index index at which the specified element is to be inserted
         * @param element element to be inserted
         * @throws IndexOutOfBoundsException {@inheritDoc}
         */
        public void add(int index, E element) {
            rangeCheckForAdd(index);
    
            ensureCapacityInternal(size + 1);  // Increments modCount!!
            System.arraycopy(elementData, index, elementData, index + 1,
                             size - index);
            elementData[index] = element;
            size++;
        }
    
         private void ensureCapacityInternal(int minCapacity) {
                if (elementData == EMPTY_ELEMENTDATA) {
                    minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
                }
    
                ensureExplicitCapacity(minCapacity);
            }
    
            private void ensureExplicitCapacity(int minCapacity) {
                modCount++;
    
                // overflow-conscious code
                if (minCapacity - elementData.length > 0)
                    grow(minCapacity);
            }
    
         private void grow(int minCapacity) {
            // overflow-conscious code
            int oldCapacity = elementData.length;
            int newCapacity = oldCapacity + (oldCapacity >> 1);
            if (newCapacity - minCapacity < 0)
                newCapacity = minCapacity;
            if (newCapacity - MAX_ARRAY_SIZE > 0)
                newCapacity = hugeCapacity(minCapacity);
            // minCapacity is usually close to size, so this is a win:
            elementData = Arrays.copyOf(elementData, newCapacity);
        }

    然后是remove操作

    //个人感觉整个remove操作的代码写了很冗余,不像甲骨文这些大神的风格
    //首先来看remove(int index)
    //先进行边界确认,传入的index是否超过了当前数组的大小,如果是抛出异常
    //如果在数组范围内,就把index之后的数据整体向前移动一位,最后一位值清空
    //如果是remove(Object o),传入的是一个对象,就会进行一次indexOf的操作,去当前数组中寻找
    //判断是否存在,这里的代码就十分冗余了,就是把indexOf的代码拷贝了一次,完全可以调用indexOf方法
    //根据返回值是否为-1来判断该值是否存在,如果存在就调用fastRemove方法
    //fastRemove(int index)和remove(int index)方法除了边界检查一模一样
    //完全可以在remove调用完rangeCheck(index)后调用fastRemove就可以了
    //这里不是很明白设计者的意图
    /**
         * Removes the element at the specified position in this list.
         * Shifts any subsequent elements to the left (subtracts one from their
         * indices).
         *
         * @param index the index of the element to be removed
         * @return the element that was removed from the list
         * @throws IndexOutOfBoundsException {@inheritDoc}
         */
        public E remove(int index) {
            rangeCheck(index);
    
            modCount++;
            E oldValue = elementData(index);
    
            int numMoved = size - index - 1;
            if (numMoved > 0)
                System.arraycopy(elementData, index+1, elementData, index,
                                 numMoved);
            elementData[--size] = null; // clear to let GC do its work
    
            return oldValue;
        }
    
        /**
         * Removes the first occurrence of the specified element from this list,
         * if it is present.  If the list does not contain the element, it is
         * unchanged.  More formally, removes the element with the lowest index
         * <tt>i</tt> such that
         * <tt>(o==null&nbsp;?&nbsp;get(i)==null&nbsp;:&nbsp;o.equals(get(i)))</tt>
         * (if such an element exists).  Returns <tt>true</tt> if this list
         * contained the specified element (or equivalently, if this list
         * changed as a result of the call).
         *
         * @param o element to be removed from this list, if present
         * @return <tt>true</tt> if this list contained the specified element
         */
        public boolean remove(Object o) {
            if (o == null) {
                for (int index = 0; index < size; index++)
                    if (elementData[index] == null) {
                        fastRemove(index);
                        return true;
                    }
            } else {
                for (int index = 0; index < size; index++)
                    if (o.equals(elementData[index])) {
                        fastRemove(index);
                        return true;
                    }
            }
            return false;
        }
    
        /*
         * Private remove method that skips bounds checking and does not
         * return the value removed.
         */
        private void fastRemove(int index) {
            modCount++;
            int numMoved = size - index - 1;
            if (numMoved > 0)
                System.arraycopy(elementData, index+1, elementData, index,
                                 numMoved);
            elementData[--size] = null; // clear to let GC do its work
        }

    indexof

    //这里就和上面remove寻找是一模一样的,就不进行探讨了
    public int indexOf(Object o) {
            if (o == null) {
                for (int i = 0; i < size; i++)
                    if (elementData[i]==null)
                        return i;
            } else {
                for (int i = 0; i < size; i++)
                    if (o.equals(elementData[i]))
                        return i;
            }
            return -1;
        }


    3.Vector

    Vector就是ArrayList的线程安全版,它的方法前都加了synchronized锁,其他实现逻辑都相同。
    如果对线程安全要求不高的话,可以选择ArrayList,毕竟synchronized也很耗性能

    4.LinkedList

    故名思意就是链表,和我们大学在数据结构里学的链表是一会事,LinkedList还是一个双向链表。

    这里写图片描述

    LinkedList继承于AbstractSequentialList,和ArrayList一个套路。内部维护了3个成员变量,一个是当前链表的头节点,一个是尾部节点,还有是链表长度。然后我们在来看下Node这个数据结构。

    这里写图片描述

    和C语言实现方式差不多,由于是双向链表,所以记录了next和prev,只不过把C语言里的指针换成了对象。

    然后我们简单的在来看下链表额度查询,插入和删除操作

    首先是add(E e)操作

        //学过数据结构的同学看这部分代码特别轻松
        //首先来看下void linkLast(E e),尾部插入
        //就是把newNode的前面节点执行现在的尾部节点,newNode的后面节点执行null,因为是在尾部嘛
        //然后把现在的尾部节点的后面节点指向newNode,因为现在的尾部节点不是最后一个了
    
        //然后再来看下中间插入
        //也是一个套路。假设现在在3号位插入一个newNode
        //就是通过现在的3号Node的prev找到2号节点,然后修改2号节点的next,指向nowNode
        //然后nowNode的prev指向2号节点,next指向3号节点
        //最后3号节点的prev变成了nowNode,next不变
        //这样就完成了一次中间插入  
    
        /**
         * Inserts the specified element at the specified position in this list.
         * Shifts the element currently at that position (if any) and any
         * subsequent elements to the right (adds one to their indices).
         *
         * @param index index at which the specified element is to be inserted
         * @param element element to be inserted
         * @throws IndexOutOfBoundsException {@inheritDoc}
         */
        public void add(int index, E element) {
            checkPositionIndex(index);
    
            if (index == size)
                linkLast(element);
            else
                linkBefore(element, node(index));
        }
    
        /**
         * Appends the specified element to the end of this list.
         *
         * <p>This method is equivalent to {@link #addLast}.
         *
         * @param e element to be appended to this list
         * @return {@code true} (as specified by {@link Collection#add})
         */
        public boolean add(E e) {
            linkLast(e);
            return true;
        }
    
        /**
         * Links e as last element.
         */
        void linkLast(E e) {
            final Node<E> l = last;
            final Node<E> newNode = new Node<>(l, e, null);
            last = newNode;
            if (l == null)
                first = newNode;
            else
                l.next = newNode;
            size++;
            modCount++;
        }
    
        /**
         * Inserts element e before non-null Node succ.
         */
        void linkBefore(E e, Node<E> succ) {
            // assert succ != null;
            final Node<E> pred = succ.prev;
            final Node<E> newNode = new Node<>(pred, e, succ);
            succ.prev = newNode;
            if (pred == null)
                first = newNode;
            else
                pred.next = newNode;
            size++;
            modCount++;
        }

    然后是void linkLast(E e)操作

    //indexOf操作非常简单,就是从头开始遍历整个链表,如果没有就反-1,有就返回当前下标
    /**
         * Returns the index of the first occurrence of the specified element
         * in this list, or -1 if this list does not contain the element.
         * More formally, returns the lowest index {@code i} such that
         * <tt>(o==null&nbsp;?&nbsp;get(i)==null&nbsp;:&nbsp;o.equals(get(i)))</tt>,
         * or -1 if there is no such index.
         *
         * @param o element to search for
         * @return the index of the first occurrence of the specified element in
         *         this list, or -1 if this list does not contain the element
         */
        public int indexOf(Object o) {
            int index = 0;
            if (o == null) {
                for (Node<E> x = first; x != null; x = x.next) {
                    if (x.item == null)
                        return index;
                    index++;
                }
            } else {
                for (Node<E> x = first; x != null; x = x.next) {
                    if (o.equals(x.item))
                        return index;
                    index++;
                }
            }
            return -1;
        }

    虽然indexOf非常简单,但是我在这还是写了个例子,帮助大家理解下

    List list = new ArrayList();
            list.add("zero");
            list.add(null);
            list.add("two");
            list.add(null);
            list.add("three");
    
            Log.i("test", "index : " + list.indexOf(null));

    在不看答案的情况下 大家能准确的说出答案吗?

    Answer:I/test: index : 1

    从这个例子可以看出三点List的特征
    1.是按顺序查找
    2.允许存储项为空
    3.允许多个存储项的值相等

    最后看下remove操作

        //如果直接调无参的remove(),就会默认删除头节点
        //删除头节点非常简单,就是把头节点的值清空,next清空
        //然后把nextNode只为头节点,然后清空next的prev
        //最后size减1
        //如果是删除中间节点,调用remove(int index)
        //首先判断Index对应的节点是否为头节点,即index是否为0
        //如果不是中间节点,就是x的prev指向x的next
        public E remove() {
            return removeFirst();
        }
    
        public E remove(int index) {
            checkElementIndex(index);
            return unlink(node(index));
        }
    
         public E removeFirst() {
            final Node<E> f = first;
            if (f == null)
                throw new NoSuchElementException();
            return unlinkFirst(f);
        }
    
        private E unlinkLast(Node<E> l) {
            // assert l == last && l != null;
            final E element = l.item;
            final Node<E> prev = l.prev;
            l.item = null;
            l.prev = null; // help GC
            last = prev;
            if (prev == null)
                first = null;
            else
                prev.next = null;
            size--;
            modCount++;
            return element;
        }
    
        /**
         * Unlinks non-null node x.
         */
        E unlink(Node<E> x) {
            // assert x != null;
            final E element = x.item;
            final Node<E> next = x.next;
            final Node<E> prev = x.prev;
    
            if (prev == null) {
                first = next;
            } else {
                prev.next = next;
                x.prev = null;
            }
    
            if (next == null) {
                last = prev;
            } else {
                next.prev = prev;
                x.next = null;
            }
    
            x.item = null;
            size--;
            modCount++;
            return element;
        }
    
        /**
         * Unlinks non-null first node f.
         */
        private E unlinkFirst(Node<E> f) {
            // assert f == first && f != null;
            final E element = f.item;
            final Node<E> next = f.next;
            f.item = null;
            f.next = null; // help GC
            first = next;
            if (next == null)
                last = null;
            else
                next.prev = null;
            size--;
            modCount++;
            return element;
        }




    总结


    通过上面对ArrayList和LinkedList的分析,可以理解List的3个特性
    1.是按顺序查找
    2.允许存储项为空
    3.允许多个存储项的值相等
    可以知其然知其所以然

    然后对比LinkedList和ArrayList的实现方式不同,可以在不同的场景下使用不同的List
    ArrayList是由数组实现的,方便查找,返回数组下标对应的值即可,适用于多查找的场景
    LinkedList由链表实现,插入和删除方便,适用于多次数据替换的场景

    再下一章中,我们可以了解set是如何实现的,还有set又有哪些特性

    展开全文
  • Java集合框架总结

    万次阅读 多人点赞 2019-08-08 09:13:16
    集合框架:用于存储数据的容器。 集合框架是为表示和操作集合而规定的一种统一的标准的体系结构。 任何集合框架都包含三大块内容:对外的接口、接口的实现和对集合运算的算法。 接口:表示集合的抽象数据类型。接口...

    简介

    集合框架:用于存储数据的容器。

    集合框架是为表示和操作集合而规定的一种统一的标准的体系结构。
    任何集合框架都包含三大块内容:对外的接口、接口的实现和对集合运算的算法。

    接口:表示集合的抽象数据类型。接口允许我们操作集合时不必关注具体实现,从而达到“多态”。在面向对象编程语言中,接口通常用来形成规范。

    实现:集合接口的具体实现,是重用性很高的数据结构。

    算法:在一个实现了某个集合框架中的接口的对象身上完成某种有用的计算的方法,例如查找、排序等。这些算法通常是多态的,因为相同的方法可以在同一个接口被多个类实现时有不同的表现。事实上,算法是可复用的函数。
    它减少了程序设计的辛劳。

    集合框架通过提供有用的数据结构和算法使你能集中注意力于你的程序的重要部分上,而不是为了让程序能正常运转而将注意力于低层设计上。
    通过这些在无关API之间的简易的互用性,使你免除了为改编对象或转换代码以便联合这些API而去写大量的代码。 它提高了程序速度和质量。

    特点

    • 对象封装数据,对象多了也需要存储。集合用于存储对象。

    • 对象的个数确定可以使用数组,对象的个数不确定的可以用集合。因为集合是可变长度的。

    集合和数组的区别

    • 数组是固定长度的;集合可变长度的。

    • 数组可以存储基本数据类型,也可以存储引用数据类型;集合只能存储引用数据类型。

    • 数组存储的元素必须是同一个数据类型;集合存储的对象可以是不同数据类型。

    数据结构:就是容器中存储数据的方式。

    对于集合容器,有很多种。因为每一个容器的自身特点不同,其实原理在于每个容器的内部数据结构不同。

    集合容器在不断向上抽取过程中,出现了集合体系。在使用一个体系的原则:参阅顶层内容。建立底层对象。

    使用集合框架的好处

    1. 容量自增长;
    2. 提供了高性能的数据结构和算法,使编码更轻松,提高了程序速度和质量;
    3. 允许不同 API 之间的互操作,API之间可以来回传递集合;
    4. 可以方便地扩展或改写集合,提高代码复用性和可操作性。
    5. 通过使用JDK自带的集合类,可以降低代码维护和学习新API成本。

    Iterator接口

    Iterator接口,用于遍历集合元素的接口。

    在Iterator接口中定义了三个方法:

    修饰与类型 方法与描述
    boolean hasNext() 如果仍有元素可以迭代,则返回true。
    E next() 返回迭代的下一个元素。
    void remove() 从迭代器指向的 collection 中移除迭代器返回的最后一个元素(可选操作)。

    每一个集合都有自己的数据结构(就是容器中存储数据的方式),都有特定的取出自己内部元素的方式。为了便于操作所有的容器,取出元素。将容器内部的取出方式按照一个统一的规则向外提供,这个规则就是Iterator接口,使得对容器的遍历操作与其具体的底层实现相隔离,达到解耦的效果。

    也就说,只要通过该接口就可以取出Collection集合中的元素,至于每一个具体的容器依据自己的数据结构,如何实现的具体取出细节,这个不用关心,这样就降低了取出元素和具体集合的耦合性。

    使用迭代器遍历集合元素

    public static void main(String[] args) {
        List<String> list1 = new ArrayList<>();
        list1.add("abc0");
        list1.add("abc1");
        list1.add("abc2");
    
        // while循环方式遍历
        Iterator it1 = list1.iterator();
        while (it1.hasNext()) {
            System.out.println(it1.next());
        }
    
        // for循环方式遍历
        for (Iterator it2 = list1.iterator(); it2.hasNext(); ) {
            System.out.println(it2.next());
        }
    
    }
    

    使用Iterator迭代器进行删除集合元素,则不会出现并发修改异常。

    因为:在执行remove操作时,同样先执行checkForComodification(),然后会执行ArrayList的remove()方法,该方法会将modCount值加1,这里我们将expectedModCount=modCount,使之保持统一。

    ListIterator接口

    ListIterator是一个功能更加强大的迭代器, 它继承于Iterator接口,只能用于各种List类型的访问。可以通过调用listIterator()方法产生一个指向List开始处的ListIterator, 还可以调用listIterator(n)方法创建一个一开始就指向列表索引为n的元素处的ListIterator。

    特点

    1. 允许我们向前、向后两个方向遍历 List;
    2. 在遍历时修改 List 的元素;
    3. 遍历时获取迭代器当前游标所在位置。

    常用API

    修饰与类型 方法与描述
    void add(E e) 将指定的元素插入到列表 (可选操作)。
    boolean hasNext() 如果此列表迭代器在前进方向还有更多的元素时,返回 true
    boolean hasPrevious() 如果此列表迭代器在相反方向还有更多的元素时,返回 true
    E next() 返回列表中的下一个元素和光标的位置向后推进。
    int nextIndex() 返回调用 next()后返回的元素索引。
    E previous() 返回列表中的上一个元素和光标的位置向前移动。
    int previousIndex() 返回调用previous() 后返回的元素索引 。
    void remove() 删除列表中调用next()previous()的返回最后一个元素。
    void set(E e) 用指定元素替换列表中调用next()previous()的返回最后一个元素。

    Collection接口

    所有集合类都位于java.util包下。Java的集合类主要由两个接口派生而出:CollectionMap,Collection和Map是Java集合框架的根接口,这两个接口又包含了一些子接口或实现类。

    • Collection一次存一个元素,是单列集合;

    • Map一次存一对元素,是双列集合。Map存储的一对元素:键–值,键(key)与值(value)间有对应(映射)关系。

    单列集合继承关系图

    单列集合

    Collection集合主要有List和Set两大接口

    • List:有序(元素存入集合的顺序和取出的顺序一致),元素都有索引。元素可以重复。

    • Set:无序(存入和取出顺序有可能不一致),不可以存储重复元素。必须保证元素唯一性。

    List集合

    List是元素有序并且可以重复的集合。

    List的主要实现:ArrayList, LinkedList, Vector。

    List常用方法

    List常用方法

    ArrayList、LinkedList、Vector 的区别
    ArrayList LinkedList Vector
    底层实现 数组 双向链表 数组
    同步性及效率 不同步,非线程安全,效率高,支持随机访问 不同步,非线程安全,效率高 同步,线程安全,效率低
    特点 查询快,增删慢 查询慢,增删快 查询快,增删慢
    默认容量 10 / 10
    扩容机制 int newCapacity = oldCapacity + (oldCapacity >> 1);//1.5 倍 / 2 倍

    总结

    • ArrayList 和 Vector 基于数组实现,对于随机访问get和set,ArrayList优于LinkedList,因为LinkedList要移动指针。
    • LinkedList 不会出现扩容的问题,所以比较适合随机位置增、删。但是其基于链表实现,所以在定位时需要线性扫描,效率比较低。
    • 当操作是在一列数据的后面添加数据而不是在前面或中间,并且需要随机地访问其中的元素时,使用ArrayList会提供比较好的性能;
    • 当你的操作是在一列数据的前面或中间添加或删除数据,并且按照顺序访问其中的元素时,就应该使用LinkedList了。
    遍历时操作元素

    遍历集合时,同时操作集合中的元素(增删等)

    /**
      * Description: for循环遍历
      * 输出结果:
      * [a, b, c, d, e]
      * 由结果可知,第二个元素b并未删除,原因是当第一个元素b被删除后,它后面所有的元素都向前移动了一个单位,循环时导致第二个元素b漏掉了
      */
    public static void remove(List<String> list) {
        for (int i = 0; i < list.size(); i++) {
            String s = list.get(i);
            if (s.equals("b")) {
                list.remove(s);
            }
        }
    }
    
    /**
      * Description: foreach循环遍历
      *
      * 会报错:java.util.ConcurrentModificationException。这是因为在这里,foreach循环遍历容器本质上是使用迭代器进行遍历的,会对修改次数modCount进行检查,不允许集合进行更改操作
         */
    public static void remove2(List<String> list) {
        for (String s : list) {
            if (s.equals("b")) {
                list.remove(s);
            }
            System.out.println(s);
        }
    }
    
    /**
      * Description: 使用迭代器遍历
      */
    public static void remove3(List<String> list) {
        Iterator<String> it = list.iterator();
        while (it.hasNext()) {
            String s = it.next();
            if (s.equals("b")) {
                it.remove();
            }
        }
    }
    

    使用迭代器遍历删除时,能够避免方法二中出现的问题。这是因为:在ArrayList中,modCount是指集合的修改次数,当进行add或者delete时,modCount会+1;expectedModCount是指集合的迭代器的版本号,初始值是modCount,但是当集合进行add或者delete操作时,modCount会+1,而expectedModCount不会改变,所以方法二中会抛出异常。但是it.remove操作时,会同步expectedModCount的值,把modCount的值赋予expectedModCount。所以不会抛出异常。

    测试方法

    public static void main(String[] args) {
        List<String> arrayList = new ArrayList<String>();
        arrayList.add("a");
        arrayList.add("b");
        arrayList.add("b");
        arrayList.add("c");
        arrayList.add("d");
        arrayList.add("e");
        // remove(arrayList);
        // remove2(arrayList);
        remove3(arrayList);
        System.out.println(arrayList);
    
    }
    

    总结:如果想正确的循环遍历删除(增加)元素,需要使用方法三,也就是迭代器遍历删除(增加)的方法。

    Set集合

    Set集合元素无序(存入和取出的顺序不一定一致),并且没有重复对象。
    Set的主要实现类:HashSet, TreeSet。

    Set常用方法

    Set常用方法

    HashSet、TreeSet、LinkedHashSet的区别
    HashSet TreeSet LinkedHashSet
    底层实现 HashMap 红黑树 LinkedHashMap
    重复性 不允许重复 不允许重复 不允许重复
    有无序 无序 有序,支持两种排序方式,自然排序和定制排序,其中自然排序为默认的排序方式。 有序,以元素插入的顺序来维护集合的链接表
    时间复杂度 add(),remove(),contains()方法的时间复杂度是O(1) add(),remove(),contains()方法的时间复杂度是O(logn) LinkedHashSet在迭代访问Set中的全部元素时,性能比HashSet好,但是插入时性能稍微逊色于HashSet,时间复杂度是 O(1)。
    同步性 不同步,线程不安全 不同步,线程不安全 不同步,线程不安全
    null值 允许null值 不支持null值,会抛出 java.lang.NullPointerException 异常。因为TreeSet应用 compareTo() 方法于各个元素来比较他们,当比较null值时会抛出 NullPointerException异常。 允许null值
    比较 equals() compareTo() equals()
    HashSet如何检查重复

    当你把对象加入HashSet时,HashSet会先计算对象的hashcode值来判断对象加入的位置,同时也会与其他加入的对象的hashcode值作比较,如果没有相符的hashcode,HashSet会假设对象没有重复出现。但是如果发现有相同hashcode值的对象,这时会调用equals()方法来检查hashcode相等的对象是否真的相同。如果两者相同,HashSet就不会让加入操作成功。
    hashCode()与equals()的相关规定:

    • 如果两个对象相等,则hashcode一定也是相同的
    • 两个对象相等,equals方法返回true
    • 两个对象有相同的hashcode值,它们也不一定是相等的
    • 综上,equals方法被覆盖过,则hashCode方法也必须被覆盖
      hashCode()的默认行为是对堆上的对象产生独特值。如果没有重写hashCode(),则该class的两个对象无论如何都不会相等(即使这两个对象指向相同的数据)。

    总结:
    HashSet是一个通用功能的Set,而LinkedHashSet 提供元素插入顺序保证,TreeSet是一个SortedSet实现,由Comparator 或者 Comparable指定的元素顺序存储元素。

    Map接口

    Map 是一种把键对象和值对象映射的集合,它的每一个元素都包含一对键对象和值对象。 Map没有继承于Collection接口,从Map集合中检索元素时,只要给出键对象,就会返回对应的值对象。
    Map 的常用实现类:HashMap、TreeMap、HashTable、LinkedHashMap、ConcurrentHashMap

    双列集合继承关系图

    双列集合

    Map常用方法

    Map常用方法

    HashMap、HashTable、TreeMap的区别

    • TreeMap:基于红黑树实现。
    • HashMap:基于哈希表实现。
    • HashTable:和 HashMap 类似,但它是线程安全的,这意味着同一时刻多个线程可以同时写入 HashTable 并且不会导致数据不一致。它是遗留类,不应该去使用它。现在可以使用 ConcurrentHashMap 来支持线程安全,并且 ConcurrentHashMap 的效率会更高,因为 ConcurrentHashMap 引入了分段锁。
    • LinkedHashMap:使用双向链表来维护元素的顺序,顺序为插入顺序或者最近最少使用(LRU)顺序。
    HashMap HashTable TreeMap
    底层实现 哈希表(数组+链表) 哈希表(数组+链表) 红黑树
    同步性 线程不同步 同步 线程不同步
    null值 允许 key 和 Vale 是 null,但是只允许一个 key 为 null,且这个元素存放在哈希表 0 角标位置 不允许key、value 是 null value允许为null。
    当未实现 Comparator 接口时,key 不可以为null
    当实现 Comparator 接口时,若未对 null 情况进行判断,则可能抛 NullPointerException 异常。如果针对null情况实现了,可以存入,但是却不能正常使用get()访问,只能通过遍历去访问。
    hash 使用hash(Object key)扰动函数对 key 的 hashCode 进行扰动后作为 hash 值 直接使用 key 的 hashCode() 返回值作为 hash 值
    容量 容量为 2^4 且容量一定是 2^n 默认容量是11,不一定是 2^n
    扩容 两倍,且哈希桶的下标使用 &运算代替了取模 2倍+1,取哈希桶下标是直接用模运算

    HashMap在JDK1.7和JDK1.8中有哪些不同

    不同 JDK 1.7 JDK 1.8
    存储结构 数组 + 链表 数组 + 链表 + 红黑树
    初始化方式 单独函数:inflateTable() 直接集成到了扩容函数resize()
    hash值计算方式 扰动处理 = 9次扰动 = 4次位运算 + 5次异或运算 扰动处理 = 2次扰动 = 1次位运算 + 1次异或运算
    存放数据的规则 无冲突时,存放数组;冲突时,存放链表 无冲突时,存放数组;冲突 & 链表长度 < 8:存放单链表;冲突 & 链表长度 > 8:树化并存放红黑树
    插入数据方式 头插法(先讲原位置的数据移到后1位,再插入数据到该位置) 尾插法(直接插入到链表尾部/红黑树)
    扩容后存储位置的计算方式 全部按照原来方法进行计算(即hashCode ->> 扰动函数 ->> (h&length-1)) 按照扩容后的规律计算(即扩容后的位置=原位置 or 原位置 + 旧容量)

    集合工具类Collections

    Collections:集合工具类,方便对集合的操作。这个类不需要创建对象,内部提供的都是静态方法。

    静态方法:

    Collections.sort(list);//list集合进行元素的自然顺序排序。
    Collections.sort(list,new ComparatorByLen());//按指定的比较器方法排序。
    class ComparatorByLen implements Comparator<String>{
      public int compare(String s1,String s2){
         int temp = s1.length()-s2.length();
         return temp==0?s1.compareTo(s2):temp;
      }
    }
    Collections.max(list);//返回list中字典顺序最大的元素。
    int index = Collections.binarySearch(list,"zz");//二分查找,返回角标。
    Collections.reverseOrder();//逆向反转排序。
    Collections.shuffle(list);//随机对list中的元素进行位置的置换。
    
    //将非同步集合转成同步集合的方法:Collections中的  XXX synchronizedXXX(XXX);  
    //原理:定义一个类,将集合所有的方法加同一把锁后返回。
    List synchronizedList(list);
    Map synchronizedMap(map);
    

    Collection 和 Collections的区别

      Collections是个java.util下的类,是针对集合类的一个工具类,提供一系列静态方法,实现对集合的查找、排序、替换、线程安全化(将非同步的集合转换成同步的)等操作。
    
      Collection是个java.util下的接口,它是各种集合结构的父接口,继承于它的接口主要有Set和List,提供了关于集合的一些操作,如插入、删除、判断一个元素是否其成员、遍历等。
    

    数组工具类 Arrays

    用于操作数组对象的工具类,里面都是静态方法。

    数组 -> 集合:asList方法,将数组转换成list集合。

    String[] arr ={"abc","kk","qq"};
    List<String> list =Arrays.asList(arr);//将arr数组转成list集合。
    

    将数组转换成集合,有什么好处呢?用aslist方法,将数组变成集合;

    可以通过list集合中的方法来操作数组中的元素:isEmpty()、contains、indexOf、set;
    
    注意(局限性):数组是固定长度,不可以使用集合对象增加或者删除等,会改变数组长度的功能方法。比如add、remove、clear。(会报不支持操作异常UnsupportedOperationException);
    
    如果数组中存储的引用数据类型,直接作为集合的元素可以直接用集合方法操作。
    
    如果数组中存储的是基本数据类型,asList会将数组实体作为集合元素存在。
    

    集合 -> 数组:用的是Collection接口中的toArray()方法;

    如果给toArray传递的指定类型的数据长度小于了集合的size,那么toArray方法,会自定再创建一个该类型的数据,长度为集合的size。
    
    如果传递的指定的类型的数组的长度大于了集合的size,那么toArray方法,就不会创建新数组,直接使用该数组即可,并将集合中的元素存储到数组中,其他为存储元素的位置默认值null。
    
    所以,在传递指定类型数组时,最好的方式就是指定的长度和size相等的数组。
    

    将集合变成数组后有什么好处?限定了对集合中的元素进行增删操作,只要获取这些元素即可。

    用基本数据类型的数组转换ArrayList,ArrayList的size有问题

    public static void main(String[] args) {
        int[] arr1 = { 1, 2, 3, 4, 5 };
        List<int[]> intList = Arrays.asList(arr1);
        // intList size: 1
        System.out.println(String.format("intList size: %s", intList.size()));
    
        Integer[] arr2 = { 1, 2, 3, 4, 5 };
        List<Integer> integerList = Arrays.asList(arr2);
        // integerList size: 5
        System.out.println(String.format("integerList size:%s", integerList.size()));
    }
    

    asList方法接受的参数是一个泛型的变长参数,我们知道基本数据类型是无法泛型化的,也就是说基本类型是无法作为asList方法的参数的, 要想作为泛型参数就必须使用其所对应的包装类型。但是这个这个实例中为什么没有出错呢?因为该实例是将int 类型的数组当做其参数,而在Java中数组是一个对象,它是可以泛型化的。所以该例子是不会产生错误的。既然例子是将整个int 类型的数组当做泛型参数,那么经过asList转换就只有一个int 的列表了.

    结论:

    在使用asList()时尽量不要将基本数据类型数组转List.

    asList转换得到的ArrayList不是java.util.ArrayList

    public static void main(String[] args) {
        String[] arr = {"abc", "kk", "qq"};
        List<String> list = Arrays.asList(arr);
        // 添加一个元素,抛出异常UnsupportedOperationException
        list.add("bb");
    }
    

    原因:

    此处ArrayList是Arrays的内部类,并没有add方法,add方法是父类AbstractList的,但是没有具体实现,
    而是直接抛出UnsupportedOperationException异常.

    Arrays内部类ArrayList

    正确操作

    public static void main(String[] args) {
        String[] arr = {"abc", "kk", "qq"};
    	// 使用new ArrayList包裹一层
        List<String> list = new ArrayList<>(Arrays.asList(arr));
        list.add("bb");
    }
    

    如何选用集合?

    主要根据集合的特点来选用,比如我们需要根据键值获取到元素值时就选用Map接口下的集合,需要排序时选择TreeMap,不需要排序时就选择HashMap,需要保证线程安全就选用ConcurrentHashMap.当我们只需要存放元素值时,就选择实现Collection接口的集合,需要保证元素唯一时选择实现Set接口的集合比如TreeSet或HashSet,不需要就选择实现List接口的比如ArrayList或LinkedList,然后再根据实现这些接口的集合的特点来选用。

    展开全文
  •  假设有集合 A 和 B 分别用两个线性表 LA 和 LB 表示,即线性表中的数据元素即为集合中的成员。设计算法,函数unionList(List LA, List LB, List &LC )函数实现该算法,求一个新的集合C=A∪B,即将集合的...

      本文点评一位学生对基于线性表存储集合,然后对集合进行求并运算的错解,供学习者参考。

    【项目 - 求集合并集】
      假设有两个集合 A 和 B 分别用两个线性表 LA 和 LB 表示,即线性表中的数据元素即为集合中的成员。设计算法,用函数unionList(List LA, List LB, List &LC )函数实现该算法,求一个新的集合C=A∪B,即将两个集合的并集放在线性表LC中。

    提示:
    (1)除了实现unnionList函数外,还需要在main函数中设计代码,调用unionList进行测试和演示;
    (2)可以充分利用前面建好的算法库[点击…],在程序头部直接加 #include<list.h>即可(工程中最普遍的方法,建议采纳);
    (3)也可以将实现算法中需要的线性表的基本运算对应的函数,与自己设计的所有程序放在同一个文件中。

    点这儿…】可以看课程中提供参考解答。

    【错解】

    #include <stdio.h>
    #include "list.h"
    
    void unionList(SqList *LA, SqList *LB, SqList *&LC)
    {
        int e;
        int lena=LA->length;
        LC = LA;
        for (int i = 0; i <LA->length; i++)
        {
            if (LA->data[i] != LB->data[i])
            {
                ListInsert(LC, lena++, LB->data[i]);
            }
        }
        DispList(LC);
    }
    
    int main()
    {
        SqList *la, *lb, *lc;
        ElemType x[2] = {1,2};
        ElemType y[2] = {1,4,3}; //原文中只有{1,4},为更好地反映问题,我增加1个元素3
        ElemType z[4];
        CreateList(la, x, 2);
        CreateList(lb, y, 3);
        CreateList(lc, z, 4);
        unionList(la, lb, lc);
        return 0;
    }

    【我的点评】
      阅读代码知道,第8行LC=LA,意即从此LC指向的也就是LA指向的线性表了。对照题目要求,合并后的LC应该是一个新的线性表,此处处理不合要求。
      若不考虑这一要求,LC=LA后,合并的结果就保存在LA(也是LC)中了。在内存访问的机制中,这是合法的。(这儿和内存管理中的什么堆区、栈区之类的没有关系。内存管理机制对于计算机类的学生很重要,但一般入门级阶段并不讲。)合法仅是在合乎语法要求的层面,事实上,LC原先指向的空间从此没有由任何变量指向,也没有被释放,成了“游离”的垃圾。  
      接下来的讨论,我们就以合并后的结果保存到LA中为起点。
      第9-15行的处理,可以看出学生在算法设计时没有理清头绪。LA(LC)中已经是并集中的第一部分元素了,接下来,应该是“将LB中有,但LA没有的元素,加到LC中”(严格讲,“LB中的元素”指LB指针指向的线性表代表的集合中的元素,LA、LC同),代码没有体现出这层意思。为了完成这一任务,要考察LB中的每个元素,最外层的循环,应该针对的是LB,而不是LA。
      故算法框架应该是:

        for (i = 0; i <LB->length; i++)
        {
            //若LB集合中的第i个元素不在原LA集合中,则将LB中的第i个元素加入到LC中
        }

      如何知道“LB集合中的第i个元素不在原LA集合中”?这需要和LA集合中的元素逐个比较的!于是这里需要针对“原LA集合”构造一个循环,以便逐个比较。显然,11-14行的一个分支结构,仅完成“LA和LB相同序号的元素是否相等”,是不足以考察LA中的每一个元素的。于是上面是算法框架拓展为:

        for (i = 0; i <LB->length; i++)
        {
            for (j = 0; j <lena; j++)  
                //若LB->data[i] == LA->data[j]退出循环
            //循环中未出现相等的情形,则说明LB->data[i]未在LA中出现过,要将LB->data[i]加入
    
        }

      于是,尽可能在原错误程序基础上修改,且合并后的结果LC实际就是LA的情况下,得到的完整代码为:

    #include <stdio.h>
    #include "list.h"
    
    void unionList(SqList *LA, SqList *LB, SqList *&LC)
    {
        int i,j;
        int lena,lenc;
        lena=lenc=LA->length; //lena是原LA长度,lenc代表合并后的长度
        LC = LA;  //LC和LA将指同一个集合
        for (i = 0; i < LB->length; i++)
        {
            for (j = 0; j <lena; j++)
                if(LB->data[i] == LA->data[j])
                    break;
            if(j>=lena)  //退出前面的循环是因为全找过了找不着,即在原LA中不存在
            {
                ListInsert(LC, ++lenc, LB->data[i]);
            }
        }
    }
    
    int main()
    {
        SqList *la, *lb, *lc;
        ElemType x[2] = {1,2};
        ElemType y[3] = {1,4,3}; //原文中只有{1,4},为更好地反映问题,我增加1个元素3
        //ElemType z[4];
        CreateList(la, x, 2);
        CreateList(lb, y, 3);
        //CreateList(lc, z, 4);
        unionList(la, lb, lc);
        DispList(lc);
        return 0;
    }

      需要强调的是,for (j = 0; j <lena; j++)中的lena是“原LA”的长度,不能用LA->length代替,因为在LA、LC混用的情况下,LA->length随着插入,是动态变化着的。
      在原参考解答中,“插入LB中每一个元素”只用了一重循环,但要知道,实现if (!LocateElem(LA,e))的内部,“藏”对LA指向的每一个元素的扫描,是内含一层循环的,到算法库[点击…]中考察基本操作的实现可以验证这一说法。这种写法看起来更简单,也道出了我们应该用基本运算为单位进行思考的必要性。这是在学习数据结构中,应该养成的习惯。这是工程中用到的思维,代码写得出,还要写得好。
      在上面的解答中,我将DispList(LC);放到main函数中了。unionList只管合并,不管别的任何事情。这是软件工程中“高内聚”的要求——一个模块尽可能只完成单一的工作。“显示结果”是“求并”以后做的工作,两者是“平级”的,不要将显示作为合并的一部分。
      还有,新代码中的27和30(在原代码中也有)没有必要,这样创建了线性表,却在合并时直接将LC和LA共用空间了,何必呢,反倒使一块空间彻底成了垃圾。
      在初学者的学习中,一定要争取自己写出来。可以参考一切可以用到的资料启发自己,给出自己的解答。写出这样的错解,也是好的成果,中间的思考、尝试过程是我们真正要的东西。这个过程价值连城。当自己已经经过一定的思考之后,再看一些相对规范的解法(例如本文中的参考解答),也是很必要的。观摩、阅读是学习方法。如果能在观摩中品到其味道,再去仿制一份,也便极好。

    展开全文
  • java集合详解和集合面试题目

    万次阅读 多人点赞 2018-02-12 11:01:14
    一、集合与数组 数组(可以存储基本数据类型)是用来存现对象的一种容器,但是数组的长度固定,不适合在对象数量未知的情况下使用。 集合(只能存储对象,对象类型可以不一样)的长度可变,可在多数情况下使用。 ...
  • 【1】基本概念: 隶属函数、模糊集合的表示方法、模糊关系、模糊矩阵 【2】模糊模式识别:海明贴近度 、欧几里得贴近度 、黎曼贴近度、 格贴近度、最大隶属原则、择近原则 【3】模糊聚类分析方法:模糊等价矩阵、...
  • Java-Collection集合和Map集合总结

    千次阅读 2018-05-27 14:43:11
    那么这些集合(容器)都是干什么用的呢?他们各自又有什么特性呢? 三、集合基本概念 首先在搞清楚常用集合之前,先说说有关集合的基本概念。 前面我们说到,在程序运行过程中,对于不确定数量、不确定类型...
  • java常用集合集合讲解

    万次阅读 2018-07-04 13:32:59
    一、java集合系列 java的集合主要分为List列表、Set集合、Map映射、工具类(Iterator迭代器、Enumeration枚举类、Arrays和Collections )java中集合类的关系图 由此图可以看到,主要分为Collection和Map大类: 1....
  • Set、Map、List三种集合的差别

    万次阅读 多人点赞 2019-05-30 16:15:27
    1.集合类型主要有3种:set(集)、list(列表)和map(映射)。 2.三者关系 3.Set set接口时Collection接口的一个子接口,是无序的,set中不包含重复的元素,也就是说set中不存在个这样的元素a1.equals(a2)结果为...
  • 2. LinkedList的继承关系 LinkedList API java.lang.Object java.util.AbstractCollection< E > java.util.AbstractList< E > java.util.AbstractSequentialList< E > java.util.LinkedList< E >...
  • 集合框架 1.1 集合框架概述 1.1.1 容器简介 到目前为止,我们已经学习了如何创建多个不同的对象,定义了这些对象以后,我们就可以利用它们来做一些有意义的事情。  举例来说,假设要存储许多雇员,不同的...
  • java常用集合集合框架总结

    千次阅读 2018-06-04 23:33:27
    今天这篇文章我们重点总结一下java中常用的集合,及他们的特性和适用的场合。常见集合框架结构如下图(不是全部,只包含常用的) 1、List 1.1、ArrayList1.2、LinkedList1.3、Vector1.4、List接口下各种接口实现...
  • Java笔试面试-集合详解(上)

    万次阅读 多人点赞 2019-09-16 12:02:58
    集合的继承关系图,如下: 其中: 外框为虚线的表示接口,边框为实线的表示类; 箭头为虚线的表示实现了接口,箭头为实线的表示继承了类。 集合的根节点是 Collection,而 Collection 下又提供了大常用集合,...
  • Java集合面试总结

    万次阅读 多人点赞 2017-10-28 22:01:38
    可以用集合。因为集合是可变长度的。 集合和数组的区别: 1:数组是固定长度的;集合可变长度的。 2:数组可以存储基本数据类型,也可以存储引用数据类型;集合只能存储引用数据类型。 3:数组存储的元素必须...
  • Scala集合

    千次阅读 2016-01-12 19:35:37
    很多集合的处理和转换可以被表达的简洁又可读,但不审慎地它们的功能也会导致相反的结果。每个Scala程序员应该阅读 集合设计文档;通过它可以很好地洞察集合库,并了解设计动机。 scala集合API:...
  • 查找集合个最大的元素

    千次阅读 2011-12-15 15:57:28
    查找集合个最大的元素 启示:我们应该仔细检查证明过程中是否确实用到了所有的假设;应该设法更少的假设完成同样的证明;另外,除非有反例说明已经到达所有可能的证明的边界,否则我们应该永不满足。 ———...
  • Java集合框架(上)

    千次阅读 2016-06-29 10:30:56
    Java中集合类的概念:是一种工具类,就像是容器,储存任意...有的集合接口,提供了映射的关系,可以通过关键字(key)快速查找到对应的唯一对象,而这个关键字可以是任意类型。 为什么选择集合,而不是数组? 数组的长
  • 本文介绍了Java集合类的基本框架,接口结构以及部分源码分析,并且通过自己实现一些集合类来更好地剖析Java集合类的整体结构。 本文只是对集合类框架进行一个大概的梳理,毕竟集合框架中包含的类太多了,一篇文章不...
  • java集合详解

    千次阅读 2020-05-01 21:19:29
    1.java集合什么? java集合实际上是一种经常被运用到的java类库,其中提供了已经实现的的数据结构,省去了程序员再次编写数据结构的事情.在Leetcode中经常会被用到,有很重要的作用. 集合体系 我们发现,无论是Set...
  • python数据类型 集合set(无序)

    千次阅读 2018-05-06 20:46:39
    集合: set 集合是可变的容器 集合内的数据对象都是唯一的(不能重复多次的) 集合是无序的存储结构,集合中的数据没有先后顺序关系 集合内的元素必须是不可变对象 集合是可迭代对象 集合是相当于只有键没有值的...
  • 集合的概念:  集合是包含多个对象的简单对象,所包含的对象称为元素。集合里面可以包含任意多个对象,数量可以变化;同时对对象的类型也没有限制,也就是说集合里面的所有对象的类型可以相同,也可以不同。 ...
  • java集合框架08——HashMap和源码分析

    千次阅读 多人点赞 2016-04-15 23:40:56
    相反如果机器内存紧张,并且对查询速度没什么要求的话可以将加载因子设置大一点。一般我们都使用它的默认值, 即0.75 。 3.2构造方法  下面看看HashMap的几个构造方法: /**********************...
  • 相比之下,关系型数据库中也同样有这些操作,但是在Java 8之前,集合和数组的处理并不是很便捷。 不过,这一问题在Java 8中得到了改善,Java 8 API添加了一个新的抽象称为流Stream,可以让你以一种声明的方式处理...
  • 单链表来实现结合的基本运算,首先的是单链表所以我们就先给它创建一个头结点并且为它分配空间,而结点的结构体中定义了个属性 data域和next指针域。 ②实现集合元素的插入。我的是单链表头插法的方法,...
  • Java集合框架完全解析

    千次阅读 多人点赞 2017-05-23 12:57:43
    1、集合概述 现实生活中集合:很多事物凑在一起。  数学中的集合:具有共同属性的事物的总体。  Java中的集合类:是一种工具类,就像是容器,储存任意数量的具有共同属性的对象。在编程时,常常需要集中存放多个...
  • Java集合排序及java集合类详解

    万次阅读 2012-08-20 14:21:53
    Java集合排序及java集合类...能够集合和理解好集合对于做Java程序的开发拥有无比的好处。本文详细解释了关于Java中的集合是如何实现的,以及他们的实现原理。   目录 1 集合框架.............................
  • 集合论与图论

    千次阅读 多人点赞 2020-06-23 10:21:20
    文章目录一、集合及其运算1.1 集合概念1.2 子集、集合相等定义1.2.1 集合的包含.定义1.2.2 集合的真子集.定义1.2.3 集合的相等.定理1.2.1 空集定义1.2.4 集族.定义1.2.5 幂集.1.3 集合的基本运算定义1.3.1 并集定理...
  • Java集合——ArrayList源码详解

    万次阅读 2016-10-20 21:17:59
    默认的序列化机制,那采用什么呢?直接翻到源码的最下边有个方法,发现 ArrayList 自己实现了序列化和反序列化的方法。 /** * Save the state of the <tt>ArrayList</tt> instance to a stream (that is,serialize...
  • 学习笔记:C#常用容器(集合

    千次阅读 2019-04-09 09:36:50
    相信大家一开始学习的时候接触到的集合就是数组了,他也是最简单的集合。 String[] array = new String[3]; array[0] = "张三"; array[1] = "1"; array[2] = "游泳"; for(int i = 0; i < array.Length; i++)...
  • java8之stream:处理集合数据

    万次阅读 2017-04-18 08:27:41
    Streams lambda表达式允许我们在不创建新类的情况下传递行为,从而帮助我们写出干净简洁的代码。...Stream使用一种类似SQL语句从数据库查询数据的直观方式来提供一种对Java集合运算和表达的高...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 101,676
精华内容 40,670
关键字:

两集合中间用i是什么关系