Java List集合

最新推荐文章于 2021-06-12 12:13:11 发布

djfengqiang

最新推荐文章于 2021-06-12 12:13:11 发布

阅读量976

点赞数

分类专栏： JAVA

本文链接：https://blog.csdn.net/djfengqiang/article/details/16852391

版权

JAVA 专栏收录该内容

34 篇文章 0 订阅

订阅专栏

·List列表

·list: list代表有序集合，每个元素都有对应的索引，所以List集合中的元素可以重复。

·list当然也用于collection中的所有方法，并且自己也有添加了额外的方法，所有List实现类都可以调用这些方法来操作元素。List集合可以根据索引来操作元素。

a) ： void add(int index, Object element) 将element插入index位置。

b) ： boolean addAll(int index, Collection c) 将集合c所有的元素插入到index位置处

c) ： Object get(int index) 返回index出的元素。

d) ： int indexOf(Object o) 返回对象o处于哪个索引位置。

e) ： int lastIndexOf(Object o) 返回的最后面的对象o处于哪个索引位置。

f) ： Object remove(int index) 删除index索引处的元素。

g) : Object set(int index, Object element) 将index索引处的内容替换为element。

h) : List subList(int fromIndex, int toIndex)返回从索引fromIndex处的内容到toIndex索引（不包含）处的子集合。

·上述方法例子：

import java.util.*;

public class ListTest
{
	public static void main(String[] args)
	{
		List l = new ArrayList();
		l.add("a");
		l.add("b");
		l.add("c");
		l.add("a");
		System.out.println(l);

		l.add(1, "ok");
		System.out.println(l);

		l.remove(1);
		System.out.println(l);

		System.out.println(l.indexOf("a"));
		System.out.println(l.lastIndexOf("a"));

		System.out.println(l.subList(0,2));
	}
}

+++++++输出结果+++++++

[a, b, c, a]
[a, ok, b, c, a]
[a, b, c, a]
0
3
[a, b]

·List比较两个对象相等的规则是：通过equals方法比较两个对象返回true则判定两个对象相等。

例子：

import java.util.*;

class A
{
	public boolean equals(Object obj)
	{
		return true;
	}
}

public class TestList2
{
	public static void main(String[] args)
	{
		List l = new ArrayList();
		l.add("a");
		l.add("b");
		l.add("c");
		l.add("d");

		System.out.println(l);

		l.remove(new A());	//用A对象的equals方法与l集合中从第一个元素开始对比，如果结果falas则比较下一个，为ture则删除该元素。
		System.out.println(l);

		l.remove(new A());
		System.out.println(l);
	}
}

++++++++++++++++++输出结果+++++++++++++++++++++++
[a, b, c, d]
[b, c, d]
[c, d]

·List的listIterator()方法，这个方法属于ListIterator接口，与iterator很类似，只不过ListIterator增加了向前迭代的方法，而Iterator接口提供的iterator()方法只能向后迭代。

ListIterator抽象类的listIterator()方法

a)boolean hasPrevious() : 如果集合中还有上一个元素。

b)Object previous() ：返回迭代器的上一个元素。

voidadd() ：在指定位置插入一个元素。

例子：

import java.util.*;

public class ListTest3
{
	public static void main(String[] args)
	{
		String[] s = {"a","b","c"};
		List l = new ArrayList();
		for(int i = 0; i < s.length; i++)
		{
			l.add(s[i]);
		}

		ListIterator li = l.listIterator();

		while(li.hasNext())
		{
			System.out.println(li.next());
		}

		System.out.println("---next() and previous()---");

		while(li.hasPrevious())
		{
			System.out.println(li.previous());
		}
	}
}

+++++++++++++++++++++++结果+++++++++++++++++++++++++

a
b
c
---next() and previous()---
c
b
a

·ArrayList

·ArrayList底层采用数组实现，使用不带参数构造器生活一个ArrayList对象时，实际上会在底层生成一个长度为10的Object类型的数组。

·如果增加的元素个数超过了10个，那么ArrayList底层会生成一个新的数组，长度为原数组的1.5倍加1，然后将原来数组中的内容全部复制到这个新生成的大数组中，并且后续增加的内容也放到这个数组中。当这个新的数组无法容纳增加的元素时，然后再重复该过程。

·对于ArrayList集合的删除操作，需要将后续的所有元素向前移，所以代价比较高。

·对于ArrayList集合的插入操作，需要将后续的元素向后移，所以代价也很高。

·但是ArrayList集合对于查找操作，性能很好，因为它是根据索引来定位的。

·LinkedList

·LinkedList底层采用双向链表实现。双向链表就是一个数据既有前驱也有后继，如果知道这个元素那么就能找到它的前驱和后继一次类推。这中方式的优势就是插入数据，删除数据代价小，只要把前一个元素的后继和后一个元素的前驱指针指向这个数据就可以了，但是查找性能不好，因为要进行所有元素的遍历才能找到数据。

·LinkedList也继承与List所以具有List列表的所有方法，但是它还是一个双向列表，它还实现Deque接口，所以它就是双向列表双端队列，自然它就有一些额外的方法提供插入数据用处。

a) :void addFirst(Object e) 将e对象插入到双端队列开头。

b) :void addLast(Object e) 将e对象插入到双端队列尾部。

b1)boolean add(E e): 将指定元素添加到此列表的末尾

c) :boolean offerFirst(Object e) 将e对象插入到双端队列开头。

d) :boolean offerLast(Object e) 将额对象插入到双端队列尾部。

d1): boolean offer(E e) 将指定元素添加到此列表的末尾

e) :Iterator descendingIterator() 返回该双端队列的迭代器，该迭代器以descend的顺序进行迭代。

f) :Object getFirst() 获取开头元素，但不删除元素。

g) :Object getLast() 获取尾部元素，但不删除元素。

h) :Object peekFirst() 获取开头的元素，但不删除元素。

i) :Object peekLast()获取尾部元素，但不删除元素。