JAVA学习---Collection子接口（List）以及List接口的常用方法

JAVA学习—Collection子接口一（List）以及List接口的常用方法

说明

/*
 * 1.Collection接口：单列集合，用来存储一个一个的对象
 *       List接口：存储有序的、可重复的数据。   ---->类似动态数组，替换原有的数组
 *          ArrayList:作为List接口的主要实现类，线程不安全，效率高，底层使用Object[] elementData存储
 *          LinkedList:底层使用双向链表存储，对于频繁的插入、删除操作，使用此类效率比ArrayList高
 *          Vector:作为List接口的古老实现类，线程安全，效率低，底层使用Object[] elementData存储
 *          
 * 面试题：ArrayList、LinkedList、Vector三者的异同？
 * 同：三个类都实现了List的接口，存储数据的特点相同：存储有序的、可重复的数据
 * 不同:见上
 * 
 * 2.ArrayList源码分析
 * 2.1 jdk 7的情况
 * ArrayList list=new ArrayList(); //底层创建了长度为10的Object[] 数组elementData
 * list.add(123); //element[0]=new Integer(123);
 * ...
 * list.add(11); //如果此次添加导致底层elementData数组容量不够，则扩容。默认情况下，扩容为原来的容量的1.5倍，同时需要将原有数组中的数据复制到新的数组中
 * 
 * 结论：建议开放中使用参数的构造器： ArrayList list=new ArrayList();
 * 
 * 2.2 jdk 8中ArrayList的变化
 * ArrayList list=new ArrayList(); //底层Object[] elementData初始化为{},并没有创建长度
 * 
 * list.add(12); //第一次调用add()时，底层才创建长度为10的数组，并将数据12添加到elementData
 * ...
 * 后续的添加和扩容操作与jdk 7无异
 * 
 * 2.3 小结：jdk7中的ArrayList的对象的创建类似于单例的饿汉式，而jdk8中的ArrayList的对象的创建类似于单例的懒汉式，耗费创建数组的时间，但节省空间。
 * 
 * 
 * 3.LinkedList的源码分析
 * LinkedList list = new LinkedList(); //内部声明了Node类型的first和last属性，默认值为null
 * list.add(123); //将123封装到Node中，创建了Node对像。
 * 
 * 其中，Node定义如下，体现了LinkNodeList的双向链表的属性
 * 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.prev=prev;
 *       this.next=next;
 *       
 *       }
 * }
 * 
 * 4.Vector源码分析
 * 在jdk7和jdk8中，底层已经创建了长度为10的数组
 * 在扩容方面，每次扩容都会增加为原来的2倍
 * 
 /*

List常用方法

void add(int index, Object ele):在index位置插入ele元素
boolean addAll(int index, Collection eles):从index位置开始将eles中的所有元素添加进来
Object get(int index):获取指定index位置的元素
int indexOf(Object obj):返回obj在集合中首次出现的位置 ，如果没有就返回-1
int lastIndexOf(Object obj):返回obj在当前集合中末次出现的位置 ，如果没有就返回-1
Object remove(int index):移除指定index位置的元素，并返回此元素
注意：Collection中的remove是删除某个元素，这里是方法的重载而不是方法的重写 ，在List中也可以按照对象去删除
Object set(int index, Object ele):设置指定index位置的元素为ele
List subList(int fromIndex, int toIndex):返回从[fromIndex到toIndex )位置的子集合，本身的list没有变化

List常用方法测试

import java.util.ArrayList;
import java.util.Collection;
public class SubinterafaceTest {
	public static void main(String[] args) {
		
		ArrayList list=new ArrayList();
		list.add(123);
		list.add(456);
		list.add(789);
		list.add(new Person1("Tom",12));
		System.out.println(list); //[123, 456, 789, Person [name=Tom, age=12]]
		
		/*
		 * void add(int index, Object ele):在index位置插入ele元素,index表示下标
		 * boolean addAll(int index, Collection eles):从index位置开始将eles中的所有元素添加进来
		 */
		list.add(1,"Hello");
		System.out.println(list); //[123, Hello, 456, 789, Person [name=Tom, age=12]]
		
		Collection eles=new ArrayList();
		eles.add("Java");
		eles.add('!');
		list.addAll(2,eles);
		System.out.println(list); //[123, Hello, Java, !, 456, 789, Person [name=Tom, age=12]]
		
		/*
		 * Object get(int index):获取指定index位置的元素
		 */
		System.out.println(list.get(1));  //Hello
		
		/*
		 * int indexOf(Object obj):返回obj在集合中首次出现的位置 ，如果没有就返回-1
		 * int lastIndexOf(Object obj):返回obj在当前集合中末次出现的位置 ，如果没有就返回-1
		 */
		System.out.println(list.indexOf('!'));  //3
		System.out.println(list.lastIndexOf("o"));  //-1
		
		/*
		 * Object remove(int index):移除指定index位置的元素，并返回此元素
		 * 注意：Collection中的remove是删除某个元素，这里是方法的重载而不是方法的重写 ，此处的remove()按照索引来删除，在List中可以按照集合中的元素来删除
		 */
		System.out.println(list.remove(1));  //Hello
		
		/*
		 * Object set(int index, Object ele):设置指定index位置的元素为ele
		 */
		list.set(2, "Hello");
		System.out.println(list); //[123, Java, Hello, 456, 789, Person [name=Tom, age=12]]
		
		/*
		 * List subList(int fromIndex, int toIndex):返回从[fromIndex到toIndex )位置(不包括toIndex位置的元素)的子集合，本身的list没有变化
		 */
		System.out.println(list.subList(1, 3));  //[Java, Hello]
		
		/*
		 * 遍历的三种方法
		 */
		//Iterator迭代器方式
		Iterator iterator=list.iterator();
		while(iterator.hasNext()) {
			System.out.print(iterator.next()+" "); //123 Java Hello 456 789 Person [name=Tom, age=12]
		} 
		//增强for循环
		for(Object obj:list) {
			System.out.print(obj+" ");//123 Java Hello 456 789 Person [name=Tom, age=12]
		}
		//普通for循环
		for(int i=0;i<list.size();i++) {
			System.out.print(list.get(i)+" "); //123 Java Hello 456 789 Person [name=Tom, age=12]
		}
	}

}

class Person1{
	private String name;
	private int age;
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Person1 other = (Person1) obj;
		if (age != other.age)
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return true;
	}

	Person1(String name,int age){
		this.name=name;
		this.age=age;
	}
	public String toString() {
		return "Person [name=" + name + ", age=" + age + "]";
	}	
}