一、list接口

1、基本概念
List接口中的数据对象有索引，存入的数据有顺序，并且元素可以重复。

2、List方法摘要

boolean add(Object e); 向列表的尾部添加指定的元素（可选操作）。
void add(int index, Object element); 在列表的指定位置插入指定元素（可选操作）。
void clear(); 从列表中移除所有元素（可选操作）。
boolean contains(Object o); 如果列表包含指定的元素，则返回 true。
boolean containsAll(Collection<?> c); 如果列表包含指定 collection 的所有元素，则返回 true。
boolean equals(Object o); 比较指定的对象与列表是否相等。
Object get(int index); 返回列表中指定位置的元素。
int hashCode(); 返回列表的哈希码值。
int indexOf(Object o); 返回此列表中第一次出现的指定元素的索引；如果此列表不包含该元素，则返回 -1。
boolean isEmpty(); 如果列表不包含元素，则返回 true。
Iterator<Object > iterator(); 返回按适当顺序在列表的元素上进行迭代的迭代器。
int lastIndexOf(Object o); 返回此列表中最后出现的指定元素的索引；如果列表不包含此元素，则返回 -1。
ListIterator<Object > listIterator(); 返回此列表元素的列表迭代器（按适当顺序）。
ListIterator<Object > listIterator(int index); 返回列表中元素的列表迭代器（按适当顺序），从列表的指定位置开始。
Object remove(int index); 移除列表中指定位置的元素（可选操作）。
boolean remove(Object o); 从此列表中移除第一次出现的指定元素（如果存在）（可选操作）。
boolean removeAll(Collection<?> c); 从列表中移除指定 collection 中包含的其所有元素（可选操作）。
boolean retainAll(Collection<?> c); //仅在列表中保留指定 collection 中所包含的元素（可选操作）。
Object set(int index, Object element); //用指定元素替换列表中指定位置的元素（可选操作）。
int size(); //返回列表中的元素数。
List<Object > subList(int fromIndex, int toIndex); //返回列表中指定的开始位置和结束位置之间的部分视图（包前不包后）。
Object[] toArray() //返回按适当顺序包含列表中的所有元素的数组（从第一个元素到最后一个元素）。

3、List集合特有的迭代器：ListIterator是Iterator的子接口
（1）在迭代时，不可以通过集合对象的方法操作集合中的元素，因为会发生ConcurrentModificationException异常。所以，在迭代时只能用迭代器的方法操作元素，但Iterator方法是有限的，如果想要其他操作，就需要其子接口ListIterator。

（2）ListDemo：生成10个1至100之间的不重复的随机整数，存入List集合并排序后输出。

public class ListDemo {
	public static void main(String[] args) {
		List<Integer> list = new ArrayList<Integer>();
		for(int i = 0; list.size()< 10; i++) {
			int num = (int) (Math.random() * 100 +1);
			if(!list.contains(num)) {
				list.add(num);
			}
		}
		//排序第一种
		for(int i = 0; i < list.size() - 1; i++) {
			for(int j = 0; j < list.size() - 1 - i; j++) {
				if(list.get(j) > list.get(j + 1)) {
					int temp = list.get(j);
					list.set(j,list.get(j + 1)) ;
					list.set(j + 1,temp) ;
				}
			}
		}
		//排序第二种（默认升序）
//		Collections.sort(list);

		//直接输出toString()方法
		System.out.println(list.toString());
		//迭代器输出
		Iterator it = list.iterator();
		while(it.hasNext()) {
			System.out.print(it.next() + " ");
		}
	}
}
得到结果为：
[3, 13, 19, 32, 34, 50, 57, 63, 74, 99]
3 13 19 32 34 50 57 63 74 99

二、LinkedList类

1、基本概念
LinkedList实现了List接口，其底层存储数据使用的是链表结构（单链表、双链表、循环链表）。LinkedList对数据的查询和修改效率低，增加和删除效率高。

2、LinkedList方法摘要

boolean add(Object e); 将指定元素添加到此列表的结尾。
void add(int index, Object element); 在此列表中指定的位置插入指定的元素。
void addFirst(Object e); 将指定元素插入此列表的开头。
void addLast(Object e); 将指定元素添加到此列表的结尾。
void clear(); 从此列表中移除所有元素。
Object clone(); 返回此 LinkedList 的浅表副本。
boolean contains(Object o); 如果此列表包含指定元素，则返回 true。
Iterator<Object > descendingIterator(); 返回以逆向顺序在此双端队列的元素上进行迭代的迭代器。
Object element(); 获取但不移除此列表的头（第一个元素）。
Object get(int index); 返回此列表中指定位置处的元素。
Object getFirst(); 返回此列表的第一个元素。
Object getLast(); 返回此列表的最后一个元素。
int indexOf(Object o); 返回此列表中首次出现的指定元素的索引，如果此列表中不包含该元素，则返回 -1。
int lastIndexOf(Object o); 返回此列表中最后出现的指定元素的索引，如果此列表中不包含该元素，则返回 -1。
ListIterator<Object > listIterator(int index); 返回此列表中的元素的列表迭代器（按适当顺序），从列表中指定位置开始。
boolean offer(Object e); 将指定元素添加到此列表的末尾（最后一个元素）。
boolean offerFirst(Object e); 在此列表的开头插入指定的元素。
boolean offerLast(Object e); 在此列表末尾插入指定的元素。
Object peek(); 获取但不移除此列表的头（第一个元素）。
Object peekFirst(); 获取但不移除此列表的第一个元素；如果此列表为空，则返回 null。
Object peekLast(); 获取但不移除此列表的最后一个元素；如果此列表为空，则返回 null。
Object poll(); 获取并移除此列表的头（第一个元素）
Object pollFirst(); 获取并移除此列表的第一个元素；如果此列表为空，则返回 null。
Object pollLast(); 获取并移除此列表的最后一个元素；如果此列表为空，则返回 null。
Object remove(); 获取并移除此列表的头（第一个元素）。
Object remove(int index); 移除此列表中指定位置处的元素。
boolean remove(Object o); 从此列表中移除首次出现的指定元素（如果存在）。
Object removeFirst(); 移除并返回此列表的第一个元素。
boolean removeFirstOccurrence(Object o); 从此列表中移除第一次出现的指定元素（从头部到尾部遍历列表时）。
Object removeLast(); 移除并返回此列表的最后一个元素。
boolean removeLastOccurrence(Object o); 从此列表中移除最后一次出现的指定元素（从头部到尾部遍历列表时）。
Object set(int index, Object element);` 将此列表中指定位置的元素替换为指定的元素。
int size(); 返回此列表的元素数。
Object[] toArray(); 返回以适当顺序（从第一个元素到最后一个元素）包含此列表中所有元素的数组。

3、LinkedList特有的方法addFirst()，addLast()，removeFirst()，removeLast()
（1）addFirst()每次添加元素会添加到现有所有元素的最前前；
addLast()每次添加元素会添加到现有所有元素的最后面。

public class Demo{
	public static void main(String[] args) {
		LinkedList link = new LinkedList();
		link.addFirst(1);
		link.addFirst(2);
		link.addFirst(3);
		link.addFirst(4);
		System.out.println(link);
		link.addLast(5);
		link.addLast(6);
		link.addLast(7);
		link.addLast(8);
		System.out.println(link);
	}
}
//得到结果如下
[4, 3, 2, 1]
[4, 3, 2, 1, 5, 6, 7, 8]

（2）removeFirst()每次获取集合中的第一个元素并删除
removeLast()每次获取集合中的最后一个元素并删除

public class Demo{
	public static void main(String[] args) {
		LinkedList link = new LinkedList();
		link.addFirst(1);
		link.addFirst(2);
		link.addFirst(3);
		link.addFirst(4);
		while( !link.isEmpty()) {
			System.out.println(link.removeFirst());
		}
		System.out.println(link);
	}
}

三、ArrayList类

1、基本概念
ArryList实现了List接口，其底层存储数据使用的是数组结构，是线程不安全的。ArryList对数据的查询和修改效率高，增加和删除效率低。

2、 ArryList主要方法摘要

boolean add(Object e); 将指定元素添加到此列表的结尾。
void add(int index, Object element); 在此列表中指定的位置插入指定的元素。
void clear(); 从此列表中移除所有元素。
Object clone(); 返回此 LinkedList 的浅表副本。
boolean contains(Object o); 如果此列表包含指定元素，则返回 true。
void ensureCapacity(int minCapacity); 如有必要，增加此 ArrayList 实例的容量，以确保它至少能够容纳最小容量参数所指定的元素数。
Object get(int index); 返回此列表中指定位置上的元素。
int indexOf(Object o); 返回此列表中首次出现的指定元素的索引，如果此列表中不包含该元素，则返回 -1。
boolean isEmpty(); 如果此列表中没有元素，则返回 true
int lastIndexOf(Object o); 返回此列表中最后出现的指定元素的索引，如果此列表中不包含该元素，则返回 -1。
E remove(int index); 移除此列表中指定位置上的元素。
boolean remove(Object o); 移除此列表中首次出现的指定元素（如果存在）。
protected void removeRange(int fromIndex, int toIndex); 移除列表中从开始位置到结束位置之间的所有元素（包前不包后）。
E set(int index, E element); 用指定的元素替代此列表中指定位置上的元素。
int size(); 返回此列表中的元素数。
Object[] toArray(); 按适当顺序（从第一个到最后一个元素）返回包含此列表中所有元素的数组。

3、示例
（1）示例1：ArrayList遍历

public class ArrayListDemo{
	public static void main(String[] args) {
	    List<String> list=new ArrayList<String>();
	     list.add("张三");
	     list.add("李四");
	     list.add("王五");
	     
	     //第一种遍历方法使用foreach遍历List
	      //也可以改写for(int i=0;i<list.size();i++)这种形式
	     for (String str : list) { 
	        System.out.println(str);
	     }
	 
	     //第二种遍历，把链表变为数组相关的内容进行遍历
	     String[] strArray=new String[list.size()];
	     list.toArray(strArray);
	     //可以改写为  foreach(String str:strArray)这种形式
	     for(int i=0;i<strArray.length;i++){
	        System.out.println(strArray[i]);
	     }
	     
	    //第三种遍历 使用迭代器进行相关遍历
	     Iterator<String> ite=list.iterator();
	     while(ite.hasNext()){
	         System.out.println(ite.next());
	     }
	}
}

（2）示例2：从键盘输入一行字符串，去除重复的字符

public class Test3 {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入一个任意字符串：");
		String str = sc.next();
		List list = new ArrayList();
		for(int i = 0; i < str.length(); i++) {
			String s = String.valueOf(str.charAt(i));
				if(!list.contains(s)) {
					list.add(s);
				}
		}
		String str1 = "";
		Iterator it = list.iterator();
		while(it.hasNext()) {
			str1 = str1 + it.next();
		}
		System.out.println("去重后的字符串" + str1);
	}
}

四、Vector类

1、基本概念
Vector实现了List接口，其底层使用的是数组结构，线程同步是线程安全的。Vector对数据的增删查询都慢。

2、Vector方法摘要

boolean add(Object e); 将指定元素添加到此列表的结尾。
void add(int index, Object element); 在此列表中指定的位置插入指定的元素。
boolean addAll(Collection<? extends E> c); 添加指定 collection 中的所有元素到此列表的结尾，顺序是指定 collection 的迭代器返回这些元素的顺序。
boolean addAll(int index, Collection<? extends E> c); 将指定 collection 中的所有元素从指定位置开始插入此列表。
void addElement(E obj); 将指定的组件添加到此集合的末尾，将其大小增加 1。
int capacity(); 返回此集合的当前容量。
void clear(); 从此列表中移除所有元素。
Object clone(); 返回此 LinkedList 的浅表副本。
boolean contains(Object o); 如果此列表包含指定元素，则返回 true。
boolean containsAll(Collection<?> c); 如果此集合包含指定 Collection 中的所有元素，则返回 true。
void copyInto(Object[] anArray); 将此集合的组件复制到指定的数组中。
Object elementAt(int index); 返回指定索引处的组件。
Enumeration<Object > elements(); 返回此集合的组件的枚举。
void ensureCapacity(int minCapacity); 如有必要，增加此 ArrayList 实例的容量，以确保它至少能够容纳最小容量参数所指定的元素数。
boolean equals(Object o); 比较指定对象与此向量的相等性。
Object firstElement(); 返回此集合的第一个组件（位于索引 0) 处的项）。
Object get(int index); 返回此列表中指定位置上的元素。
int hashCode(); 返回此集合的哈希码值。
int indexOf(Object o); 返回此列表中首次出现的指定元素的索引，如果此列表中不包含该元素，则返回 -1。
int indexOf(Object o, int index); 返回此集合中第一次出现的指定元素的索引，从 index 处正向搜索，如果未找到该元素，则返回 -1。
void insertElementAt(E obj, int index); 将指定对象作为此集合中的组件插入到指定的 index 处。
boolean isEmpty(); 测试此集合是否不包含组件。
Object lastElement(); 返回此集合的最后一个组件。
int lastIndexOf(Object o); 返回此集合中最后一次出现的指定元素的索引；如果此集合不包含该元素，则返回 -1。
int lastIndexOf(Object o, int index); 返回此集合中最后一次出现的指定元素的索引，从 index 处逆向搜索，如果未找到该元素，则返回 -1。
Object 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 中移除指定开始位置到结束位置之间的所有元素（包前不包后）。
boolean retainAll(Collection<?> c); 确保该集合仅保留包含在指定 Collection 中的元素。
Object set(int index, E element); 用指定的元素替换此集合中指定位置处的元素。
int size(); 返回此向量中的组件数。
List<Object subList(int fromIndex, int toIndex); 返回此 List 的部分视图，元素范围为指定开始位置到结束位置之间的所有元素（包前不包后）。
Object[] toArray(); 返回一个数组，包含此集合中以恰当顺序存放的所有元素。
String toString(); 返回此集合的字符串表示形式，其中包含每个元素的 String 表示形式。

3、其特有的取出方式：枚举Enumeration。
Enumeration枚举Demo：

public class EnumerationDemo{
	public static void main(String[] args) {
		Vector v = new Vector();
		v.add(1);
		v.add(2);
		v.add(3);
		v.add(4);
		Enumeration en = v.elements();
		while(en.hasMoreElements()) {
			System.out.print(en.nextElement() + " ");
		}
	}
}
得到结果：
1 2 3 4

三块五的海景房

发布了40 篇原创文章 · 获赞 0 · 访问量 360

私信关注

JAVA SE（十四）—— JAVA 集合框架2（list接口、LinkedList类、ArrayList类、Vector类）

文章目录

一、list接口

二、LinkedList类

三、ArrayList类

四、Vector类

猜你喜欢