精华内容
下载资源
问答
  • List集合多种实现分类

    2019-06-03 21:10:39
    List是有序、可重复的容器。 有序: List中每个元素都有索引标记。可以根据元素的索引标记(在List中的位置)访问 元素,从而精确...List接口常用的实现类有3个:ArrayList、LinkedList和Vector。 ArrayList: ArrayLi...

    List是有序、可重复的容器。
    有序:
    List中每个元素都有索引标记。可以根据元素的索引标记(在List中的位置)访问 元素,从而精确控制这些元素。
    可重复:
    List允许加入重复的元素。更确切地讲,List通常允许满足 e1.equals(e2) 的元素重复加入容器。
    List接口常用的实现类有3个:ArrayList、LinkedList和Vector。
    ArrayList:
    ArrayList底层是用数组实现的存储。 特点:查询效率高,增删效率低,线程不安全。我们一般使用它。
    ArrayList底层使用Object数组来存储元素数据。所有的方法,都围绕这个核心的Object数组来开展。

        transient Object[] elementData; // non-private to simplify nested  class access
        /**
         * The size of the ArrayList (the number of elements it contains).
         *
         * @serial
         */
        private int size;
    

    我们知道,数组长度是有限的,而ArrayList是可以存放任意数量的对象,长度不受限制,那么它是怎么实现的呢?本质上就是通过定义新的更大的数组,将旧数组中的内容拷贝到新数组,来实现扩容。 ArrayList的Object数组初始化长度为10,如果我们存储满了这个数组,需要存储第11个对象,就会定义新的长度更大的数组,并将原数组内容和新的元素一起加入到新数组中,源码如下:

        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); //复制
        }
    

    LinkedList:
    LinkedList底层用双向链表实现的存储。特点:查询效率低,增删效率高,线程不安全。
    双向链表也叫双链表,是链表的一种,它的每个数据节点中都有两个指针,分别指向前一个节点和后一个节点。 所以,从双向链表中的任意一个节点开始,都可以很方便地找到所有节点。
    Vector:
    Vector底层是用数组实现的List,相关的方法都加了同步检查,因此“线程安全,效率低”。 比如,copyInto方法就增加了synchronized同步标记。

     public synchronized void copyInto(Object[] anArray) {
            System.arraycopy(elementData, 0, anArray, 0, elementCount);
        }
    

    如何选用ArrayList、LinkedList、Vector?
    1. 需要线程安全时,用Vector。
    2. 不存在线程安全问题时,并且查找较多用ArrayList(一般使用它)。
    3. 不存在线程安全问题时,增加或删除元素较多用LinkedList。

    展开全文
  • 引入集合的目的:使用数组存储元素时必须确定数组的长度,即数组存储元素的个数是固定的,这实际运用时十分大的局限性,因此引入集合可以结局这个问题。 集合的概念:JAVA API所提供的一系列的实例,可以...

    引入集合的目的:在使用数组存储元素时必须确定数组的长度,即数组存储元素的个数是固定的,这在实际运用时有十分大的局限性,因此引入集合可以结局这个问题。

    集合的概念:JAVA API所提供的一系列类的实例,可以用于动态存放多个对象。集合类位于java.util包中,

    特点: 长度不固定,只能存储引用类型的对象

    集合的大致框架

    其中

    Collection接口存储一组不唯一的对象;

    List接口存储一组不唯一的,有序的对象;Set接口存储一组唯一的、不可重复的对象

    Map集合存储一组键值对象。

    一、List接口的实现类之一 —— ArrayList集合(有时间实现一下

    ArrayList有点类似于数组,不过在存储元素时更加灵活,在添加元素时不必指明集合的长度,底层实现是是通过ensureCapacity来增加其容量。

    构造方法

    ArrayList() : 构造一个初始容量为 10 的空集合;

    ArrayList(Collection< ? extends E> c) :构造一个包含指定 collection 的元素的列表,这些元素是按照该 collection的迭代器返回它们的顺序排列的;

    ArrayList(int initialCapacity):构造一个具有指定初始容量的空列表;

    一些重要方法

    boolean add(E e) : 将元素添加到集合尾部;

    void add(int index,E e):将元素插入到指定位置;

    boolean contains(Object o): 判断集合中是否包含所给元素;

    E get(int index): 返回此列表中指定位置的元素;

    E remove(int index): 移除集合中指定位置上的元素;

    int size(): 返回该集合的长度

    Object[] toArray():按适当顺序(从第一个到最后一个元素)返回包含此列表中所有元素的数组;

    简单使用示例

    package list;
    
    import java.util.*;
    
    public class ArrayListDemo {
    	
    	public static void main(String[] args) {
    		
    		List<String> list = new ArrayList<>();
    		list.add("小花");
    		list.add("小红");
    		list.add("小黑");
    		list.add("小绿");
    		list.add("小名");
    		list.add(2,"小黄");
    		
    		System.out.println(list.contains("大花"));
    		
    		//利用for循环遍历list元素
    		for (int i = 0; i < list.size(); i++) {
    			System.out.print(list.get(i)+"  ");
    		}
    		
    		list.remove("小绿");
    		
    		//String[] str = (String[]) list.toArray();
    	}
    }
    

    二、List集合的实现类之二 —— LinkedList(有时间去实现一下

    优点:插入或删除快效率高

    缺点:查找速度慢

    三、Collection工具类

    Collection是集合的工具类,其中提供了一系列的静态方法,用于操作集合的一系列静态方法。

    package collections;
    
    import java.util.ArrayList;
    import java.util.Collections;
    import java.util.List;
    
    public class CollectionsDemo {
    	
    	public static <E> void showList(List<E> list){
    		for(E e : list){
    			System.out.print(e+"  ");
    		}
    		System.out.println();
    		System.out.println("**************");
    	}
    	
    	public static void main(String[] args) {
    		
    		List<String> list = new ArrayList<String>();
    		//该方法可以实现向集合中添加元素
    		Collections.addAll(list,"瓜皮","智障","神经病","妖刀村正","天域","恍惚","三神器","年套");
    		CollectionsDemo.showList(list);
    		
    		//shuffle(xxx)方法将list集合中的数据顺序打乱
    		Collections.shuffle(list);
    		CollectionsDemo.showList(list);
    		
    		//reverse()方法将打乱的list集合中的数据逆序输出
    		Collections.reverse(list);
    		CollectionsDemo.showList(list);
    	}
    	
    }
    
    四、迭代器的使用(Iterator)

    Iterator是专门的迭代输出接口,迭代输出的意思是将元素进行判断,判断是否有内容,如果有内容就将内容取出。

    Iterator对象成为迭代器,用以方便的实现对集合内容元素的遍历操作。

    集合能用迭代器遍历的原因:所有实现了Collections接口的集合类都有一个iterator()方法用以返回一个实现了Iterator接口的对象

    eg: Iterator it = coll.iterator();

          while(it.hasNext()){

    it.next();

    }

    Iterator接口定义了如下方法:

    boolean hasNext():  判断游标的下一个是否还有元素;

    Object next(): 返回游标右边的元素并将游标移动到下一个位置;

    遍历实例如下:


    五、泛型的使用

    泛型是对Java语言的类型系统的一种扩展,以支持创建可以按类型进行参数化的类。可以把类型参数看作是使用参数化类型时指定的类型的一个占位符,就像方法的形式参数是运行时传递的值的占位符一样,即使用泛型之后可以在使用泛型类时指定类型参数的类型。

    泛型的好处:

    1.解决类型安全的问题(运行时出现的ClassCastException异常);

    2.当我们从集合中获取值时不必进行强制类型转换;

    3.使用泛型之后,我们可以指定加入集合中对象的类型,这样,在加入错误类型的对象时在编译期间编译器会报错,增加了程序的安全性和可读性;

    泛型类设置如下:


    关于受限泛型:

    1.设置上限

    类型名称<? entends 上限类> :只能接收上限类对象或其子类对象;

    2.设置下限

    类名称<? super 下限类>:接收下限类对象或其父类对象

    注:若定义泛型类,可以将?设置为泛型标识

    六、Set集合

    Set集合中的元素为不可重复的

    HashSet:散列存储;

    TreeSet:有序存放(按指定顺序存放);

    6.1 HashSet(重点讨论存储原理)

    HashSet的存储原理:在调用add()方法时,根据每个对象的哈希码值(自动调用hashCode())用固定的算法算出它的存储索引,把对象存放在一个叫散列表的相应位置中;

    若对应位置没有其他元素,就只需要直接存入;

    若该位置有元素了,会将新对象跟该位置的所有对象进行比较,,以查看是否已经存在该元素,若存在了就不存放了,若不存在就存放新元素(比较的时候是用equals()方法进行比较的)

    若若存储的对象类没有hashCode和equals方法,便自动调用Object类中的这俩个方法

    比如存储学生类对象:

    package set.hashset;
    
    public class Student {
    	
    	private String name;
    	private String sex;
    	private int age;
    	
    	public Student(){
    		
    	}
    	
    	public Student(String name,String sex,int age){
    		this.name = name;
    		this.sex = sex;
    		this.age = age;
    	}
    
    	//HashSet实现元素的不重复的方法是:
    	/*
    	 * 1.若对应位置的哈希码值(调用hashcode()方法)用固定的算法算出他的存储索引值对应的位置如果没有
    	 * 元素时,就直接把该元素放进去,调用的hashcode方法跟hashset存储的对象有关系,若该对象重写了hashcode方法
    	 * 则调用的是对象所属类的hashcode方法,否则调用Object的hashcode的方法
    	 * 2.若比较的hashcode值对应的索引处已经有元素了,则比较存储对象和该元素是否为同一对象,若一样就不存放了,若不一样就存储,
    	 * 比较的方法是调用equals方法,若对象所属类重写了equals方法则调用的是它的equals方法,否则依然调用Object类的equals方法
    	 * 以上调用的hashcode和equals方法都是对象自动调用的!!!!!!!!
    	 */
    	//重写hashcode方法
    	@Override
    	public int hashCode() {
    		return (this.age+3)*2;
    	}
    	
    	//重写equals方法
    	@Override
    	public boolean equals(Object obj) {
    		Student stu = (Student)obj;
    		if(this.name.equals(stu.name) && this.age==stu.age && this.sex.equals(stu.sex)){
    			return true;
    		}
    		return false;
    	}
    	
    	public String getName() {
    		return name;
    	}
    
    	public void setName(String name) {
    		this.name = name;
    	}
    
    	public String getSex() {
    		return sex;
    	}
    
    	public void setSex(String sex) {
    		this.sex = sex;
    	}
    
    	public int getAge() {
    		return age;
    	}
    
    	public void setAge(int age) {
    		this.age = age;
    	}
    
    	@Override
    	public String toString() {
    		return "Student [name=" + name + ", sex=" + sex + ", age=" + age + "]";
    	}
    	
    	
    }
    
    存储时候用hashSet存储:

    package set.hashset;
    
    import java.util.HashSet;
    import java.util.Iterator;
    
    public class HashSetDemo {
    	
    	public static void main(String[] args) {
    		
    		HashSet<Student> hs = new HashSet<>();
    		
    		hs.add(new Student("小红","女",20));
    		hs.add(new Student("小飞","男",18));
    		hs.add(new Student("小刚","男",28));
    		hs.add(new Student("小天","男",20));
    		hs.add(new Student("小红","女",20));
    		hs.add(new Student("小红","女",20));
    		hs.add(new Student("小红","女",20));
    		hs.add(new Student("小红","女",20));
    		
    		//用迭代器遍历hashset集合中的内容
    		Iterator<Student> it = hs.iterator();
    		while(it.hasNext()){
    			System.out.println(it.next());
    		}
    	}
    }
    
    遍历结果为:



    七、TreeSet集合(重点讨论存储原理)

    TreeSet集合可以对加入其中的元素进行排序,前提是必须指定排序规则,即TreeSet所存储的对象的类必须实现Comparable接口,重写compareTo()方法

    TreeSet的重要构造方法:

    public TreeSet() : 若使用无参构造实例化集合对象,则加入到TreeSet集合的对象所属的类必须实现Comparable接口,重写

     int compareTo (T o)方法,并在方法中编写排序规则,compareTo方法返回值只有正整数,负整数和0;同时在比较排序的过程中已经进行去重操作了

    实例如下(用TreeSet类存储Rice类对象):

    package set.treeset;
    
    //对米饭类对象进行排序
    public class Rice implements Comparable<Rice>{
    	
    	private String name;
    	private int score;  //根据口味打的分
    	private int price;  //米饭价格
    	
    	public Rice(){
    		
    	}
    	
    	public Rice(String name,int score,int price){
    		this.name = name;
    		this.score = score;
    		this.price = price;
    	}
    
    	@Override //升序排列,实现Comparable接口,重写compareTo方法
    	public int compareTo(Rice r) {
    		if(this.score > r.score){
    			return 1;
    		}else if(this.score < r.score){
    			return -1;
    		}else{
    			if(this.price > r.price){
    				return 1;
    			}else if(this.price < r.price){
    				return -1;
    			}else{
    				return this.name.compareTo(r.name);
    			}
    		}
    	}
    
    	@Override
    	public String toString() {
    		return "Rice [name=" + name + ", score=" + score + ", price=" + price
    				+ "]";
    	}
    	
    
    }
    
    存储:

    package set.treeset;
    
    import java.util.TreeSet;
    
    public class TreeTreeSet {
    	
    	public static void main(String[] args) {
    		
    		TreeSet<Rice> tr = new TreeSet<>();
    		tr.add(new Rice("排骨饭",8,18));
    		tr.add(new Rice("西红柿鸡蛋饭",5,12));
    		tr.add(new Rice("鱼香肉丝饭",8,15));
    		tr.add(new Rice("竹笋饭",9,18));
    		tr.add(new Rice("瓜皮饭",8,18));
    		tr.add(new Rice("排骨饭",8,18));
    		
    		for(Rice r : tr){
    			System.out.println(r);
    		}
    	}
    }
    
    遍历结果为:



    集合的概念十分重要,值得深挖。

    展开全文
  • ArrayList集合前面我们学习了Collection以及他的子集合List,子集合中三个实现类分别是ArrayList,vector,LinkedList三个集合,接下来让我们了解一下这三个集合: ArrayList是List集合的一个常用子实现类,...

    ArrayList集合

    在前面我们学习了Collection以及他的子集合List,子集合中有三个实现类分别是ArrayListvectorLinkedList三个集合,接下来让我们了解一下这三个集合:

     

    ArrayListList集合的一个常用子实现类,所以他可以使用List以及collection集合的方法
    特点: 查询速度快,增删慢

    Arraylist集合对字符串的两种遍历方式:

    package com.ArrayList;
     
    import java.util.ArrayList;
    import java.util.Iterator;
     
    public class ArrayListDome {
     
    public static void main(String[] args) {
    ArrayList list=new ArrayList();
    list.add("Hello");
    list.add("World");
    list.add("javaSE");
    //方式一:通过迭代器遍历
    Iterator it=list.iterator();
    while(it.hasNext()) {
    String s=(String) it.next();
    System.out.println(s);
    }
    System.out.println("--------------");
    //方式二:通过size()和get方法遍历
    for(int x=0;x<list.size();x++) {
    String s1=(String)list.get(x);
    System.out.println(s1);
    }
    }
    }
    运行结果:
    Hello
    World
    javaSE
    --------------
    Hello
    World
    javaSE

    对自定义对象的遍历方法:

    首先创建一个自定义对象类:

    package com.ArrayList;
     
    public class Student {
     
    private String name;
    private int age;
    public Student() {
    super();
    }
    public Student(String name, int age) {
    super();
    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;
    }
    
    
    }

    然后在创建一个测试类去调用自定义类中的变量去遍历

    package com.ArrayList;
     
     
    import java.util.ArrayList;
    import java.util.Iterator;
     
    /**
     *通过ArrayList集合遍历自定义对象
     *
     */
     
    public class ArrayListStudentDome {
     
    
    public static void main(String[] args) {
    //创建ArrayList集合对象
    ArrayList list=new ArrayList();
    //创建学生对象
    Student s1=new Student("迪丽热巴",27);
    Student s2=new Student("高雯",25);
    Student s3=new Student("赵星星",24);
    Student s4=new Student("吴宣仪",24);
    Student s5=new Student("杨颖",32);
    //将学生对象导入ArrayList集合对象中
    list.add(s1);
    list.add(s2);
    list.add(s3);
    list.add(s4);
    list.add(s5);
    //方法一:使用迭代器遍历
    Iterator it =list.iterator();
    while(it.hasNext()) {
    Student st=(Student) it.next();
    System.out.println(st.getName()+"----"+st.getAge());
    }
    System.out.println("---------------------");
    //方式二:使用size()和get()遍历
    for(int x=0;x<list.size();x++) {
    Student st2=(Student) list.get(x);
    System.out.println(st2.getName()+"----"+st2.getAge()); 
    }
    }
    }
    运行结果:
    迪丽热巴----27
    高雯----25
    赵星星----24
    吴宣仪----24
    杨颖----32
    ---------------------
    迪丽热巴----27
    高雯----25
    赵星星----24
    吴宣仪----24
    杨颖----32

    Vector集合

    Vector集合也是List集合下的第二个子实现接口

      Vector集合

       底层是一种可增长对象数组,查询快,增删慢

       线程安全,同步,执行效率高

      

      Vector特有功能:

       public void addElement(Object obj)------->相当于add(Object obj)

       public Enumeration elements():返回此向量的枚举--->相当 :public Iterator iterator()迭代器

       boolean hasMoreElements()  --->相当于boolean hasNext() ;

       Object nextElement()   --->相当于Object next() ;

     例如:

    package com.vector;
     
    import java.util.Enumeration;
    import java.util.Vector;
     
    import javax.lang.model.util.Elements;
     
     
    public class vectorDome {
     
    public static void main(String[] args) {
    //创建Vector集合的对象
    Vector ve=new Vector();
    //给对象添加元素
    ve.addElement("element");
    ve.addElement("Enumeration");
    ve.addElement("elements");
    //获取向量的枚举(也就是相当于ArrayList中的迭代器)
    Enumeration e=ve.elements();
    //进行遍历
    while(e.hasMoreElements()) {
    String st=(String) e.nextElement();
    System.out.println(st);
    }
    
    
    }
    }
    运行结果:
    element
    Enumeration
    Elements

    LinkedList集合

    LinkedList集合的特点:

    底层是一种链表实现,查询慢,增删快

      线程不安全的,不同步,执行效率高

     

     linkedList特有功能:

      添加功能

      addFirst(Object e):将指定的元素插入到列表的开头

      addLast(object e):将指定的元素添加到列表末尾

      获取功能:

      getFirst():获取列表第一个元素

      getLast():获取列表最后一个元素

     

      删除功能

      public Object removeFirst()移除并返回此列表的第一个元素。

      public Object removeLast()移除并返回此列表的最后一个元素

     

     例如:

     

    package com.LinkedList;
     
    import java.util.LinkedList;
     
    public class LinkedListDome {
     
    public static void main(String[] args) {
    //创建LinkedList集合的对象
    LinkedList list=new LinkedList();
    //添加功能:addFirst(Object e):将指定的元素插入到列表的开头
    list.addFirst("hello");
    list.addFirst("World");
    list.addFirst("Android");
    System.out.println(list);
    //addLast(object e):将指定的元素添加到列表末尾
    System.out.println("-------------------");
    list.addLast("baby");
    System.out.println(list);
    System.out.println("-------------------");
    //获取列表中的第一个元素
    System.out.println(list.getFirst());
    //获取列表中的最后一个元素
    System.out.println(list.getLast());
    System.out.println("---------------------");
    //删除功能:删除第一个集合中的第一个元素
    list.removeFirst();
    System.out.println("removeFirst过后的List:"+list);
    list.removeLast();
    System.out.println("removeLast过后的List:"+list);
    }
    }
    运行结果:
    [Android, World, hello]
    -------------------
    [Android, World, hello, baby]
    -------------------
    Android
    baby
    ---------------------
    removeFirst:[World, hello, baby]
    removeLast:[World, hello]

    展开全文
  • 引言 后端语言(如C#、Java)中,一般具有List类型,它是一种集合类型,可以放置某个类型数据;...JavaScript中是没有原生支持List类型,所以大家想要使用时候,都会去自己封装一个,然后去实现它,...
        

    引言

    在后端语言(如C#、Java)中,一般具有List类型,它是一种集合类型,可以放置某个类型的数据;它与数组(Array)类似,但是相对于数组,它又会有很多更加便捷的API,如:add、remove、clear等方法;

    JavaScript中是没有原生的支持List类型的,所以大家在想要使用的时候,都会去自己封装一个类,然后去实现它,下面我也给出一种实现方式,这个实现满足了基本的API,而且是在JS Array类型的基础上扩展的,也可以在它上面使用Array的方法,另外一大 亮点 是可以直接引用length属性获得集合的元素个数。

    代码实现

    //兼容IE8-,为Array原型添加indexOf方法;
    if (!Array.prototype.indexOf) {
        Array.prototype.indexOf = function (item) {
            var index = -1;
            for (var i = 0; i < this.length; i++) {
                if (this[i] === item) {
                    index = i;
                    break;
                }
            }
            return index;
        }
    }
    
    //List类实现
    var List = function (args) {
        var self = this;
    
        if (List.isArray(args)) {
            self = args;
        }
        self.constructor = List;
        //向集合追加新元素
        self.add = function (item) {
            self.push(item);
            return self;
        };
        //在指定索引处插入新元素
        self.insert = function (index, item) {
            self.splice(index, 0, item);
            return self;
        };
        //删除元素,仅删除第一个索引处的元素
        self.remove = function (item) {
            var index = self.indexOf(item);
            if (index != -1) {
                return self.splice(index, 1)[0];
            } else {
                return undefined;
            }
        };
        //删除元素,如果元素在多个索引处存在,则全部删除
        self.removeAll = function (item) {
            var result = [];
            var removeItem = undefined;
            do {
                removeItem = self.remove(item);
                if (removeItem !== undefined) {
                    result.push(removeItem);
                }
            } while (removeItem !== undefined);
            return result;
        };
        //根据index删除元素
        self.removeAt = function (index) {
            if (index != -1) {
                return self.splice(index, 1)[0];
            } else {
                return undefined;
            }
        };
        //判断元素是否包含在集合中
        self.contains = function (item) {
            return self.indexOf(item) != -1;
        };
        //清空集合的所有元素
        self.clear = function () {
            return new List(self.splice(0, self.length));
        };
        self.size = function () {
            return self.length;
        };
    
        if (List.isArray(args)) {
            return self;
        } else if (arguments.length > 0) {
            for (var i = 0; i < arguments.length; i++) {
                self.add(arguments[i]);
            }
        }
    };
    List.isArray = Array.isArray || function (target) {
        return Object.prototype.toString.call(target) === "[object Array]";
    };
    
    /*下面这段代码是关键,它设定了List类的原型是Array的原型(继承关系),所以List类也同样拥有Array的特征*/
    List.prototype = Array.prototype;

    改进

    这段代码还是有改进的空间的,就是还可以添加一些其他的便捷方法,不过我就先实现到这里,后续的改进我会更新这段代码。

    展开全文
  • list接口: ...Java 集合框架中最常使用几种 List 实现类是 ArrayList,LinkedList 和 Vector。各种 List 中,最好做法是以 ArrayList 作为默认选择。 当插入、删除频繁时,使用 LinkedList,Vect
  • 1.集合结构图 2.单例集合:将数据一个一个进行存储 2.1 Collection 接口...可以根据元素索引标记(在List位置)访问元素,从而精确控制这些元素。 可重复: List 允许加入重复元素。更确切地讲,List 通常允许
  • 集合类是放在java.util.*;这个包里。集合类存放都是对象引用,而非...集合类型主要3种:set(集)、list(列表)、map(映射)和Queue(队列)。//队列为jdk5中加上(1)Set集(set)是最简单一种集合,它对象...
  • List接口及实现类集合续) List继承了Collection接口,三个实现类 ArrayList ​ 数组列表,数据采用数组方式存储。 ​ ArrayList实现了长度可变数组,内存中分配连续空间。遍历元素和随机访问元素效率...
  • 跟汤老师学Java笔记:集合相关的类和接口 完成:第一遍 1.集合相关的类和接口哪个包中? 集合相关的API都java.util包中 2.集合可以分为哪两大类?...List接口的实现类: ArrayList类,LinkedList类,Vector
  • List接口是一个有序 Collection,List接口能够精确控制每个元素插入位置,能够通过索引(元素在List中位置,类似于数组下标)来访问List中元素,第一个元素索引为 0,而且允许相同元素。 特点:List ...
  • List 接口实现了 Collection 接口,它主要两个实现类:ArrayList 类和 LinkedList 类。 List 集合中允许出现重复元素。与 Set 集合不同是, List 集合元素是有序,可以根据索引位置来检索 List 集合中...
  • Java单例集合List接口常用实现类

    千次阅读 2015-11-22 18:42:26
    集合的出现就是为了持有对象。 集合中可以存储任意类型的对象, 而且长度可变。程序中可能无法预先知道需要多少个对象, 那么用数组来装对象的话, 长度不好定义, 而集合解决了这样的问题。 2.集合和数组的区别1....
  • 一.java集合类图如下所示:上述类图中,实线边框实现类,比如ArrayList,LinkedList,HashMap等,折线边框是抽象类,比如AbstractCollection,AbstractList,AbstractMap等,而点线边框是接口,比如...
  •  List接口是Collection接口子接口,实现List接口集合元素是顺序,而且可以重复,被称为序列。  List集合元素都对应一个整数型序列容器中序号记载其容器中位置,可以根据序号存取容器中...
  • 1. List接口实现类: ArrayList和LinkedList都是按照被存进去顺序保存。存储数据允许重复,可以根据下标获取对应元素。 ArrayList优点是快速随机访问元素,缺点:在List插入和删除时比较慢。 ...
  • Vector 是古老的实现类,继承于AbstractList,实现了List, RandomAccess, Cloneable这些接口。 Vector 是一个古老的集合,JDK1.0就了。大多数操作与ArrayList相同,区别之处在于Vector是线程安全的。 各种list中...
  • Vector 是古老的实现类,继承于AbstractList,实现了List, RandomAccess, Cloneable这些接口。 Vector 是一个古老的集合,JDK1.0就了。大多数操作与ArrayList相同,区别之处在于Vector是线程安全的。 各种list...
  • 它实现了Collection 接口,它主要两个实现类:ArrayList 类和 LinkedList 类。 List 集合中允许出现重复元素。与 Set 集合不同是, List 集合元素是有序,可以根据索引位置来检索 List 集合元素,...
  • * 这两个都是基于数组实现的List Vector是线程安全但是十分古老,在List集合类没有出现时就了,所以尽量少使用Vector,推荐视同Collections工具,来包装线程安全集合 * Vector还提供了一个stack子类,...
  • 集合的长度是可变的。 数组中存储的是同一类型的元素,可以存储基本数据类型值。集合存储的都是对象。而且对象的类型可以不一致。开发中一般当对象多的时候,使用集合进行存储。 2.集合框架 JAVASE提供了满足各种...
  • Java集合的实现中,一个modCount变量,这个变量ArrayList中提供了比较详细的解释: 简单来说,就是这个变量表示了列表结构性改变的次数,结构性改变指的是列表大小发生变化,或者是其他方式改变列表内容,...
  • List接口及其实现类

    2020-12-14 10:04:23
    List接口 鉴于Java中数组用来存储数据的局限性,我们通常...JDK API中List接口的实现类常用的:ArrayList、LinkedList和Vector。 常用方法 void add(int index,Object ele) : index位置插入ele元素 boolean
  • java中List接口的实现类 ArrayList,LinkedList,Vector 的区别概要学习方法 概要 学习完数组、链表、栈这三个数据结构之后,再来看下Java中有序集合List的常用实现类使用什么数据结构实现?以及各类之间什么区别...
  • 查询一列数据然后封装到一个类的属性字段List<String> s 中 实现: 无法实现 resultMap 映射也无法实现 为什么? 当我们用mybatis 时,底层会一行一行数据进行封装,而不能实现一列数据 进行封装一...
  • List接口及实现类

    2020-06-12 16:49:22
    在List集合中允许出现重复元素,所有元素是以一种线性方式进行存储,在程序中可以通过索引来访问集合中指定元素。另外,List集合还有一个特点就是元素有序,即元素存入顺序和取出顺序一致。 特点 它是一...
  • 1:集合java语言中java.util包提供了一些集合,这些集合...3 : 常用集合有List集合,Set集合,Map集合。其中List集合和Set集合实现Collection接口。4:Collection接口是层次结构中根接口,构成Coll...
  • 平时使用中使用比较多就是ArrayList ,ArrayList实现List接口,实现List接口还有Vector、LinkedList 集合。 这三个集合有什么联系和区别以及他们效率。
  • 4. List接口及其实现类

    2020-11-11 22:26:01
    java.util.List 接口继承自 Collection 接口,是单列集合的一个重要分支,习惯性地会将实现了 List 接口的对象称为List集合。...JDK API中List接口的实现类常用的:ArrayList、LinkedList和Vector。
  • List定义: List集合代表一个元素有序、可以重复的集合,集合中每个元素都其对应的顺序索引(List集合默认以元素的添加顺序作为索引)。 List的实现类: 1.ArrayList: ArrayList是一个List(接口)的实现类,因此List...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,221
精华内容 888
关键字:

在list集合的实现类有