黑马程序员——List接口

------ Java培训、Android培训、iOS培训、.Net培训 学习型技术博客、期待与您交流！ -------

List接口

一.  List的介绍：

       1. List：是Collection接口下的一个子接口

       2. 特点：元素有序（指的是存储顺序和取出顺序是否一致），可重复

       3. List的特有功能：

           ⑴. 添加功能：void add(int index,Object obj): 在指定位置添加元素。

           ⑵. 删除功能：Object remove(int index): 根据指定索引删除元素，并把删除的元素返回

           ⑶. 修改功能：Object set(int index,Object obj):把指定索引位置的元素修改为指定的值，返回修改前

                的值。 

           ⑷. 获取功能： ①. Object get(int index): 获取指定位置的元素

                               ②. int indexOf(Object obj): 返回指定元素在集合中第一次出现的索引。

                               ③. ListIterator listIterator(): 列表迭代器

           ⑸. 截取功能：List subList( int fromIndex, int toIndex )截取集合。

       4. List 功能练习:

import java.util.ArrayList;
import java.util.List;

class ListDemo {
	public static void main(String[] args) {
		// 创建集合对象    List接口 不能被实例化,但是可以子类来实例化【多态】，<String> 先可以不写
		List<String> list = new ArrayList<String>();

		// 1. 添加元素
		list.add("hello");
		list.add("world");
		list.add("java");

		// void add(int index, Object obj):在指定位置添加元素
		list.add(1, "javaEE");
		System.out.println("list:" + list);
		// IndexOutOfBoundsException 交表越界异常
		// list.add(14,"javaSE");

		//2. 删除元素
		// Object remove(int index):根据指定索引删除元素，并把删除的元素返回。
		System.out.println("remove:" + list.remove(1));
		System.out.println("list:" + list);
		System.out.println("-------------------");
		
		//3. 修改元素
		// Object set(int index, Object obj):把指定索引位置的元素修改为指定的值，返回修改前的值。
		System.out.println("set:" + list.set(1, "javaee"));
		System.out.println("list:" + list);
		System.out.println("-------------------");
		
        //4. 截取元素
		// List subList(int fromIndex, int toIndex)：截取集合。
		List list2 = list.subList(1, 2);
		System.out.println("list2:" + list2);
		System.out.println("-------------------");
		
		//5. 获取元素
		// int indexOf(Object o):返回指定元素在集合中第一次出现的索引
		System.out.println("indexOf--java:" + list.indexOf("java"));
		System.out.println("indexOf--java2:" + list.indexOf("java2"));
		System.out.println("list:" + list);
	}
}

       运行结果如下:

       5.   ConcurrentModificationException并发修改异常【面试题】

            ConcurrentModificationException : 这是个什么异常，怎么产生的，怎么解决的?

⑴. 怎么产生：

             当我们通过迭代器迭代元素的过程中，又通过集合去添加了元素。这种情况是不允许的。
             因为迭代器是依赖于集合存在的，如果集合发生改变，迭代器也应该相应的发生改变。
             而我们目前看到的确实，迭代器没变，集合变了。所以，报出了一个并发修改异常。

        ⑵. 注意问题：

             通过迭代器遍历集合的时候，是不能通过集合去操作(添加，删除)。

       ⑶. 解决方案：

                            A: 全部通过迭代器操作：元素是添加到刚遍历的那个元素后面。 通过迭代器迭代的时候，可以通过迭代器对集合进行操作。

           B: 全部通过集合操作：元素是添加到最后的。通过集合普通for遍历的时候，可以通过集合去操作。

       ⑷. 案例:

             需求：请遍历集合，判断其中是否有"hello"这个元素，如果有，就再添加一个元素:"IOS"：

package testdemo;
import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;

public class ListDemo {
	public static void main(String[] args) {
		// 创建集合对象
		List<String> list = new ArrayList<String>();

		// 添加元素
		list.add("hello");
		list.add("world");
		list.add("java");

		 //1. 完全通过集合实现
		 for (int x = 0; x < list.size(); x++) {
		 String s = (String) list.get(x);
		 if ("hello".equals(s)) {
		 list.add("IOS");
		 }
		 }
		 System.out.println("list:"+list);
		 System.out.println("-----------");

		// 2. 全部通过迭代器操
		ListIterator<String> lit = list.listIterator();
		while (lit.hasNext()) {
			String s = (String) lit.next();
			if ("hello".equals(s)) {
				lit.add("IOS");
			}
		}
		System.out.println("list:" + list);
	}
}

        运行结果如下:

二.  List的子类介绍：

      1. List三个子类特点：

                         List
                            |--ArrayList
                                        底层数据结构是数组，查询快，增删慢
                                        线程不安全，效率高
                            |--Vector
                                        底层数据结构是数组，查询快，增删慢
                                        线程安全，效率低
                            |--LinkedList
                                        底层数据结构是链表，查询慢，增删快
                                        线程不安全，效率高

        2. 案例：ArrayList存储自定义对象去重复 
             需求：ArrayList如果存储的是学生，那么，怎么去除重复元素呢？（如果学生的姓名和年龄相同，我就认为是同一个学生）

          (1).ListDemo类:

package testdemo;

import java.util.ArrayList;
import java.util.Iterator;

class ListDemo {
	public static void main(String[] args) {
		ArrayList<Student> array = new ArrayList<Student>();

		Student s1 = new Student("郑成功", 40);
		Student s2 = new Student("戚继光", 50);
		Student s3 = new Student("戚继光", 50);
		Student s4 = new Student("岳飞", 36);
		Student s5 = new Student("岳飞", 40);
		Student s6 = new Student("林则徐", 30);

		array.add(s1);
		array.add(s2);
		array.add(s3);
		array.add(s4);
		array.add(s5);
		array.add(s6);

		// 创建新集合
		ArrayList<Student> array2 = new ArrayList<Student>();

		// 遍历旧集合，获取到每一个元素
		Iterator<Student> it = array.iterator();
		while (it.hasNext()) {
			Student s = (Student) it.next();
			// 在新集合中判断，看是否存在这个元素
			if (!array2.contains(s)) {
				// 如果s不再array2中存在，就添加
				array2.add(s);
			}
		}

		// array2就是没有重复元素的集合。
		// 遍历array2
		for (int x = 0; x < array2.size(); x++) {
			Student s = (Student) array2.get(x);
			System.out.println(s.getName() + "***" + s.getAge());
		}
	}
}

          (2).Student类:

package testdemo;

public class Student {
	private String name;
	private int age;

	public Student() {
		super();
	}

	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Student other = (Student) 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;
	}

	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;
	}
}

        运行结果如下:

        2. Vector的特有功能:

             A：添加功能:  void addElement( Object obj )

             B：获取功能:  (1). public Object elementAt( int index )

                               (2). public Enumeration elements()

                               (3). 类Enumeration里边有两个方法。（类似于迭代器）
                                                       boolean hasMoreElements()
                                                       Object nextElement()
                               (4). public int size()

             C: 已经被ArrayList所代替,基本上很少用!

             D：功能小练习：

import java.util.Enumeration;
import java.util.Vector;

	public class VectorDemo {
		public static void main(String[] args) {
			// 创建集合对象
			Vector<String> v = new Vector<String>();

			// 添加元素
			v.addElement("hello");
			v.addElement("world");
			v.addElement("java");

			// 遍历
			for (int x = 0; x < v.size(); x++) {
				String s = (String) v.elementAt(x);
				System.out.println(s);
			}
			
			System.out.println("----------------");
			
			//public Enumeration elements()
			Enumeration<String> en = v.elements();
			while(en.hasMoreElements()){
				String s = (String)en.nextElement();
				System.out.println(s);
			}
		}
	}

        运行结果如下：

       3. LinkedList的特有功能:

                A：添加功能
                        void addFirst( Object o )：将指定元素插入此列表的开头。
                        void addLast( Object o )：将指定元素添加到此列表的结尾。
                B：获取功能
                        Object getFirst()：获取列表第一个元素
                        Object getLast()：获取列表最后一个元素
                C： 删除功能
                        Object removeFirst()：删除列表第一个元素
                        Object removeLast()：删除列表最后一个元素

          D：面试题：用LinkedList模拟栈数据结构

                         它的意思是说，你有一个LinkedList可以用，但是，你需要自己定义一个栈集合。
                         对外提供获取和添加功能。

          （1）. 创建LinkedListTest类：

package testdemo;

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

		// 创建集合对象
		MyStack ms = new MyStack();

		// 创建并添加元素
		ms.add("hello");
		ms.add("world");
		ms.add("java");

		for (int x = 0; x < ms.size(); x++) {
			String s = (String) ms.get(x);
			System.out.println(s);
		}
	}
}

          （2）. 创建LinkedListTest类：

package testdemo;

import java.util.LinkedList;

/*
 * 自定义栈集合。
 */
class MyStack {
	private LinkedList link;

	public MyStack() {
		link = new LinkedList();
	}

	public void add(Object obj) {
		link.addFirst(obj);
	}

	public Object get(int index) {
		return link.get(index);
	}

	public int size() {
		return link.size();
	}
}

        运行结果如下：