精华内容
下载资源
问答
  • java中Vector

    2013-07-17 22:26:12
    JAVA中 Java.util.Vector提供了向量(Vector)类以实现类似动态数组的功能。在Java语言中是没有指针概念的,但如果能正确灵活地使用指针又确实可以大大提高程序的质量,比如在C、C++中所谓“动态数组”一般都由...

    http://baike.baidu.com/view/184178.htm#refIndex_1_184178


    在JAVA中

    Java.util.Vector提供了向量(Vector)类以实现类似动态数组的功能。在Java语言中是没有指针概念的,但如果能正确灵活地使用指针又确实可以大大提高程序的质量,比如在C、C++中所谓“动态数组”一般都由指针来实现。为了弥补这点缺陷,Java提供了丰富的类库来方便编程者使用,Vector类便是其中之一。事实上,灵活使用数组也可完成向量类的功能,但向量类中提供的大量方法大大方便了用户的使用。
    相对于ArrayList来说,Vector线程是安全的,也就是说是同步的
    创建了一个向量类的对象后,可以往其中随意地插入不同的类的对象,既不需顾及类型也不需预先选定向量的容量,并可方便地进行查找。对于预先不知或不愿预先定义数组大小,并需频繁进行查找、插入和删除工作的情况,可以考虑使用向量类。向量类提供了三种构造方法
    public vector()
    public vector(int initialcapacity,int capacityIncrement)
    public vector(int initialcapacity)
    使用第一种方法,系统会自动对向量对象进行管理。若使用后两种方法,则系统将根据参数initialcapacity设定向量对象的容量(即向量对象可存储数据的大小),当真正存放的数据个数超过容量时,系统会扩充向量对象的存储容量。
    参数capacityIncrement给定了每次扩充的扩充值。当capacityIncrement为0时,则每次扩充一倍。利用这个功能可以优化存储。在Vector类中提供了各种方法方便用户使用:

    插入功能

    (1)public final synchronized void addElement(Object obj)
    将obj插入向量的尾部。obj可以是任何类的对象。对同一个向量对象,可在其中插入不同类的对象。但插入的应是对象而不是数值,所以插入数值时要注意将数值转换成相应的对象。
    例 要插入一个整数1时,不要直接调用v1.addElement(1),正确的方法为:
    Vector v1=new Vector();
    Integer integer1=new Integer(1);
    v1.addElement(integer1);
    (2)public final synchronized void setElementAt(object obj,int index)
    将index处的对象设成obj,原来的对象将被覆盖。
    (3)public final synchronized void insertElementAt(Object obj,int index)
    在index指定的位置插入obj,原来对象以及此后的对象依次往后顺延。

    删除功能

    (1)public final synchronized void removeElement(Object obj)
    从向量中删除obj。若有多个存在,则从向量头开始试,删除找到的第一个与obj相同的向量成员。
    (2)public final synchronized void removeAllElement()
    删除向量中所有的对象。
    (3)public final synchronized void removeElementlAt(int index)
    删除index所指的地方的对象。

    查询搜索功能

    (1)public final int indexOf(Object obj)
    从向量头开始搜索obj,返回所遇到的第一个obj对应的下标,若不存在此obj,返回-1。
    (2)public final synchronized int indexOf(Object obj,int index)
    从index所表示的下标处开始搜索obj。
    (3)public final int lastIndexOf(Object obj)
    从向量尾部开始逆向搜索obj。
    (4)public final synchronized int lastIndexOf(Object obj,int index)
    从index所表示的下标处由尾至头逆向搜索obj。
    (5)public final synchronized Object firstElement()
    获取向量对象中的首个obj。
    (6)public final synchronized Object lastelement()
    获取向量对象中的最后一个obj。

    实例

    了解了向量的最基本的方法后,我们来看一下例子VectorApp.java。
    例 VectorApp.java
    import java.util.Vector;
    import java.lang.*;
    //这一句不应该要,但原文如此
    import java.util.Enumeration;
    public class VectorApp
    {
    public static void main(String[] args)
    {
    Vector<Integer> v1=new Vector<Integer>(); //jdk1.5以后增加了对[1]的支持![1]
    Integer integer1=new Integer(1);
    v1.addElement("one");
    //加入的为字符串对象
    v1.addElement(integer1);
    v1.addElement(integer1);
    //加入的为Integer的对象
    v1.addElement("two");
    v1.addElement(new Integer(2));
    v1.addElement(integer1);
    v1.addElement(integer1);
    System.out.println("The vector v1 is:\n\t"+v1);
    //将v1转换成字符串并打印
    v1.insertElementAt("three",2);
    v1.insertElementAt(new Float(3.9),3);
    System.out.println("The vector v1(used method insertElementAt())is:\n\t "+v1);
    //往指定位置插入新的对象,
    指定位置后的对象依次往后顺延
    v1.setElementAt("four",2);
    System.out.println("The vector v1(used method setElementAt())is:\n\t "+v1);
    //将指定位置的对象设置为新的对象
    v1.removeElement(integer1);
    //从向量对象v1中删除对象integer1由于
    存在多个integer1所以从头开始
    找,删除找到的第一个integer1
    Enumeration enum=v1.elements();
    System.out.print("The vector v1(used method removeElement())is:");
    while(enum.hasMoreElements())
    System.out.print(enum.nextElement()+" ");
    System.out.println();
    //使用枚举类(Enumeration)
    的方法来获取向量对象的每个元素
    System.out.println("The position of object 1(top-to-bottom):"
    + v1.indexOf(integer1));
    System.out.println("The position of object 1(tottom-to-top):"
    +v1.lastIndexOf(integer1));
    //按不同的方向查找对象integer1所处的位置
    v1.setSize(4);
    System.out.println("The new vector(resized the vector)is:"+v1);
    //重新设置v1的大小,多余的元素被行弃
    }
    }
    运行结果:
    E:\java01>java VectorApp
    The vector v1 is:
    [one,1,1,two,2,1,1]
    The vector v1(used method insertElementAt())is:
    [one,1,three,3.9,1,two,2,1,1]
    The vector v1(used method setElementAt()) is:
    [one,1,four,3.9,1,two,2,1,1]
    The vector v1(used method removeElement())is:
    one four 3.9 1 two 2 1 1
    The position of object 1(top-to-bottom):3
    The position of object 1(tottom-to-top):7
    The new vector(resized the vector)is:
    [one,four,3.9,1]
    E:\java01>
    从例1中运行的结果中可以清楚地了解上面各种方法的作用,另外还有几点需解释。
    (1)类Vector定义了方法
    public final int size()
    此方法用于获取向量元素的个数。它的返回值是向是中实际存在的元素个数,而非向量容量。可以调用方法capactly()来获取容量值。
    方法:
    public final synchronized void setsize(int newsize)
    此方法用来定义向量大小。若向量对象现有成员个数已超过了newsize的值,则超过部分的多余元素会丢失。
    (2)程序中定义了Enumeration类的一个对象
    Enumeration是java.util中的一个接口类,在Enumeration中封装了有关枚举数据集合的方法。
    在Enumeration中提供了方法hawMoreElement()来判断集合中是否还有其它元素和方法nextElement()来获取下一个元素。利用这两个方法可以依次获得集合中元素。
    Vector中提供方法:
    public final synchronized Enumeration elements()
    此方法将向量对象对应到一个枚举类型。java.util包中的其它类中也大都有这类方法,以便于用户获取对应的枚举类型。

    展开全文
  • java中vector和list的区别发布时间:2020-06-19 17:07:11来源:亿速云阅读:106作者:元一vector的概念Vector类 是在 java 中可以实现自动增长的对象数组,vector在C++标准模板库中的部分内容,它是一个多功能的,...

    java中vector和list的区别

    发布时间:2020-06-19 17:07:11

    来源:亿速云

    阅读:106

    作者:元一

    vector的概念

    Vector类 是在 java 中可以实现自动增长的对象数组,vector在C++标准模板库中的部分内容,它是一个多功能的,能够操作多种数据结构和算法的模板类和函数库。

    vector的使用

    连续存储结构:vector是可以实现动态增长的对象数组,支持对数组高效率的访问和在数组尾端的删除和插入操作,在中间和头部删除和插入相对不易,需要挪动大量的数据。

    它与数组最大的区别就是vector不需程序员自己去考虑容量问题,库里面本身已经实现了容量的动态增长,而数组需要程序员手动写入扩容函数进形扩容。

    Vector的模拟实现template

    class Vector

    {

    public:

    typedef T* Iterator;

    typedef const T* Iterator;

    Vector()

    :_start(NULL)

    ,_finish(NULL)

    ,_endOfStorage(NULL)

    {}

    void template

    PushBack(const T& x)

    {

    Iterator end = End();

    Insert(end, x);

    }

    void Insert(Iterator& pos, const T& x)

    {

    size_t n = pos - _start;

    if (_finish == _endOfStorage)

    {

    size_t len = Capacity() == 0 ? 3 : Capacity()*2;

    Expand(len);

    }

    pos = _start+n;

    for (Iterator end = End(); end != pos; --end)

    {

    *end = *(end-1);

    }

    *pos = x;

    ++_finish;

    }

    Iterator End()

    {

    return _finish;

    }

    Iterator Begin()

    {

    return _start;

    }

    void Resize(size_t n, const T& val = T())//用Resize扩容时需要初始化空间,并且可以缩小容量

    {

    if (n < Size())

    {

    _finish = _start+n;

    }

    else

    {

    Reserve(n);

    size_t len = n-Size();

    for (size_t i = 0; i < len; ++i)

    {

    PushBack(val);

    }

    }

    }

    void Reserve(size_t n)//不用初始化空间,直接增容

    {

    Expand(n);

    }

    inline size_t Size()

    {

    return _finish-_start;

    }

    inline size_t Capacity()

    {

    return _endOfStorage-_start;

    }

    void Expand(size_t n)

    {

    const size_t size = Size();

    const size_t capacity = Capacity();

    if (n > capacity)

    {

    T* tmp = new T[n];

    for (size_t i = 0; i < size; ++i)

    {

    tmp[i] = _start[i];

    }

    delete[] _start;

    _start = tmp;

    _finish = _start+size;

    _endOfStorage = _start+n;

    }

    }

    T& operator[](size_t pos)

    {

    assert(pos < Size());

    return _start[pos];

    }

    const T& operator[](size_t pos) const

    {

    assert(pos < Size());

    return _start[pos];

    }

    protected:

    Iterator _start; //指向第一个元素所在节点

    Iterator _finish; //指向最后一个元素所在节点的下一个节点

    Iterator _endOfStorage; //可用内存空间的末尾节点

    };

    list的概念

    在编程语言中List 是类库中的一个类,可以简单视之为双向连结串行,以线性列的方式管理物件集合。list 的特色是在集合的任何位置增加或删除元素都很快,但是不支持随机存取。list 是类库提供的众多容器(container)之一,除此之外还有vector、set、map、…等等。list 以模板方式实现(即泛型),可以处理任意型别的变量,包括使用者自定义的资料型态

    list的使用

    非连续存储结构:list是一个双链表结构,支持对链表的双向遍历。每个节点包括三个信息:元素本身,指向前一个元素的节点(prev)和指向下一个元素的节点(next)。

    因此list可以高效率的对数据元素任意位置进行访问和插入删除等操作。由于涉及对额外指针的维护,所以开销比较大。

    List的模拟实现template

    class List

    {

    typedef __ListNode Node;

    public:

    typedef __ListIterator Iterator;

    typedef __ListIterator ConstIterator;

    Iterator Begin()

    {

    return _head->_next;

    }

    Iterator End()

    {

    return _head;

    }

    ConstIterator Begin() const

    {

    return _head->_next;

    }

    ConstIterator End() const

    {

    return _head;

    }

    List()

    {

    _head = new Node(T());

    _head->_next = _head;

    _head->_prev = _head;

    }

    // l2(l1)

    List(const List& l)

    {

    _head = new Node(T());

    _head->_next = _head;

    _head->_prev = _head;

    ConstIterator it = l.Begin();

    while (it != l.End())

    {

    PushBack(*it);

    ++it;

    }

    }

    ~List()

    {

    Clear();

    delete _head;

    _head = NULL;

    }

    void Clear()

    {

    Iterator it = Begin();

    while (it != End())

    {

    Node* del = it._node;

    ++it;

    delete del;

    }

    _head->_next = _head;

    _head->_prev = _head;

    }

    void PushBack(const T& x)

    {

    Insert(End(), x);

    }

    void PushFront(const T& x)

    {

    Insert(Begin(), x);

    }

    void PopBack()

    {

    Erase(--End());

    }

    void PopFront()

    {

    Erase(Begin());

    }

    void Insert(Iterator pos, const T& x)

    {

    Node* cur = pos._node;

    Node* prev = cur->_prev;

    Node* tmp = new Node(x);

    prev->_next = tmp;

    tmp->_prev = prev;

    tmp->_next = cur;

    cur->_prev = prev;

    }

    Iterator Erase(Iterator& pos)

    {

    assert(pos != End());

    Node* prev = (pos._node)->_prev;

    Node* next = (pos._node)->_next;

    prev->_next = next;

    next->_prev = prev;

    delete pos._node;

    pos._node = prev;

    return Iterator(next);

    }

    protected:

    Node* _head;

    };

    vector 和list的区别

    *vector的随机访问效率高,但在插入和删除时(不包括尾部)需要挪动数据,不易操作。

    *List的访问要遍历整个链表,它的随机访问效率低。但对数据的插入和删除操作等都比较方便,改变指针的指向即可。

    *list是单向的,vector是双向的。

    *vector中的迭代器在使用后就失效了,而list的迭代器在使用之后还可以继续使用。

    展开全文
  • java中vector与hashtable操作实例,有需要的朋友可以参考一下众所周知,java中vector与hashtable是线程安全的,主要是java对两者的操作都加上了synchronized,也就是上锁了。因此 在vector与hashtable的操作是不会...

    java中vector与hashtable操作实例,有需要的朋友可以参考一下

    众所周知,java中vector与hashtable是线程安全的,主要是java对两者的操作都加上了synchronized,也就是上锁了。因此 在vector与hashtable的操作是不会出现问题。但是有一种情况:就是将一个hashtable copy到另一个hashtable时,假如使用putAll方法的花,会抛出一个 java.util.ConcurrentModificationException异常。先上代码:

    TestSync.java

    public class TestSync

    {

    /**

    * main(这里用一句话描述这个方法的作用)

    * (这里描述这个方法适用条件 – 可选)

    * @param args

    * @return void

    * @exception

    * @since  1.0.0

    */

    public static void main(String[] args)

    {

    Map list  = new Hashtable();

    List vec = new Vector();

    TestThread thread = new TestThread();

    thread.start();

    int i = 0;

    while(i<1000)

    {

    i++;

    System.out.println("iiiiiiiiii=------------" + i);

    list.clear();

    vec.clear();

    //vector与hashtable是线程安全的 ,putAll方法中两个集合实现不一样

    vec.addAll(Constans.USERVEC);

    //            synchronized (Constans.USERLIST)

    //            {

    list.putAll(Constans.USERLIST);

    //            }

    System.out.println("--------" + list.size());

    System.out.println("--------" + vec.size());

    }

    System.out.println("Over---------------------------------------------");

    }

    }

    class Constans

    {

    public static Map USERLIST  = new Hashtable();

    public static List USERVEC = new Vector();

    }

    class TestThread extends Thread

    {

    @Override

    public void run()

    {

    for(int i=0;i<100000;i++)

    {

    User user = new User();

    user.setId(i);

    user.setName("name" + i);

    if(!Constans.USERLIST.containsKey(i))

    {

    Constans.USERLIST.put(i,user);

    Constans.USERVEC.add(user);

    }

    }

    System.out.println("线程结束------------");

    }

    }

    当我们将

    //synchronized (Constans.USERLIST)

    //            {

    list.putAll(Constans.USERLIST);

    //            }

    不使用同步时,就回抛出异常。是由于Constans.USERLIST不同步,而不是putAll方法不安全。

    而Vector与Hashtable不同的是Vector的addAll方法不使用同步也可以正常运行,那是由于Vector的addAll与Hashtable的putAll方法不同,Vector的addAll会将参数先copy一份,因此不会产生异常。

    User.java

    public class User

    {

    private int id;

    private String name;

    public int getId()

    {

    return id;

    }

    public void setId(int id)

    {

    this.id = id;

    }

    public String getName()

    {

    return name;

    }

    public void setName(String name)

    {

    this.name = name;

    }

    }

    写的不好,大家原谅。

    展开全文
  • java中vector与hashtable操作实例,有需要的朋友可以参考一下
  • 本篇文章是对Java中Vector与ArrayList的区别进行了详细的分析介绍,需要的朋友参考下
  • 主要为大家详细介绍了Java中Vector和ArrayList的区别,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • java中Vector方法详解

    2020-06-29 19:14:23
    Java中vector用法整理 ArrayList会比Vector快,他是非同步的,如果设计涉及到多线程,还是用Vector比较好一些 import java.util.*; /** 演示Vector的使用。包括Vector的创建、向Vector中添加元素、从Vector中删除...

    博客园首页新随笔联系管理订阅订阅随笔- 25 文章- 0 评论- 3
    Java中vector用法整理
    ArrayList会比Vector快,他是非同步的,如果设计涉及到多线程,还是用Vector比较好一些
    import java.util.*;

    /**

    • 演示Vector的使用。包括Vector的创建、向Vector中添加元素、从Vector中删除元素、
    • 统计Vector中元素的个数和遍历Vector中的元素。
      */

    public class VectorDemo{
    public static void main(String[] args){

    //Vector的创建
    //使用Vector的构造方法进行创建
    Vector v = new Vector(4);

    //向Vector中添加元素
    //使用add方法直接添加元素
    v.add(“Test0”);
    v.add(“Test1”);
    v.add(“Test0”);
    v.add(“Test2”);
    v.add(“Test2”);

    //从Vector中删除元素
    v.remove(“Test0”); //删除指定内容的元素
    v.remove(0); //按照索引号删除元素

    //获得Vector中已有元素的个数
    int size = v.size();
    System.out.println(“size:” + size);

    //遍历Vector中的元素
    for(int i = 0;i < v.size();i++){
    System.out.println(v.get(i));
    }
    }
    }

    Vector 类提供了实现可增长数组的功能,随着更多元素加入其中,数组变的更大。在删除一些元素之后,数组变小。
    Vector 有三个构造函数,
    public Vector(int initialCapacity,int capacityIncrement)          public Vector(int initialCapacity)          public Vector()   Vector 运行时创建一个初始的存储容量initialCapacity,存储容量是以capacityIncrement 变量定义的增量增长。初始的存储容量和capacityIncrement 可以在Vector 的构造函数中定义。第二个构造函数只创建初始存储容量。第三个构造函数既不指定初始的存储容量也不指定capacityIncrement。   Vector 类提供的访问方法支持类似数组运算和与Vector 大小相关的运算。类似数组的运算允许向量中增加,删除和插入元素。它们也允许测试矢量的内容和检索指定的元素,与大小相关的运算允许判定字节大小和矢量中元素不数目。   现针对经常用到的对向量增,删,插功能举例描述:
    addElement(Object obj)     把组件加到向量尾部,同时大小加1,向量容量比以前大1  
    insertElementAt(Object obj, int index)     把组件加到所定索引处,此后的内容向后移动1 个单位  
    setElementAt(Object obj, int index)   把组件加到所定索引处,此处的内容被代替。   removeElement(Object obj) 把向量中含有本组件内容移走。   removeAllElements() 把向量中所有组件移走,向量大小为0。

    例如:

    import java.lang.System;

    import java.util.Vector;

    import java.util.Emumeration;

    public class Avector{

    public static void main(String args[]) {
      0.Vector v=new Vector();
      1. v.addElement(“one”);
      2. addElement(“two”);
      3. v.addElement(“three”);
      4. v.insertElementAt(“zero”,0);
      5. v.insertElementAt(“oop”,3);
      6. v.setElementAt(“three”,3);
      7. v.setElementAt(“four”,4);
      8. v.removeAllElements();
    }
    }
    Vector中的变化情况:

    1. one   2. one   3. one   4. zero   5.zero   6. zero  7. zero 8.       two   two  one   one   one   one            three   two   two   two   two  three   oop   three  three  three   three  four     另外,Vector 在参数传递中发挥着举足轻重的作用。在Applet 中有一块画布(Canvas) 和一个(Panel), 而Panel 中放着用户要输入的信息,根据这些信息把参数传递到canvas 中,这时在Java 中用一个接口(Interface), 而在接口中需用一个Vector 去传递这些参数。另外,在一个类向另一个类参数传递就可以用这种方法。   例如:  
      import java.util.Vector
      interface codeselect{ Vector codeselect=new Vector(); } 显示数学信息
      Vector(0)存入学生编号
      Vector(1)存入学科     在Panel 中当用户在TextField 和Choice 中选择自己所要求的内容,程序中通过事件响应把值传到向量Vector 中。

    同步是个很大的问题,尤其多线程,和进程中,因此,我们在多线程中同时对某个数组操作时,支持同步的vector无疑是个很好的选择,一般在需要将多个元素存在一个集合里的时候用。
    java.util 类 Vector
    boolean add(E o)
    将指定元素追加到此向量的末尾。
    void add(int index, E element)
    在此向量的指定位置插入指定的元素。
    boolean addAll(Collection<? extends E> c)
    将指定 Collection 中的所有元素追加到此向量的末尾,按照指定集合的迭代器所返回的顺序追加这些元素。
    boolean addAll(int index, Collection<? extends E> c)
    在指定位置将指定 Collection 中的所有元素插入到此向量中。
    void addElement(E obj)
    将指定的组件添加到此向量的末尾,将其大小增加 1。
    int capacity()
    返回此向量的当前容量。
    void clear()
    从此向量中移除所有元素。
    Object clone()
    返回向量的一个副本。
    boolean contains(Object elem)
    测试指定的对象是否为此向量中的组件。
    boolean containsAll(Collection<?> c)
    如果此向量包含指定 Collection 中的所有元素,则返回 true。
    void copyInto(Object[] anArray)
    将此向量的组件复制到指定的数组中。
    E elementAt(int index)
    返回指定索引处的组件。
    Enumeration elements()
    返回此向量的组件的枚举。
    void ensureCapacity(int minCapacity)
    增加此向量的容量(如有必要),以确保其至少能够保存最小容量参数指定的组件数。
    boolean equals(Object o)
    比较指定对象与此向量的相等性。
    E firstElement()
    返回此向量的第一个组件(位于索引 0 处的项)。
    E get(int index)
    返回向量中指定位置的元素。
    int hashCode()
    返回此向量的哈希码值。
    int indexOf(Object elem)
    搜索给定参数的第一个匹配项,使用 equals 方法测试相等性。
    int indexOf(Object elem, int index)
    搜索给定参数的第一个匹配项,从 index 处开始搜索,并使用 equals 方法测试其相等性。
    void insertElementAt(E obj, int index)
    将指定对象作为此向量中的组件插入到指定的 index 处。
    boolean isEmpty()
    测试此向量是否不包含组件。
    E lastElement()
    返回此向量的最后一个组件。
    int lastIndexOf(Object elem)
    返回指定的对象在此向量中最后一个匹配项的索引。
    int lastIndexOf(Object elem, int index)
    向后搜索指定的对象,从指定的索引处开始搜索,并返回一个索引。
    E remove(int index)
    移除此向量中指定位置的元素。
    boolean remove(Object o)
    移除此向量中指定元素的第一个匹配项,如果向量不包含该元素,则元素保持不变。
    boolean removeAll(Collection<?> c)
    从此向量中移除包含在指定 Collection 中的所有元素。
    void removeAllElements()
    从此向量中移除全部组件,并将其大小设置为零。
    boolean removeElement(Object obj)
    从此向量中移除变量的第一个(索引最小的)匹配项。
    void removeElementAt(int index)
    删除指定索引处的组件。
    protected void removeRange(int fromIndex, int toIndex)
    从此 List 中移除其索引位于 fromIndex(包括)与 toIndex(不包括)之间的所有元素。
    boolean retainAll(Collection<?> c)
    在此向量中仅保留包含在指定 Collection 中的元素。
    E set(int index, E element)
    用指定的元素替换此向量中指定位置处的元素。
    void setElementAt(E obj, int index)
    将此向量指定 index 处的组件设置为指定的对象。
    void setSize(int newSize)
    设置此向量的大小。
    int size()
    返回此向量中的组件数。
    List subList(int fromIndex, int toIndex)
    返回此 List 的部分视图,元素范围为从 fromIndex(包括)到 toIndex(不包括)。
    Object[] toArray()
    返回一个数组,包含此向量中以正确顺序存放的所有元素。
    T[]
    toArray(T[] a)
    返回一个数组,包含此向量中以正确顺序存放的所有元素;返回数组的运行时类型为指定数组的类型。
    String toString()
    返回此向量的字符串表示形式,其中包含每个元素的 String 表示形式。
    void trimToSize()
    对此向量的容量进行微调,使其等于向量的当前大小。

    展开全文
  • 本文介绍Vector容器在Java中的底层实现,首先看一下这个类的声明:public class Vectorextends AbstractListimplements List, RandomAccess, Cloneable, java.io.Serializable这个类继承了AbstractList这个抽象类,...
  • Java中Vector

    2018-11-15 22:35:52
    Java中Vector类的用法 一、本文是对三篇文章的总结与排版,链接如下 链接1: [https://www.cnblogs.com/zhaoyan001/p/6077492.html] 链接2:[https://blog.csdn.net/lskyne/article/details/8769147] 链接3:...
  • 在Applet 有一块画布(Canvas) 和一个(Panel), 而Panel 放着用户要输入的信息,根据这些信息把参数传递到canvas ,这时在Java 中用一个接口(Interface), 而在接口需用一个Vector 去传递这些参数。另外,在一...
  • java中vector的用法

    2011-07-23 09:52:09
    本文是一篇word文档,主要介绍了java中vector的用法,让一些初学者更加了解vector的用法。
  • 参考:Java中Vector和ArrayList的区别
  • 为了可以使用 vector,必须在你的头文件中包含下面的代码: #include vector 属于 std 命名域的,因此需要通过命名限定,如下完成你的代码: using std::......Java中集合用法总结 收藏 Collection ├List │├LinkedList...
  • Java中 Vector的使用详解 Vector 可实现自动增长的对象数组。 java.util.vector提供了向量类(Vector)以实现类似动态数组的功能。 创建了一个向量类的对象后,可以往其中随意插入不同类的对象,即不需顾及类型也不...
  • java中vector和array区别

    2019-09-28 07:43:51
    java中vector和数组非常类似,两者之间也经常成对出现,下面是两者的比较:1、数组:java arrays的元素个数不能下标越界,从很大程度上保证了java程序的安全性,但创建时必须指定数组的大小,并不能再改变。...
  • ArrayList会比Vector快,他是非同步的,如果设计...包括Vector的创建、向Vector中添加元素、从Vector中删除元素、* 统计Vector中元素的个数和遍历Vector中的元素。*/public class VectorDemo{public static void ...
  • Java中Vector和ArrayList的区别? Vector是线程安全的(所有方法都是同步的) ArrayList是线程不安全的 所以,在执行效率上ArrayList更高,Vector更低一点,视乎是否多线程选择使用吧!
  • Java 中Vector、ArrayList和LinkedList 的区别2007年02月25日 09:49:00阅读数:6212Java 中Vector、ArrayList和LinkedList 的区别Java 中Vector、ArrayList和LinkedList 的区别SDK提供了有序集合接口java.util.List...
  • Java中Vector、ArraryList和LinkedList的区别
  • public classVectorextends下列类的父类:Vector类实现了可动态扩充的对象数组。类似数组,它包含的元素可通过数组下标来访问。但是,在Vector创建之后。Vector可根据增加和删除元素的需要来扩大或缩小。每个向量可...
  • java中Vector和ArrayList的性能比较 测试条件: 循环次数:1千万次 元素个数:1000个 测试结果: 总结:ArrayList获取元素非常快,不过添加元素没有Vector快,两者各有优势,Vector是线程安全的,而ArrayList是...
  • PAGE / NUMPAGES 在JAVA中的详细说明 java:Vector 类可以实现自动增长的对象数组; Java.util.Vector提供了向量(Vector)类以实现类似动态数组的功能在Java语言中是没有指针概念的但如果能正确灵活地使用指针又确实...
  • Java中vector的使用详解

    2016-06-30 11:37:02
    Java中vector的使用详解 Vector 可实现自动增长的对象数组。  java.util.vector提供了向量类(vector)以实现类似动态数组的功能。在Java语言中没有指针的概念,但如果正确灵活地使用指针又确实可以大大提高程序的...
  • Vector的最小元素可以使用java.util.Collections.min()方法获得。此方法包含一个参数,即Vector,其最小元素已确定,它从Vector返回最小元素。演示此的程序如下所示-示例importjava.util.Collections;importjava....
  • 展开全部自定义排序吧,自己写一62616964757a686964616fe58685e5...将所有的需要排序的vector放入到一个List之,然后调用Collections的sort方法进行排序。下面是实现的代码。importjava.util.ArrayList;importja...
  • Vector的使用vector类底层数组结构的,它包含可以使用整数索引进行访问的组件。不过,vector的大小可以根据需要增大或缩小,以适应创建vector后进行添加或移除项的操作,因此不需要考虑元素是否越界或者会不会浪费...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 8,837
精华内容 3,534
关键字:

java中vector

java 订阅