Java-Collection的子接口-List集合

List集合

  特点：有序，有下标、元素可以重复。
  方法：
  1）void add(int index, Object o); //在index位置插入对象o；
  1）Object get(int index); //返回集合中指定位置的元素；
  2）List subList(int fromIndex, int toIndex);//返回fromIndex到toIndex之间的集合元素

Demo1

/**
*List子接口的使用
*/
public class Demo1{
	public static void main(String[] args){
		List list=new ArrayList<>();
		//1.添加元素
		list.add("苹果");
		list.add("小米");
		list.add(0, "华为");
		System.out.println(list.size());
		//2.删除元素
		list.remove(0);
		//3.遍历
		for(int i=0;i<list.size();i++){
			System.out.println(list.get(i));
		}
		for(Object obj:list){
			System.out.println(obj);
		}
		Iterator it=list.iterator();
		while(it.hasNext()){
			System.out.println(it.next);
		}
		//使用列表迭代器
		ListIterator listit=list.listIterator();
		//向后遍历
		while(listit.hasNext()){
			System.out.println(listit.nextIndex()+listit.next());
		}
		//向前遍历
		while(listit.hasPrevious()){
			System.out.println(listit.previousIndex()+listit.previous());
		}
	}
}

public class Demo2{
	public static void main(String[] args){
		List list=new ArrayList<>();
		//添加数字数据；（自动装箱）
		list.add(20);
		list.add(30);
		list.add(40);
		list.add(50);
		list.add(60);
		//删除
		list.remove(20);
		list.remove((Object)20);//强转之后删除
		//subList（左闭右开区间）
		System.out.println(list.subList(1,3).toString());
	}
}

List 实现类

   ArrayList【重点】：
     1）数组结构实现，查询快，增删慢；
     2）运行效率快，线程不安全；
   Vector:
     1）数组结构实现，查询快，增删慢；
     2）运行效率慢，线程安全；
   LinkedList:
     链表结构实现，增删快，查询慢。

ArrayList

/**
*
*/
public class Demo2{
	public static void main(String[] args){
		ArrayList arraylist=new ArrayList<>();
		//添加元素
		Student s1=new Student("曹雪梅"，21);
		Student s2=new Student("石云鹏"，21);
		Student s3=new Student("张雨轩"，21);
		Student s4=new Student("刘荡"，21);
		arraylist.add(s1);
		arraylist.add(s2);
		arraylist.add(s3);
		Sysytem.out.println(arraylist.size());
		Sysytem.out.println(arraylist.toString());
		//删除元素
		//arraylist.remove(s1);
		arraylist.remove(new Student("张雨轩", 21));//equals(this==obj)
		/**
			需要重写Student类中的equals方法
			@override
			public boolean equals(Object obj){
				// 1 判断是否为同一个对象
				if(this==obj){
					return true;
				}
				// 2 判断是否位空
				if(obj==null){
					return false;
				}
				// 3 判断是否是Student类型
				if(obj instanceof Student){
					Student s=(Student)obj;
					// 4 比较属性
					if(this.name.equals(s.getName())&&this.age.equals(s.getAge()){
						return true;
					}
				}
				// 5 不满足返回false
				return false;
			}
		*/
		//遍历【重点】
		Iterator it=arraylist.iterator();
		while(it.hasNext()){
			Student s=(Student)it.next();
			System.out.println(s.toSting());
		}
		ListIterator listit=arraylist.listIterator ();
		while(listit.hasNext()){
			Student s=(Student)listit.next();
			System.out.println(s.toSting());
		}
		ListIterator listitp=arraylist.listIterator ();
		while(listitp.hasPrevious()){
			Student s=(Student)listitp.previous();
			System.out.println(s.toSting());
		}
		// 判断
	}
}

ArrayList源码分析

DEFAULT_CAPACITY=10   默认容量：如果没有向集合中添加任何元素，容量0；添加任意一个元素后，就为10 每次扩容大小是原来的1.5倍
elementData   存放元素的数组
size   实际元素的个数

构造方法：
   add()方法

/***
* 就是逐渐扩容的原则，到达10容量之后，在一次扩容到15，22，每次1.5倍增长
*/
public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }

private void ensureCapacityInternal(int minCapacity) {
        ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}

private static int calculateCapacity(Object[] elementData, int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            return Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        return 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);
    }

Vector

     1）数组结构实现，查询快，增删慢；
     2）运行效率慢，线程安全；

public class Demo1{
	public static void main(String[] args){
		Vector vector=new vector<>();
		//添加
		vector.add("西瓜");
		vector.add("梨子");
		vector.add("梨子");
		//遍历
		//使用枚举器
		Enumeration en=vector.elements();
		while(en.hasMoreElements()){
			String o=en.nextElement();
			System.out.println(o);
		}
	}
}

LinkedList

     链表结构实现，增删快，查询慢。

/**
* 双向链表
*/
public class Demo1{
	public static void main(Sting[] args){
		LinkedList linkedlist=new LinkedList<>();
		Student s1=new Student("曹雪梅",21);
		Student s2=new Student("石云鹏",21);
		Student s3=new Student("张雨轩",21);
		Student s4=new Student("刘荡",21);
		//添加元素
		linkedlist.add(s1);
		linkedlist.add(s2);
		linkedlist.add(s3);
		linkedlist.add(s4);
		//删除
		linkedlist.remove(new Student("刘荡",21));//能够删除，因为之前修改了Student的equals方法。
		//遍历
		for(int i=0;i<linkedlist.size();i++){
			System.out.println(linkedlist.get(i));
		}
		for(Object obj:linkedlist){
			Student s=(Student)obj;
			System.out.println(s.toString());
		}
		//迭代器listIterator(可向前向后迭代输出)
		Iterator linkedlistiterator=linkedlist.iterator();
		while(linkedlistiterator.hasNext()){
			Student s=(Student) linkedlistiterator.next();
			System.out.println(s.toString());
		}
		//获取
		
			System.out.println(linkedlist.indexOf(s1));
	}
}

LinkedList源码分析

public boolean add(E e) {
        linkLast(e);
        return true;
    }

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++;
    }
    
private static class Node<E> {
        E item;
        Node<E> next;
        Node<E> prev;

        Node(Node<E> prev, E element, Node<E> next) {
            this.item = element;
            this.next = next;
            this.prev = prev;
        }
    }

ArrayList和LinkedList的区别