Java学习之路（三十八）| 集合（一）——Collection类、List类

各自努力，最高处见！加油！

一、集合体系图

二、Collection类

1、Collection接口实现类的特点

public interface Collection<E> extends Iterable <E>

1. Collection实现子类可以存放多个元素，每个元素可以是Object。
2. 有些Collection的实现类，可以存放重复的元素，有些不可以。
3. 有些Collection的实现类是有序的（List），有些不是有序（Set）。
4. Collection接口没有直接的实现子类，是通过它的子接口Set和List来实现的。

2、Collection常用方法

1. add:添加单个元素
2. remove:删除指定元素
3. contains:查找元素是否存在
4. size:获取元素个数
5. isEmpty:判断是否为空
6. clear:清空
7. addAll:添加多个元素
8. contains:查找多个元素是否都存在
9. removeAll:删除多个元素

3、Collection接口——Iterator接口

Collection接口遍历元素方式 1---->使用Iterator迭代器

1. Iterator对象称为迭代器，主要用于遍历Collection集合中的元素
2. 所有实现了Collection接口的集合类都有一个iterator()方法，用以返回一个实现了Iterator接口的对象，即可以返回一个迭代器。
3. Iterator的结构
4. Iterator仅用于遍历集合，Iterator本身并不存放对象。

迭代器的执行原理

Iterator iterator = coll.iterator();//得到一个集合的迭代器
while(iterator.hasNext()){//下移，将下移以后集合位置上的元素返回
		System.out.println(iterator.next());
}

在调用iterator.next();方法之前要掉用iterator.hasNext()进行检测。若不调用，当下一条记录无效的时候，直接调用iterator.next()会抛出NoSuchElementException异常。

Iterator迭代器使用示例：

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

public class Iterator_Learn {
    public static void main(String[] args) {
        Collection col=new ArrayList();//col的编译类型是Collection，运行类型是ArrayList
        //这里用了向上转型

        col.add(new Book("三国演义",10));
        col.add(new Book("水浒传",20));
        col.add(new Book("西游记",15));

        Iterator iterator=col.iterator();//得到一个迭代器
        while(iterator.hasNext()){
            Object next = iterator.next();
            System.out.println(next);
        }
			//重置迭代器位置
        iterator=col.iterator();
    }
}

class Book{
    String name;
    double price;

    public Book(String name, double price) {
        this.name = name;
        this.price = price;
    }

    @Override
    public String toString() {
        return "Book{" +
                "name='" + name + '\'' +
                ", price=" + price +
                '}';
    }
}

快捷键提示：
生成迭代器：itit
显示所有快捷键的快捷键：Ctrl+j

Collection接口遍历元素方式 2—>使用增强for循环 底层仍然是迭代器

for(元素类型 元素名: 集合名或数组名){
		访问元素
}

//示例
for(Object book:col){
	System.out.println("book="+book);//book是在增强for循环中创建出来读取该元素的。
}

三、List类

List接口是Collection接口的子接口

1. List集合类中元素有序（即添加顺序和取出顺序一致）且元素可重复。
2. List集合中的每个元素都有其对应的顺序索引，即支持索引。
3. List容器中的元素都对应一个整数型的序号记载其在容器中的位置，可以根据需要取容器中的元素。
4. JDK API中List接口的常用实现类有：ArrayList、LinkedList和Vector。

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

public class List_ {
    public static void main(String[] args) {
        List list=new ArrayList();
        list.add("jack");
        list.add("tom");
        list.add("mary");
        list.add("hsp");
        System.out.println("list"+list);
        System.out.println(list.get(3));//2. List集合中的每个元素都有其对应的顺序索引，即支持索引。
    }
}

List接口和常用方法

List集合里添加了一些根据索引来操作集合元素的方法

1. void add(int index,Object ele);在index位置插入ele元素。
2. boolean addAll(int index,Collection eles);从index位置开始将eles中的所有元素添加进来。
3. Object get(int index)获取指定index位置的元素。
4. int indexOf(Object obj);返回obj在集合中首次出现的位置。
5. int lastIndexOf(Object obj);返回obj在当前集合中末次出现的位置。
6. Object remove(int index);移除指定index位置的元素，并返回此元素。
7. Object set(int index,Object ele);设置指定index位置的元素为ele，相当是替换。
8. List subList(int fromIndex,int toIndex);返回从fromIndex到toIndex位置的子集合。（前闭后开）
9. List的三种遍历方式：①迭代器 ②增强for循环（底层也是迭代器）③普通for循环

**练习程序：**按照书本的价格对集合进行排序。

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

public class ListExercise {
    public static void main(String[] args) {
        List list= new ArrayList();

        Book book1=new Book("红楼梦",20);
        Book book2=new Book("西游记",90);
        Book book3=new Book("三国演义",30);
        Book book4=new Book("水浒传",80);
        list.add(book1);
        list.add(book2);
        list.add(book3);
        list.add(book4);

        Iterator iterator=list.iterator();
        while (iterator.hasNext()){
            Book book=(Book)iterator.next();
            System.out.println(book);
        }

        sort(list);


        System.out.println("-----排序后-----");
        iterator=list.iterator();
        while (iterator.hasNext()){

            System.out.println(iterator.next());
        }

    }

    public static void sort(List list){
        int size = list.size();
        for (int i = 0; i < size-1; i++) {
            for (int j = 0; j < (size-1-i); j++) {
//                Object book1=list.get(j);//这里要用Object来接收对象,但是这样不能调用Book类中的特有函数
//                Object book2=list.get(j+1);
                Book book1=(Book)list.get(j);
                Book book2=(Book)list.get(j+1);
                if (book1.getBookPrice()>book2.getBookPrice()){
                    list.set(j,book2);
                    list.set(j+1,book1);
                }

            }
        }//循环结束
    }
}

class Book{
    String bookName;
    double bookPrice;

    public Book(String bookName, double bookPrice) {
        this.bookName = bookName;
        this.bookPrice = bookPrice;
    }

    public String getBookName() {
        return bookName;
    }

    public void setBookName(String bookName) {
        this.bookName = bookName;
    }

    public double getBookPrice() {
        return bookPrice;
    }

    public void setBookPrice(double bookPrice) {
        this.bookPrice = bookPrice;
    }

    @Override
    public String toString() {
        return "Book{" +
                "bookName='" + bookName + '\'' +
                ", bookPrice=" + bookPrice +
                '}';
    }
}