集合

1.1 为什么要使用集合框架？

传统的容器(数组)在进行增、删等破坏性操作时，需要移动元素，可能导致性能问题；同时添加、删除等算法和具体业务耦合在一起，增加了程序开发的复杂度。 

Java集合框架提供了一套性能优良、使用方便的接口和类，它们位于java.util包中

1.2 Collection

Collection是java集合框架(collection-frame)中的顶层接口。

Collection接口表示一个容器，容器中只能存储引用数据类型，建议存同一类型的引用类型，方便后续遍历等操作。

容器中的元素可以是有序的、可重复的，称为List接口

也可能是无序的、唯一的，称为Set接口。

 

1.2.1 集合常用方法

public static void main(String[] args) {

 

/**

 * 增:add/addAll

 * 删:clear/remove/removeAll/retainAll

 * 改:

 * 查:contains/containsAll/isEmpty/size

 */

 

Collection c1 = new ArrayList();

 

// 追加

c1.add("apple"); // Object object = new String("apple");

// c1.add(1);  // Object object = new Integer(1);

c1.add("banana");

System.out.println(c1);

 

// 追加一个集合

Collection c2 = new ArrayList();

c2.add("java");

c2.add("c++");

c1.addAll(c2);

System.out.println(c1);

 

// clear

//c1.clear();

 

// c1.remove("apple");

// c1.removeAll(c2);

//c1.retainAll(c2);

//System.out.println(c1);

 

System.out.println(c1.contains("apple"));

c2.add("js");

System.out.println(c1.containsAll(c2));

// c1.clear();

System.out.println(c1.isEmpty());

// 返回集合元素的个数

System.out.println(c1.size());

 

System.out.println(c1.equals(c2));

 

}

1.2.2 集合的遍历 

Iterable 可遍历的接口，集合接口继承于它，集合支持快速遍历。

// 快速遍历

// for-each

// Object 表示元素类型

// item表示迭代变量

// c1表示集合

for (Object item : c1) {

System.out.println(item.toString());

}

快速遍历的本质

Collection继承Iterable接口，表示集合支持快速遍历。Iterable接口定义了一个方法iterator()用于获取集合的迭代器，是一个Iterator接口类型，iterator()内部返回一个实现类实现类Iterator接口。这个实现类一定具有hasNext和next方法用于判断是否有下一个元素和获取下一个元素。快速遍历就是基于迭代器工作的。

public static void main(String[] args) {

 

 

Collection c1 = new ArrayList();

c1.add("apple");

c1.add("banana");

c1.add("coco");

 

 

// 快速遍历

// for-each

// Object 表示元素类型

// item表示迭代变量

// c1表示集合

for (Object item : c1) {

System.out.println(item.toString());

}

 

// 迭代器遍历（国内）

Iterator it = c1.iterator();

while(it.hasNext()) {

Object item = it.next();

System.out.println(item.toString());

}

 

// 国外

for(Iterator it2=c1.iterator();it2.hasNext();) {

Object item = it2.next();

System.out.println(item.toString());

}

}

1.3 List接口

List 接口中的元素时有序的、可重复的。List接口中的元素通过索引(index)来确定元素的顺序。

有序的 collection（也称为序列）。可以对列表中每个元素的插入位置进行精确地控制。用户可以根据元素的整数索引（在列表中的位置）访问元素，并搜索列表中的元素 

1.3.1 List常用方法

public static void main(String[] args) {

 

/**

 * 增:add/addAll/add(index,el)/addAll(index,collection)

 * 删:clear/remove/removeAll/remove(index)

 * 改:set(index,el)

 * 查:get(index)/indexOf/lastIndexOf()

 * 其他:contains/containsAll/isEmpty/size

 */

List list1 = new ArrayList();

// 添加元素

list1.add("apple");

list1.add("banana");

// 在指定位置添加元素

list1.add(0, "coco");

 

System.out.println(list1);

 

List list2 = new ArrayList();

list2.add("java");

list2.add("c++");

 

list1.addAll(1, list2);

System.out.println(list1);

 

// 删除

list1.remove(0);

System.out.println(list1);

 

// 修改

list1.set(0, "javax");

System.out.println(list1);

 

// 查

System.out.println(list1.get(0));

list1.add("apple");

list1.add("apple");

System.out.println(list1);

System.out.println(list1.indexOf("apple"));

System.out.println(list1.lastIndexOf("apple"));

}

1.3.2 List接口遍历 

ListIterator 继承于Iterator，在Iterator的基础上提供了以正向遍历集合，也可以以逆序遍历集合。

hasNext/next 以正向遍历

hasPrevious/previous 以逆序遍历

public static void main(String[] args) {

 

 

List list1 = new ArrayList();

list1.add("apple");

list1.add("banana");

list1.add("coco");

 

// 【1】快速遍历

System.out.println("--for each--");

for (Object item : list1) {

System.out.println(item.toString());

}

 

// 【2】普通for

System.out.println("--for--");

for(int i=0;i<list1.size();i++) {

System.out.println(list1.get(i));

}

 

// 【3】集合迭代器

System.out.println("--iterator--");

Iterator it = list1.iterator();

while(it.hasNext()) {

System.out.println(it.next());

}

 

System.out.println("--list iterator--");

// 正向遍历

ListIterator it2 = list1.listIterator();

while(it2.hasNext()) {

System.out.println(it2.next());

}

 

// 逆序遍历

while(it2.hasPrevious()) {

System.out.println(it2.previous());

}

 

System.out.println("--list iterator with index--");

ListIterator it3 = list1.listIterator(1);

while(it3.hasNext()) {

System.out.println(it3.next());

}

}

1.4 数据结构(补充) 

数据结构就是数据在内存中存储结构。根据存储的方式不同，分为线性表、二叉树、图、栈、队列等

1.4.1 线性表

线性表数据按照一定的逻辑顺序存储在内存中。线性表是有序的。线性表根据内存的物理结构分为两种:数组和链表

数组是一种逻辑上有序的线性表，物理上也连续。

链表是一种逻辑上有序的线性表，但物理上不连续。

数组和链表的区别 

相同点：逻辑上有序的线性表

不同点：

数组在查询时效率高，在添加、删除元素时效率低(涉及移动元素)

链表在查询时效率低(每次从头开始，不能跳跃访问)，在添加、删除元素时效率高(不涉及移动元素)

1.4.2 栈

特性:先进后出，后进先出

1.4.3 队列 

特性:先进先出

  

1.5 ArrayList/Vector

ArrayList 是List接口的实现类，底层数据结构是数组，实现大小可变的数组。

ArrayList 线程不安全，jdk1.2

ArrayList 底层数据结构是数组，默认数组大小是10,如果添加的元素个数超过默认容量，ArrayList会自动拓容，拓容原则:newCapacity = oldCapacity + oldCapacity / 2;

如果未来确定序列的元素不在增加，通过调用trimToSize()调制容量至合适的空间。

ArrayList作为List接口的实现类，常用方法和遍历方法参考List接口。

Vector 是List接口的实现类，底层数据结构也是数组，也是大小可变的数组。

Vector是线程安全的，jdk1.0

Vector底层数据结构是数组，默认数组大小是10,如果添加的元素个数超过默认容量，Vector会自动拓容，拓容原则:newCapacity = oldCapacity +capacityIncrement(增长因子);如果未来确定序列的元素不在增加，通过调用trimToSize()调制容量至合适的空间。

注意:Vector 在实现List接口的同时，同添加了自身特有的方法xxxElement,未来使用时为了程序的可拓展性，一定要按照接口来操作Vector。

1.6 LinkedList

LinkedList是List接口的实现类，底层数据结构是链表。

LinekList常用方法和遍历方法参照List接口。

LinkedList 线程不安全

除了实现List接口， 还实现栈接口

push入栈操作 / pop出栈操作

public class Test01 {

public static void main(String[] args) {

LinkedList list = new LinkedList();

list.push("apple");

list.push("banana");

list.push("coco");

 

 

System.out.println(list.pop());

System.out.println(list.pop());

System.out.println(list.pop());

 

// java.util.NoSuchElementException

System.out.println(list.pop());

}

}

队列(Queue)接口

add/remove/element() 可能会出现NoSuchElementException异常 

public static void main(String[] args) {

 

LinkedList queue = new LinkedList();

// 入队

/**

 * 队列头                   队列尾

 *<-----          <-----

 * [apple, banana, coco]

 */

queue.add("apple");

queue.add("banana");

queue.add("coco");

System.out.println(queue);

 

// 出队

System.out.println(queue.remove());

System.out.println(queue.remove());

System.out.println(queue.remove());

System.out.println(queue);

 

// java.util.NoSuchElementException

System.out.println(queue.remove());

 

 

// 获取表头元素

System.out.println(queue.element());

}

offer/poll/peek 可能会返回特殊值(null) 

public static void main(String[] args) {

 

LinkedList queue = new LinkedList();

// 入队

/**

 * 队列头                   队列尾

 *<-----          <-----

 * [apple, banana, coco]

 */

queue.offer("apple");

queue.offer("banana");

queue.offer("coco");

 

// 出队列

//System.out.println(queue.poll());

//System.out.println(queue.poll());

//System.out.println(queue.poll());

System.out.println(queue);

 

//System.out.println(queue.poll());

 

// 获取表头元素

System.out.println(queue.peek());

 

}

双向队列(Deque)接口

/**

 * 以双向队列形式操作LinkedList

 */

public class Test04 {

public static void main(String[] args) {

 

LinkedList queue = new LinkedList();

// 入队

/**

 *<-----          <-----

 * [apple, banana, coco]

 * ---->          ----->

 */

 

queue.addFirst("apple");

queue.addFirst("banana");

queue.addFirst("coco");

System.out.println(queue);

 

System.out.println(queue.removeLast());

System.out.println(queue.removeFirst());

System.out.println(queue.removeFirst());

System.out.println(queue);

 

// 获取头元素

System.out.println(queue.getFirst());

 

}

}  

1.7 Iterator和ListIterator

Iterator在迭代过程中不允许向集合中添加元素

public static void main(String[] args) {

ArrayList list = new ArrayList();

list.add("apple");

list.add("banana");

list.add("coco");

 

Iterator it = list.iterator();

while(it.hasNext()) {

String item = (String) it.next();

if(item.equals("banana")) {

list.add("test");

}

}

 

System.out.println(list);

}

 当通过Iterator集合迭代器遍历集合过程中，不能再向集合汇总添加元素，否则出现ConcurrentModificationException 并发修改异常。

ListIterator允许程序员按任一方向遍历列表、迭代期间修改列表，并获得迭代器在列表中的当前位置

public class Test01 {

public static void main(String[] args) {

ArrayList list = new ArrayList();

list.add("apple");

list.add("banana");

list.add("coco");

 

ListIterator it = list.listIterator();

while(it.hasNext()) {

String item = (String) it.next();

if(item.equals("banana")) {

it.add("test");

}

}

 

System.out.println(list);

}

}