集合(二)------单列集合

集合：集合是存储对象数据的集合容器。

集合比数组的优势：
    1. 集合可以存储任意类型的对象数据，数组只能存储同一种数据类型 的数据。
    2. 集合的长度是会发生变化的，数组的长度是固定的。

单列集合体系：

---------| Collection 单例集合的根接口
------------| List  如果是实现了List接口的集合类， 具备的特点：有序，重复。
---------------| ArraryList  底层 是使用了Object数组实现的，特点： 查询速度快，增删慢。
---------------| LinkedList 底层是使用了链表数据结构实现 的， 特点： 查询速度慢，增删快。
---------------| Vector Vector的实现与ArrayList是一致，但是是线程安全 的，操作效率低。 jdk1.0的时候出现的
------------| Set  如果是实现了Set接口的集合类，具备的特点：无序，不可重复。
----------------| HashSet  底层是使用了一个哈希表支持的， 特点：存取速度快。

----------------| TreeSet  底层是使用了红黑树（二叉树）数据结构实现的， 特点：会对元素进行排序存储。

凡是容器都具有增删改查的功能和对应的方法。

collection接口中的方法：

增加：

boolean add(E e)  确保此 collection 包含指定的元素（可选操作）。

boolean addAll(Collection<? extends E> c)  将指定 collection 中的所有元素都添加到此 collection 中（可选操作）。

删除：

void clear() 移除此 collection 中的所有元素（可选操作）。

boolean remove(Object o) 从此 collection 中移除指定元素的单个实例，如果存在的话（可选操作）。

boolean removeAll(Collection<?> c) 移除此 collection 中那些也包含在指定 collection 中的所有元素（可选操作）。

boolean retainAll(Collection<?> c) 仅保留此 collection 中那些也包含在指定 collection 的元素（可选操作）。

查看：

int size() 返回此 collection 中的元素数。

判断：

boolean isEmpty()  如果此 collection 不包含元素，则返回 true。

boolean contains(Object o) 如果此 collection 包含指定的元素，则返回 true。

boolean containsAll(Collection<?> c)   如果此 collection 包含指定 collection 中的所有元素，则返回 true。

迭代：

Object[] toArray()  返回包含此 collection 中所有元素的数组。

Iterator<E> iterator() 返回在此 collection 的元素上进行迭代的迭代器。

迭代器的方法：

boolean hasNext() 如果仍有元素可以迭代，则返回 true。

E  next()  返回迭代的下一个元素。

void remove() 从迭代器指向的 collection 中移除迭代器返回的最后一个元素（可选操作）。只能用在调用next方法之后，否则会报异常：java.lang.IllegalStateException

代码示例如下：

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

public class DemoCollection {

    public static void main(String[] args) {
        //加入
        Collection<String> collection = new ArrayList<String>();
        System.out.println("加入元素是否成功？"+ collection.add("张三"));
        collection.add("李四");
        System.out.println("add之后的collection"+collection);
        
        Collection<String> collection2 = new ArrayList<String>();
        collection2.add("王五");
        collection2.add("赵六");
        collection.addAll(collection2);
        System.out.println("addAll之后的collection"+collection);
        //删除
        System.out.println("删除是否成功？"+collection2.remove("赵六1"));
        System.out.println("删除是否成功？"+collection2.remove("赵六"));
        System.out.println("remove之后的collection2"+collection2);
        System.out.println("删除是否成功？"+collection.removeAll(collection2));
        System.out.println("removeAll之后的collection"+collection);
        
        Collection<String> collection3 = new ArrayList<String>();
        collection3.add("赵六");
        System.out.println("删除是否成功？"+collection.retainAll(collection3));
        System.out.println("retainAll之后的"+collection);
        
        collection2.clear();
        System.out.println("clear之后的collection2？"+collection2);
        //查看
        System.out.println("collection的元素个数："+collection.size());
        //判断
        System.out.println("collection时候为空?"+collection.isEmpty());
        System.out.println("collection是否包含赵六?"+collection.contains("赵六"));
        System.out.println("collection是否包含collection3?"+collection.containsAll(collection3));
        //迭代
        Object[] array = collection.toArray();
        System.out.println(Arrays.toString(array));
        
        Iterator<String> iterator = collection.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
        
        Iterator<String> iterator2 = collection.iterator();
        iterator2.next();
        iterator2.remove();
        System.out.println("collection中的"+collection);
    }
    
}

List接口特有的方法：

增加：

void add(int index, E element) 在列表的指定位置插入指定元素（可选操作）。

boolean addAll(int index, Collection<? extends E> c)  将指定 collection 中的所有元素都插入到列表中的指定位置（可选操作）。

修改：

E set(int index, E element)  用指定元素替换列表中指定位置的元素（可选操作）。

查看：

E get(int index) 返回列表中指定位置的元素。

int indexOf(Object o) 返回此列表中第一次出现的指定元素的索引；如果此列表不包含该元素，则返回 -1。

int lastIndexOf(Object o) 返回此列表中最后出现的指定元素的索引；如果列表不包含此元素，则返回 -1。

List<E> subList(int fromIndex, int toIndex) 返回列表中指定的 fromIndex（包括 ）和 toIndex（不包括）之间的部分视图。


迭代器：

ListIterator<E> listIterator() 返回此列表元素的列表迭代器（按适当顺序）。

ListIterator<E> listIterator(int index) 返回列表中元素的列表迭代器（按适当顺序），从列表的指定位置开始。

ListIterator接口特有的方法：

boolean hasPrevious() 如果以逆向遍历列表，列表迭代器有多个元素，则返回 true。

E previous() 返回列表中的前一个元素。

void add(E e)  将指定的元素插入列表（可选操作）。意思是把当前有元素插入到当前指针指向的位置上。

void set(E e) 用指定元素替换 next 或 previous 返回的最后一个元素（可选操作）。

迭代器在变量元素的时候要注意事项：

1、在迭代器迭代元素 的过程中，不允许使用集合对象改变集合中的元素 个数，如果需要添加或者删除只能使用迭代器的方法进行操作。
 
2、如果使用过了集合对象改变集合中元素个数那么就会出现ConcurrentModificationException异常。    
 
迭代元素的过程中: 迭代器创建到使用结束的时间。

代码示例如下：

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

public class DemoList {
    public static void main(String[] args) {
        List<String> list = new ArrayList<String>();
        //增加
        list.add(0, "张三");
        System.out.println(list);
        List<String> list2 = new ArrayList<String>();
        list2.add("李四");
        list2.add("王五");
        list.addAll(1, list2);
        System.out.println(list);
        //修改
        list.set(2, "赵六");
        System.out.println(list);
        //查看
        System.out.println("索引为0的元素："+list.get(0));
        System.out.println("李四的索引为："+list.indexOf("李四"));
        list.add("张三");
        System.out.println("张三的索引为："+list.indexOf("张三"));
        System.out.println("张三最后一次出现的索引为："+list.lastIndexOf("张三"));
        
        List<String> list3 = list.subList(1, 3);
        System.out.println(list3);
        
        //迭代器
        System.out.println(list);
        ListIterator<String> listIterator = list.listIterator();
        while(listIterator.hasNext()){
            listIterator.add("哈哈");
            System.out.print(listIterator.next()+",");
//            listIterator.set("=="); //只能用在next或者previous之后
        }
        System.out.println();
        System.out.println(list);
        while(listIterator.hasPrevious()){
            list.remove("张三"); //在迭代中不能修改List，否则会报异常ConcurrentModificationException
            System.out.print(listIterator.previous()+",");
        }
    }
}

ArrayList类特有的方法：

void ensureCapacity(int minCapacity)  如有必要，增加此 ArrayList 实例的容量，以确保它至少能够容纳最小容量参数所指定的元素数。

void trimToSize() 将此 ArrayList 实例的容量调整为列表的当前大小。

注意：ArrayList底层是维护了一个Object数组实现 的，使用无参构造函数时，Object数组默认的容量是10，当长度不够时，自动增长0.5倍。

需求： 编写一个函数清除集合中重复书籍，书号相等即为重复。

代码如下：

import java.util.ArrayList;
import java.util.ListIterator;

class Book{
    int id;
    String name;
    public Book(int id, String name) {
        this.id = id;
        this.name = name;
    }
    
    @Override
    public boolean equals(Object obj) {
        Book book = (Book) obj;
        return this.id == book.id;
    }
    @Override
    public int hashCode() {
        return this.id;
    }
    
    @Override
    public String toString() {
        return "[编号："+this.id +"书名："+this.name+"]";
    }
}


public class DemoList {
    public static void main(String[] args) {
        ArrayList<Book> list = new ArrayList<Book>();
        list.add(new Book(110, "西游记"));
        list.add(new Book(220, "水浒传"));
        list.add(new Book(110, "西门庆与潘金莲"));
        System.out.println(list);
        System.out.println(clearRepeat(list));
    }
    
    public static ArrayList<Book> clearRepeat(ArrayList<Book> arrayList) {
        ArrayList<Book> newList = new ArrayList<Book>();
        ListIterator<Book> listIterator = arrayList.listIterator();
        while(listIterator.hasNext()){
            Book book = listIterator.next();
            if (!newList.contains(book)) {
                newList.add(book);
            }
        }
        return newList;
    }
}

 LinkList类特有的方法：

增加：

void addFirst(E e) 将指定元素插入此列表的开头。

void addLast(E e)  将指定元素添加到此列表的结尾。

删除：

E removeFirst() 移除并返回此列表的第一个元素。

E removeLast() 移除并返回此列表的最后一个元素。

查看：

E getFirst() 返回此列表的第一个元素。

E getLast() 返回此列表的最后一个元素。

逆序迭代器：

Iterator<E> descendingIterator() 返回以逆向顺序在此双端队列的元素上进行迭代的迭代器。

与数据结构相关的函数：

1：栈 （1.6）  : 主要是用于实现堆栈数据结构的存储方式。
      先进后出
      void push(E e) 将元素推入此列表所表示的堆栈。
      E pop() 从此列表所表示的堆栈处弹出一个元素。
2：队列（双端队列1.5）： 主要是为了让你们可以使用LinkedList模拟队列数据结构的存储方式。
      先进先出
      boolean offer(E e)  将指定元素添加到此列表的末尾（最后一个元素）。
      E poll()  获取并移除此列表的头（第一个元素）

代码示例如下：

public class DemoList {
    public static void main(String[] args) {
        LinkedList<String> list = new LinkedList<String>();
        //增加
        list.add("李四");
        list.addFirst("张三");
        list.addLast("王五");
        System.out.println(list);
        //查看
        System.out.println(list.getFirst());
        System.out.println(list.getLast());
        //逆序构造器
        Iterator<String> iterator = list.descendingIterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }
        //删除
        list.removeLast();
        System.out.println(list);
        list.removeFirst();
        System.out.println(list);
        //与数据结构
        //栈
        list.push("战三");
        System.out.println(list);
        list.pop();
        System.out.println(list);
        //队列
        list.offer("张三");
        System.out.println(list);
        list.poll();
        System.out.println(list);
        
    }
}

需求：使用LinkedList实现堆栈数据结构的存储方式与队列的数据结构存储方式。   

代码如下：

class StackList<T>{
    LinkedList<T> list;

    public StackList() {
        this.list = new LinkedList<T>();
    }
    
    public void push(T t) {
        this.list.addFirst(t);
    }
    
    public T pop() {
        return this.list.removeFirst();
    }
    
    @Override
    public String toString() {
        return list.toString();
    }
    
}

class QueueList<T>{
    LinkedList<T> list;

    public QueueList() {
        this.list = new LinkedList<T>();
    }
    
    public boolean offer(T t) {
        return this.list.offer(t);
    }
    
    public T poll() {
        return this.list.poll();
    }
    @Override
    public String toString() {
        return this.list.toString();
    }
}

public class DemoList {
    public static void main(String[] args) {
        StackList<String> stackList = new StackList<String>();
        stackList.push("张三");
        stackList.push("李四");
        stackList.push("王五");
        System.out.println(stackList);
        stackList.pop();
        System.out.println(stackList);
        
        QueueList<String> queueList = new QueueList<String>();
        queueList.offer("张三");
        queueList.offer("李四");
        queueList.offer("王五");
        System.out.println(queueList);
        queueList.poll();
        System.out.println(queueList);
        
    }
}

需求： 使用LinkedList存储一副扑克牌，然后实现洗牌功能。

//扑克类
class Poker{
    
    String  color; //花色
    String num;    //点数

    public Poker(String color, String num) {
        super();
        this.color = color;
        this.num = num;
    }

    @Override
    public String toString() {
        return "{"+color+num+"}";
    }
}

public class Demo2 {
    
    public static void main(String[] args) {
        LinkedList pokers = createPoker();
        shufflePoker(pokers);
        showPoker(pokers);
    }
    
    //洗牌的功能
    public static void shufflePoker(LinkedList pokers){
        //创建随机数对象
        Random random = new Random();
        for(int i = 0 ; i <100; i++){ 
            //随机产生两个索引值
            int index1 = random.nextInt(pokers.size());
            int index2 = random.nextInt(pokers.size());
            //根据索引值取出两张牌，然后交换两张牌的顺序
            Poker poker1 = (Poker) pokers.get(index1);
            Poker poker2 = (Poker) pokers.get(index2);
            pokers.set(index1, poker2);
            pokers.set(index2, poker1);
        }
    }
    
    //显示扑克牌
    public static void showPoker(LinkedList pokers){
        for(int i = 0 ; i<pokers.size() ; i++){
            System.out.print(pokers.get(i));
            //换行
            if(i%13==12){
                System.out.println();
            }
        }
    }
    
    //生成扑克牌的方法
    public static LinkedList createPoker(){
        //该集合用于存储扑克对象。
        LinkedList list = new LinkedList();        
        //定义数组存储所有的花色与点数
        String[] colors = {"黑桃","红桃","梅花","方块"};
        String[] nums = {"A","2","3","4","5","6","7","8","9","10","J","Q","K"};
        for(int i = 0 ; i < colors.length ; i++){
            for(int j = 0 ; j<nums.length ; j++){
                list.add(new Poker(colors[i], nums[j]));
            }
        }
        return list;
    }
}

笔试题: 说出ArrayLsit与Vector的区别?
    相同点： ArrayList与Vector底层都是使用了Object数组实现的。
    不同点：
        1. ArrayList是线程不同步的，操作效率高。
           Vector是线程同步的，操作效率低。
        2. ArrayList是JDK1.2出现，Vector是jdk1.0的时候出现的。

set接口没有特有的方法

set中的元素是无序不可重复的。

hashSet的实现原理：底层是使用了一个哈希表支持的。

往Haset添加元素的时候，HashSet会先调用元素的hashCode方法得到元素的哈希值 ，然后通过元素 的哈希值经过移位等运算，就可以算出该元素在哈希表中的存储位置。存储过程中有一下两种情况。
     情况1： 如果算出元素存储的位置目前没有任何元素存储，那么该元素可以直接存储到该位置上。
　  情况2： 如果算出该元素的存储位置目前已经存在有其他的元素了，那么会调用该元素的equals方法与该位置的元素再比较一次，如果equals返回的是true，那么该元素与这个位置上的元素就视为重复元素，不添加，如果equals方法返回的是false，那么该元素允许添加。

需求：接受键盘录入用户名和密码来进行用户注册。如果用户名和密码已经存在，则不能完成注册。如果不存在，则注册成功。

代码示例如下：

import java.util.HashSet;
import java.util.Scanner;

//接受键盘录入用户名和密码来进行用户注册。如果用户名和密码已经存在，则不能完成注册。如果不存在，则注册成功。
class User{
    String userName;
    String password;
    public User(String userName, String password) {
        this.userName = userName;
        this.password = password;
    }
    
    @Override
    public int hashCode() {
        // 如果两个字符串的内容一致，那么返回的hashCode 码肯定也会一致的。
        return this.userName.hashCode() + this.password.hashCode();
    }
    
    @Override
    public boolean equals(Object obj) {
        User user = (User)obj;
        return this.userName.equals(user.userName) && this.password.equals(user.password);
    }
    
    @Override
    public String toString() {
        
        return "当前用户名："+this.userName + "密码："+this.password;
    }
    
}

public class Set {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        HashSet<User> set = new HashSet<User>();
        while(true){
            System.out.println("请输入账号：");
            String userName = scanner.next();
            System.out.println("请输入密码：");
            String password = scanner.next();
            User user = new User(userName, password);
            
            if (set.add(user)) {
                System.out.println("注册成功");
                System.out.println(set);
            }else{
                System.out.println("注册失败");
            }
        }
    }
}

treeSet

内部实现：

　　底层是使用了红黑树（二叉树）数据结构实现的， 特点：会对元素进行排序存储

注意事项：

　  1. 往TreeSet添加元素的时候，如果元素本身具备了自然顺序的特性，那么就按照元素自然顺序的特性进行排序存储。
     2. 往TreeSet添加元素的时候，如果元素本身不具备自然顺序的特性，那么该元素所属的类必须要实现Comparable接口，把元素
     的比较规则定义在compareTo(T o)方法上。
     3. 如果比较元素的时候，compareTo方法返回 的是0，那么该元素就被视为重复元素，不允许添加.(注意：TreeSet与HashCode、equals方法是没有任何关系。)
     4. 往TreeSet添加元素的时候, 如果元素本身没有具备自然顺序 的特性，而元素所属的类也没有实现Comparable接口，那么必须要在创建TreeSet的时候传入一个比较器。
     5.  往TreeSet添加元素的时候，如果元素本身不具备自然顺序的特性，而元素所属的类已经实现了Comparable接口， 在创建TreeSet对象的时候也传入了比较器，那么是以比较器的比较规则优先使用。

如何自定义定义比较器：

　　自定义一个类实现Comparator接口即可，把元素与元素之间的比较规则定义在compare方法内即可。
自定义比较器的格式 ：
             class  类名  implements Comparator{
             }
     
推荐使用：使用比较器(Comparator)。

TreeSet存储具备自然顺序的元素，代码示例如下：

public class Set {
    
    public static void main(String[] args) {
        TreeSet<Integer> treeSet = new TreeSet<Integer>();
        treeSet.add(1);
        treeSet.add(10);
        treeSet.add(8);
        treeSet.add(3);
        treeSet.add(2);
        System.out.println(treeSet);
    }
}

TreeSet存储不具备自然顺序的元素，代码示例如下：

当前类实现Comparable接口和public int compareTo(Object o)方法

class User implements Comparable<User>{
    Integer id;
    String userName;
    String password;
    public User(Integer id, String userName, String password) {
        this.id = id;
        this.userName = userName;
        this.password = password;
    }
    
    @Override
    public int compareTo(User o) {
        User user = (User)o;
        return this.id - user.id;
    }
    
    @Override
    public String toString() {
        return "id:"+ this.id +"  名字："+this.userName ;
    }
    
}

public class Set {
    
    public static void main(String[] args) {
        TreeSet<User> treeSet = new TreeSet<User>();
        treeSet.add(new User(110, "张三", "123"));
        treeSet.add(new User(310, "王五", "123"));
        treeSet.add(new User(210, "李四", "123"));
        System.out.println(treeSet);
    }
}

自定义比较器类

class User{
    Integer id;
    String userName;
    String password;
    public User(Integer id, String userName, String password) {
        this.id = id;
        this.userName = userName;
        this.password = password;
    }
    
    @Override
    public String toString() {
        return "id:"+ this.id +"  名字："+this.userName ;
    }
    
}

class myComparator implements Comparator<User>{
    
    @Override
    public int compare(User o1, User o2) {
        return o1.id - o2.id;
    }
}

public class Set {
    
    public static void main(String[] args) {
        TreeSet<User> treeSet = new TreeSet<User>(new myComparator());
        treeSet.add(new User(110, "张三", "123"));
        treeSet.add(new User(310, "王五", "123"));
        treeSet.add(new User(210, "李四", "123"));
        System.out.println(treeSet);
    }
}