一、集合框架
1.数组和集合都是容器，两者有什么区别呢？
数组长度是固定的，数组可以存储对象，可以存储基本数据类型。
集合长度是可变的，集合只能存储对象。
2.为什么出现这么多容器呢？
因为每一个容器对数据的存储方式不一样，这个存储方式被称为数据结构。
二、常用方法
2.1 增加、删除
import java.util.*;
/*
1，add方法的参数类型是Object。以便接收任意类型对象。
2，集合中存储的都是对象的引用（地址）。
*/
public class CollectionTest {
public static void main(String[] args) {
//创建一个集合容器，使用Collection接口的子类:Arraylist。
ArrayList<String> al = new ArrayList<String>();
//1.添加元素
al.add("java01"); //add(Object o);
al.add("java02");
al.add("java03");
al.add("java04");
//2.获取个数。集合长度。
System.out.println("size:"+al.size());
//3.删除元素。
al.remove("java01");
//al.clear();
//4.判断元素
System.out.println("java03是否存在:" + al.contains("java03"));
System.out.println("al是否为空:" + al.isEmpty());
//打印集合。
System.out.println(al);
}
}
运行结果：
size:4
java03是否存在:true
al是否为空:false
[java02, java03, java04]
2.2 取交集、差集
public static void method1() {
ArrayList<String> al1 = new ArrayList<String>();
al1.add("java01");
al1.add("java02");
al1.add("java03");
al1.add("java04");
ArrayList<String> al2 = new ArrayList<String>();
al2.add("java01");
al2.add("java02");
al2.add("java07");
al2.add("java08");
// al1.retainAll(al2); //取交集，al1中只会保留与al2中相同的元素。
// System.out.println(al1);
// System.out.println(al2);
al1.removeAll(al2);
System.out.println(al1);
System.out.println(al2);
}
retainAll运行结果：
[java01, java02]
[java01, java02, java07, java08]
removeAll运行结果：
[java03, java04]
[java01, java02, java07, java08]
2.3 元素的取出
public void get_method() {
ArrayList al = new ArrayList();
al.add("java01");
al.add("java02");
al.add("java03");
al.add("java04");
Iterator it = al.iterator(); //迭代器
while(it.hasNext()) {
System.out.println(it.next());
}
}
运行结果：
java01
java02
java03
java04
或者也可以这样写：
for(Iterator it = al.iterator();it.hasNext();) {
System.out.println(it.next());
}
三、List
3.1 list常见操作
package com.collection;
/*
* Collection
* |--List:元素有序。元素可以重复。因为该集合体系有索引。
* |--Set:元素无序。元素不可以重复。
*
* List：
* 特有方法：凡是可以操作角标的方法都是该体系特有的方法。
*
* 增：
* add(index,element);
* addAll(index,Collection);
* 删:
* remove(index);
* 改:
* set(index,element);
* 查:
* get(index);
* subList(from,to);
* listIterator();
* */
import java.util.*;
public class ListDemo {
public static void main(String[] args) {
ArrayList al = new ArrayList();
al.add("java01");
al.add("java02");
al.add("java03");
System.out.println("原集合是："+al); //原集合是：[java01, java02, java03]
//在指定位置添加元素
al.add(1, "java8");
System.out.println("在指定位置添加元素后："+al); //在指定位置添加元素后：[java01, java8, java02, java03]
//删除指定位置的元素
al.remove(2);
System.out.println("删除指定位置的元素后："+al); //删除指定位置的元素后：[java01, java8, java03]
//修改元素
al.set(1, "java007");
al.add("java009");
al.add("java009");
al.add("java009");
System.out.println("修改元素后："+al); //修改元素后：[java01, java007, java03, java009, java009, java009]
//通过角标获取元素
System.out.println("获取元素："+al.get(1)); //获取元素：java007
//获取所有元素
for(int i=0; i<al.size();i++) {
System.out.println("al("+i+"):"+al.get(i));
}
//通过迭代器获取所有元素
for(Iterator it = al.iterator();it.hasNext();) {
System.out.println(it.next());
}
//通过indexof获取对象位置
System.out.println(al.indexOf("java007")); //1
System.out.println(al.lastIndexOf("java009")); //5
List sub = al.subList(1, 4); // 包括开始，不包括结尾
System.out.println("subList = " + sub); //subList = [java007, java03, java009]
}
}
3.2 列表迭代器
import java.util.*;
public class ListDemo {
public static void main(String[] args) {
//演示列表迭代器
ArrayList al = new ArrayList();
al.add("java01");
al.add("java02");
al.add("java03");
Iterator it = al.iterator();
// while(it.hasNext()){
// System.out.println(it.next());
// }
//在迭代过程中准备添加或者删除元素
while(it.hasNext()){
Object obj = it.next();
if(obj.equals("java02"))
al.add("java000");
System.out.println("obj = " + obj);
}
}
}
运行结果：
Exception in thread "main" java.util.ConcurrentModificationException
at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:901)
at java.util.ArrayList$Itr.next(ArrayList.java:851)
at com.collection.ListDemo.main(ListDemo.java:44)
obj = java01
obj = java02
并发修改异常。
在用迭代器操作时，又用了集合的操作。
3.2.1 使用迭代器操作（局限性：只能删除）
//在迭代过程中准备添加或者删除元素
while(it.hasNext()){
Object obj = it.next();
if(obj.equals("java02"))
it.remove(); //将java02的引用从集合中删除
System.out.println("obj = " + obj);
}
System.out.println(al);
运行结果：
obj = java01
obj = java02
obj = java03
[java01, java03]
3.2.2 ListIterator
/*
* List集合特有的迭代器：ListIterator。
* ListIterator是Iterator的子接口。在迭代时，不可以通过集合对象的方法操作集合中的元素。
* 因为会发生ConcurrentModificationException异常。
*
* 所以，在迭代时，只能使用迭代器的方法操作元素。
* 可是Iterator方法有限，只能对元素进行判断、取出、删除的操作。
* 如果想要其他操作，比如添加、修改等，就需要使用其子接口，ListIterator。
*
* 该接口只能通过List集合的listIterator()方法调用。
* */
public static void main(String[] args) {
//演示列表迭代器
ArrayList al = new ArrayList();
al.add("java01");
al.add("java02");
al.add("java03");
al.add("java008");
ListIterator li = al.listIterator();
while(li.hasNext()){
Object obj = li.next();
if(obj.equals("java02"))
li.add("java009");
}
System.out.println(al);
}
运行结果：
[java01, java02, java009, java03, java008]
3.2.3 ListIterato API
3.3 List常见的子类对象
/* * Collection * |--List:元素有序。元素可以重复。因为该集合体系有索引。 * |--ArrayList : 底层数据结构是数组结构。 特点：查询、修改速度很快。增加、删除速度很慢。 线程不同步。 * |--LinkedList ： 底层数据结构是链表结构。 特点：增删速度很快，查询稍慢。 * |--Vector ： 底层是数组数据结构。线程同步。被ArrayList替代了。 * * |--Set:元素无序。元素不可以重复。 * * */
3.4 Vector
/*
* 枚举是Vector特有的取出方式。
* 枚举和迭代器很像。
*
* 其实枚举和迭代器一样。
* 因为枚举的名称和方法名都过长，所以被迭代器取代。
* */
public class VectorDemo {
public static void main(String[] args) {
Vector v = new Vector();
v.add("java01");
v.add("java02");
v.add("java03");
Enumeration en = v.elements();
while(en.hasMoreElements()){
System.out.println(en.nextElement());
}
}
}
3.5 LinkedList
3.5.1 LinkedList特有方法
package com.collection;
import java.util.*;
/*
* LinkedList特有方法：
* addFirst(E e);
* addLast(E e);
*
* getFirst();
* getLast();
* 获取元素但不删除元素。如果集合中没有元素，NoSuchElementException。
*
* removeFirst();
* removeLast();
* 获取元素删除元素。如果集合中没有元素，NoSuchElementException。
*
* 在JDK1.6出现了替代方法
* offerFirst(E e);
* offerLast(E e);
* 插入元素
*
* peekFirst();
* peekLast();
* 检索但不删除元素。如果此列表为空，则返回 null 。
*
* pollFirst();
* pollLast();
* 检索并删除元素。如果此列表为空，则返回 null 。
* */
public class LinkedListDemo {
public static void main(String[] args) {
LinkedList link = new LinkedList();
link.addFirst("java01");
link.addFirst("java02");
link.addFirst("java03");
link.addFirst("java04");
System.out.println(link); //[java04, java03, java02, java01]
System.out.println(link.getFirst()); //java04
System.out.println(link.getLast()); //java01
System.out.println(link.removeFirst()); //java04
System.out.println(link); //[java03, java02, java01]
while(!link.isEmpty()){
link.removeFirst();
}
}
}
3.5.1 LinkedList练习
import java.util.*;
/*
* 使用LinkedList模拟堆栈或者队列数据结构
*
* 堆栈：先进后出。如同杯子。
* 队列：先进先出。如同水管。
*
* */
public class LinkedListTest {
public static void main(String[] args) {
Queue q1 = new Queue();
q1.myAdd("java01");
q1.myAdd("java02");
q1.myAdd("java03");
q1.myAdd("java04");
while(!q1.isNull()){
System.out.println(q1.myGet());
}
}
}
class Queue{
private LinkedList link;
Queue(){
link = new LinkedList();
}
public void myAdd(Object obj){
link.addFirst(obj);
}
public Object myGet(){
return link.removeLast();
}
public boolean isNull(){
return link.isEmpty();
}
}
3.5.2 LinkedList API
3.6 ArrayList
import java.util.*;
/*
* 去除ArrayList集合中的重复元素
* */
public class ArrayListTest {
public static void main(String[] args) {
ArrayList al = new ArrayList();
al.add("aaa");
al.add("bbb");
al.add("bbb");
al.add("def");
al.add("ggg");
singleElement(al); //[aaa, bbb, def, ggg]
}
public static void singleElement(ArrayList al){
//定义一个临时容器
ArrayList al1 = new ArrayList();
ListIterator li = al.listIterator();
while(li.hasNext()){
Object obj = li.next();
if(al1.indexOf(obj) == -1){
al1.add(obj);
}
}
System.out.println(al1);
}
}
import java.util.*;
/*将自定义对象存入ArrayList中，并删除重复元素*/
public class ArrayListTest2 {
public static void main(String[] args) {
ArrayList<Person> al = new ArrayList<Person>();
al.add(new Person("张三",20));
al.add(new Person("李四",25));
al.add(new Person("王五",21));
al.add(new Person("李四",25));
ArrayList newAl = singleElement(al);
Iterator<Person> it = newAl.iterator();
while(it.hasNext()){
Person p = it.next();
System.out.println(p.getName() + "::" + p.getAge());
}
}
public static ArrayList singleElement(ArrayList al){
//定义一个临时容器
ArrayList al1 = new ArrayList();
ListIterator li = al.listIterator();
while(li.hasNext()){
Object obj = li.next();
if(!al1.contains(obj)){
al1.add(obj);
}
}
return al1;
}
}
class Person{
private String name;
private int age;
Person(String name,int age){
this.name = name;
this.age = age;
}
public void setName(String name) {
this.name = name;
}
public void setAge(int age) {
this.age = age;
}
public String getName(){
return name;
}
public int getAge(){
return age;
}
public boolean equals(Object obj){
if(!(obj instanceof Person))
return false;
Person p = (Person)obj;
return p.name.equals(this.name) && p.age == this.age;
}
}
运行结果：
张三::20
李四::25
王五::21
contains实际上是调用对象的equals方法。
结论：
List集合判断元素是否相同，依据的是元素的equals方法。
其他：
remove、indexof底层其实用的也是元素的equals方法。
ArrayList API
