Collection接口、List、Set

Collection

集合是用来存储引用类型的容器

集合分为两大类：
Collection集合：存储数据时。是单个存储的。
Map集合：存储数据时是按键值对存储的。
Collection的基本操作：

boolean add(E e) 向集合中添加元素.
boolean addAll(Collection<? extends E> c) 把集合c中的所有元素添加到当前集合中
void clear() 清空集合
boolean contains(Object o) 判断当前集合是否包含指定的元素o.
boolean containsAll(Collection<?> c)判断当前集合是否包含集合c中的所有元素
boolean isEmpty() 判断集合是否为空
Iterator iterator() 返回集合的迭代器.
boolean remove(Object o) 在当前集合中删除第一个与o匹配的元素.
boolean removeAll(Collection<?> c) 在当前集合中删除在集合c中包含的元素.
int size() 返回元素的个数.
Object[] toArray() 转换为数组.

Collection集合的遍历
方法：foreach、iterator方法（获取迭代器）、for循环
具体代码：

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

public class 迭代器 {
    public static void main(String[] args) {
    List list = new ArrayList();
    list.add(2);
    list.add(2);
    list.add("xi");
    list.add("8");
    list.add("7");
    System.out.println(list);
    //利用for循环
    for(int i=0;i<list.size();i++){
        System.out.println(list.get(i));//get获取指定下标的元素
    }
    //利用Iterator进行迭代
    Iterator s=list.iterator();
    while(s.hasNext()){
        System.out.println(s.next());
    }
    System.out.println();
    //等价于
    for(Iterator s1=list.iterator();s1.hasNext();){
        System.out.println(s1.next());
    }
    System.out.println();
    //利用for-each
    for(Object p:list){//底层就是用Iterable
        System.out.println(p);
    }
}
}

注意：
1.调用iterator()方法其实是创建iterator对象
2.foreach只能对集合进行遍历而不能进行增删改的操作，但是iterator方法所获取的对象中的remove方法可以进行删除操作，但必须引用iterator对象调用方法来进行删除，不可以使用集合对象来进行删除，否则会报错。
3.在获取iterator对象后，不能再向集合中增加元素，否则会报错。

泛型

泛型就是指定某集合为某种类型的数据。
在创建集合时使用，具体用法为在类名后加上尖括号<>在<>内写上数据类型，后边类名的<>中的数据类型可以省略，但如果写必须与前边一致。

List

特点：
1.有序，可重复
2. 有序指的是指存储顺序就是添加顺序
List基本操作：

void add(int index, E element) 在指定位置添加元素
boolean addAll(int index, Collection<? extends E> c)
E get(int index) 返回指定索引值的元素
int indexOf(Object o) 返回元素o在集合中第一次出现的索值
int lastIndexOf(Object o) 最后一次出现的索引值
List subList(int fromIndex, int toIndex) 返回子列表
remove(int index) 删除指定索引的元素
set(int index, E element) 将索引为index的元素改为element
ListIterator（）返回迭代器类似于iterator
sort(Comparator<?superE> c)排序

注意：
1.subList（）并没有生成一个新的列表，只是返回原来列表的一个视图，对subList所截取的视图操作其实就是对原来列表进行操作。
2.ListIterator（）方法所返回的对象的方法比Iterator功能更多，例如可以增删改，而且可以向前迭代等等。
排序方法sort（）的形参是一个Comparator接口的引用，一般使用匿名内部类完成对它的方法compare的重写，compare方法的主要作用是写排序规则。
3.List集合使用contains方法其实是调用对象的equals方法，如果是自定义类的话，需要重写equals方法。

具体代码:

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

public class 使用匿名内部类实现Comparator接口 {
public static void main(String[] args) {
    List<String> list=new ArrayList<>();
    list.add("gg");
    list.add("dd");
    list.add("jj");
    list.add("mm");
    System.out.println(list);
    list.sort(new Comparator<String>() {
        @Override
        public int compare(String o1, String o2) {
            return o1.compareTo(o2);//compareTo为Comparable接口的方法，因为String已经实现此接口故可以直接调用。
        }
    });
    System.out.println(list);
}
}

ArrayList和Vector和LinkedList

ArrayList：
ArrarList的底层算法是基于数组的，它是集合里边的变长数组，Vector是它的前身，Vector相对于ArrayList来说，线程更安全，但是性能较低。
对于开发来说建议使用ArrayList
ArrayList能存储相同的数据，也能保证存储数据的顺序，因为它的底层是数组，数组是用索引来区别元素的存储位置的。
构造器：
public ArrayList（）{}
public ArrayList (int initialCapacity) {}
如果事先知道需要存储多少元素，建议在创建ArrayList的时候，设定初始容量，可以避免扩容的问题。
扩容问题：
若添加个数超过定义时的容量，则会进行自动扩容。
java8开始默认为空集合。

Vector：
Vector和ArrayList的区别：Vector相比于ArrayList更加安全，因为它的方法有Synchronized修饰，但是它的性能低一些。

LinkedList：
底层是双向链表。
LinkedList中的独有方法主要是对头和尾部的操作，有许多重复的。
新增方法：
void addFirst(E e) 在头部添加元素
void addLast(E e) 在尾部添加元素
Iterator descendingIterator()
E element() 返回第一个元素,不删除
E getFirst()返回第一个元素,不删除
E getLast()返回最后一个元素,不删除
boolean offer(E e) 在尾部添加元素
boolean offerFirst(E e).在头部添加元素
boolean offerLast(E e) 在尾部添加元素.
E peek()返回第一个元素,不删除.
E peekFirst()返回第一个元素,不删除
E peekLast()返回最后一个元素,不删除
E poll() 删除第一个元素,并把删除掉的元素返回
E pollFirst()删除第一个元素,并把删除掉的元素返回
E pollLast()删除最后一个元素,并把删除掉的元素返回.
E pop()删除第一个元素,并把删除掉的元素返回.
void push(E e) 在头部添加元素
E removeFirst()删除第一个元素,并把删除掉的元素返回
E removeLast()

一般情况下,在头部添加在尾部添加使用: addFirst()/addLast()
返回第一个元素,返回最后一个元素, getFirst()/ getLast()
删除第一个元素,删除最后一个元素, removeFirst()/ removeLast()
有时: 使用列表模拟栈这种数据结构: push() / pop()
使用列表模拟队列: offer() / poll()

Set

无序,不可重复
无序是指存储顺序可能与添加顺序不一致。

HashSet

• 1. HashSet底层是HashMap
• 2. 调用add()添加元素, 实际上是把该元素作为键添加到了hashMap中
• 3. Hashset实际上就是HashMap的键的集合
• 4. 因为Map中的键不允许重复,所以Set集合中的元素不重复

TreeSet

SortedSet集合,可以对元素进行自然排序
TreeSet实现了SortedSet, 可以对元素进行自然排序, 要求集合中的元素必须是可比较的.
TreeSet实现了SortedSet接口, TreeSet中的元素也可以自然排序
TreeSet集合中只能存储引用类型数据, 要求集合中的元素必须是可比较的

1. 指定Comparator比较器
   2）如果没有Comparator比较器, 元素的类需要实现Comparable接口

如果不需要由小到大(由大到小)排序,选择HashSet, 如果需要排序选择TreeSet.
实现Comparator接口代码方法：

import java.util.Comparator;
import java.util.Set;
import java.util.TreeSet;

class Student1 {
int age;
String name;
public Student1(int age,String name){
    this.age=age;
    this.name=name;
 }

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

public class 使用匿名内部类完成对Comparator接口的实现TreeSet {
public static void main(String[] args) {
    Set< Student1> stu=new TreeSet<>(new Comparator<Student1>() {
        @Override
        public int compare(Student1 o1, Student1 o2) {
            if(o1.age>o2.age){
                return 1;
            }
            if(o1.age<o2.age){
                return -1;
            }
            if(o1.age==o2.age){
                return 0;
            }
            return 0;
        }
    });
    stu.add(new Student1(14, "张三"));
    stu.add(new Student1(19, "李四"));
    stu.add(new Student1(3, "王五"));
    stu.add(new Student1(8, "秀儿"));
    System.out.println(stu);
}
}

实现Comparable接口方法代码：

import java.util.Set;
import java.util.TreeSet;
class Student implements java.lang.Comparable{
int age;
String name;

public Student(int age,String name) {
  this.age=age;
  this.name=name;
}

public String toString() {
    return "Student{" +
            "age=" + age +
            ", name='" + name + '\'' +
            '}';
}

public int compareTo(Object o) {//此方法会自己调用
    Student it1=(Student)o;
     if(this.age>it1.age){
         return 1;
     }else if(this.age<it1.age){
         return -1;
    }else{
         return 0;
     }
}
}
public class Comparable {
public static void main(String[] args) {
    Set set=new TreeSet();
    set.add(new Student(12,"张三"));//若treeSet对象使用add添加元素,括号中的东西必须已经用compareTo排序过，即实现了Compareable接口
    set.add(new Student(13,"李四"));//String中的此接口已经被实现
    set.add(new Student(14,"王五"));//括号中的数据类型必须相同，否则无法比较
    System.out.println(set);
}
}