Java学习List接口、Set接口

Collection中常用的两大子类（List集合、Set集合）

List接口

1、它是一个元素存取有序的集合。这里的有序不是说集合按照升序降序进行存储，而是说元素怎么存进去，怎么取出来的

2、它是一个带有索引的集合，通过索引就可以精确的操作集合中的元素（与数组的索引是一个道理）。

3、集合中可以有重复的元素，通过元素的equals方法，来比较是否为重复的元素。

List接口的常用子类有：

1、ArrayList集合

2、LinkedList集合

List中常用的方法：

100

101

102

103

104

package com.oracle.demo1;
 
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
 
public class ListDemo {
 
    public static void main(String[] args) {
        add();
        remove();
        set();
        get();
        edit();
    }
 
    /*
     * void add(int index,E element) 在指定位置添加元素
     * java.lang.IndexOutOfBoundsException 集合的越界异常
     * java.lang.ArrayIndexOutOfBoundsException 数组的越界异常
     * java.lang.StringIndexOutOfBoundsException 字符串的越界异常
     */
    public static void add() {
        List<String> list = new ArrayList<String>();
        list.add("asd");
        list.add("123");
        list.add("zxc");
        list.add(0, "xxx");
        System.out.println(list);
    }
 
    /*
     * E remove(int index) 
     * 1、删除指定位置上的元素 
     * 2、返回被删除的元素的值
     */
    public static void remove() {
        List<String> list = new ArrayList<String>();
        list.add("asd");
        list.add("123");
        list.add("zxc");
        String element = list.remove(0);
        System.out.println(element);
        System.out.println(list);
    }
 
    /*
     * E set(int index,E element) 
     * 1、替换指定位置上的值
     * 2、获取替换之前的值
     */
    public static void set() {
        List<String> list = new ArrayList<String>();
        list.add("asd");
        list.add("123");
        list.add("zxc");
        System.out.println(list);
        String e = list.set(1, "李四");
        System.out.println(e);
    }
    /*
     * E get(int index)
     * 获取指定索引上的元素值
     * */
    public static void get(){
        List<String> list = new ArrayList<String>();
        list.add("asd");
        list.add("123");
        list.add("zxc");
        System.out.println(list);
        System.out.println(list.get(0));
        for(int i=0;i<list.size();i++){
           System.out.println(list.get(i));
        }
        System.out.println("=================");
        for(String e:list){
            System.out.println(e);
        }
        System.out.println("=================");
        Iterator<String> it=list.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }
    }
    /*
     * Iterator并发修改异常
     * java.util.ConcurrentModificationException
     * 在遍历的过程中不能做修改长度的操作，不然会发生并发修改异常
     * */
    public static void edit(){
        List<String> list = new ArrayList<String>();
        list.add("asd");
        list.add("123");
        list.add("zxc");
        Iterator<String> it=list.iterator();
        while(it.hasNext()){
            String str=it.next();
            if(str.equals("123")){
                int i=list.indexOf("123");
                list.add(i, "lisi");
            }
            System.out.println(list);
        }
    }<br>      //并发修改异常解决办法：在迭代时，不要使用集合的方法操作元素。}

//那么想要在迭代时对元素操作咋办？

//通过ListIterator迭代器操作元素是可以的，ListIterator的出现，解决了使用Iterator迭代过程中可能会发生的错误情况。

List集合存储的数据结构

数据存储的常用结构有：堆栈、队列、数组、链表

堆栈采用该结构的集合，对元素的存取有如下的特点：

先进后出（即，存进去的元素，要在后它后面的元素依次取出后，才能取出该元素）。例如，子弹压进弹夹，先压进去的子弹在下面，后压进去的子弹在上面，当开枪时，先弹出上面的子弹，然后才能弹出下面的子弹。

栈的入口、出口的都是栈的顶端位置

压栈：就是存元素。即，把元素存储到栈的顶端位置，栈中已有元素依次向栈底方向移动一个位置。

弹栈：就是取元素。即，把栈的顶端位置元素取出，栈中已有元素依次向栈顶方向移动一个位置。

队列采用该结构的集合，对元素的存取有如下的特点：

先进先出（即，存进去的元素，要在后它前面的元素依次取出后，才能取出该元素）。例如，安检。排成一列，每个人依次检查，只有前面的人全部检查完毕后，才能排到当前的人进行检查。

队列的入口、出口各占一侧。例如，下图中的左侧为入口，右侧为出口。

数组采用该结构的集合，对元素的存取有如下的特点：

查找元素快：通过索引，可以快速访问指定位置的元素

增删元素慢：

指定索引位置增加元素：需要创建一个新数组，将指定新元素存储在指定索引位置，再把原数组元素根据索引，复制到新数组对应索引的位置。如下图

指定索引位置删除元素：需要创建一个新数组，把原数组元素根据索引，复制到新数组对应索引的位置，原数组中指定索引位置元素不复制到新数组中。如下图

链表采用该结构的集合，对元素的存取有如下的特点：

多个节点之间，通过地址进行连接。例如，多个人手拉手，每个人使用自己的右手拉住下个人的左手，依次类推，这样多个人就连在一起了。

查找元素慢：想查找某个元素，需要通过连接的节点，依次向后查找指定元素

增删元素快：

增加元素：操作如左图，只需要修改连接下个元素的地址即可。

删除元素：操作如右图，只需要修改连接下个元素的地址即可。

ArrayList集合数据存储的结构是数组结构，元素增删慢，查找快，所以日常开发中的查询数据，遍历数据，ArrayList集合是最常用的

LinkedList集合数据存储的结构是链表结构，元素增删快，查找慢，在实际开发中对一个集合的增删经常涉及到首尾操作，在LinkedList集合中提供了一下方法，如下

package com.oracle.demo2;
 
import java.util.LinkedList;
 
public class LinkedListDemo {
    public static void main(String[] args) {
        add();
        get();
        remove();
    }
 
    /*
     * void addFirst(E e) 将指定元素插入到此列表的开头 void addLast(E e) 将指定元素插入到此列表的结尾
     */
    public static void add() {
        LinkedList<String> list = new LinkedList<String>();
        list.addLast("好好学习");
        list.add("HelloWorld");
        list.addFirst("你好");
        System.out.println(list);
    }
 
    /*
     * E getFirst() 返回此列表的第一个元素 
     * E getLast() 返回此列表的最后一个元素
     * java.util.NoSuchElementException
     * 当集合中没有元素时再获取元素会报异常
     * boolean isEmpty()  如果列表中不包含元素，返回true
     */
    public static void get() {
        LinkedList<String> list = new LinkedList<String>();
        list.addLast("好好学习");
        list.add("HelloWorld");
        list.addFirst("你好");
        list.clear();
        if(!list.isEmpty()){
            String s = list.getFirst();
            String f = list.getLast();
            System.out.println(s + "=========" + f);
        }else{
            System.out.println("NoSuchElementException");
        }   
    }
    /*
     * E removeFirst()  移除并返回列表中的第一个元素
     * E removeLast()  移除并返回列表中的最后一个元素
     * */
    public static void remove(){
        LinkedList<String> list = new LinkedList<String>();
        list.addLast("好好学习");
        list.add("HelloWorld");
        list.addFirst("你好");
        System.out.println(list.removeFirst());
        System.out.println(list.removeLast());
        System.out.println(list);
    }
}

Vector集合

Vector集合数据存储的结构是数组结构，为JDK中最早提供的集合。Vector中提供了一个独特的取出方式，就是枚举Enumeration，它其实就是早期的迭代器。此接口Enumeration的功能与 Iterator 接口的功能是类似的。Vector集合已被ArrayList替代。枚举Enumeration已被迭代器Iterator替代。

Set接口

set接口的特点：和List接口的特点相反，无序、可重复、无索引

package com.oracle.demo3;
 
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
 
public class SetDemo {
    public static void main(String[] args) {
        Set<String> set = new HashSet<String>();
        set.add("123");
        set.add("asd");
        set.add("w34ww");
        set.add("dvef");
        set.add("dvef");
        // set中没有索引,无序
        // 1、用Iterator遍历
        Iterator<String> it = set.iterator();
        while (it.hasNext()) {
            System.out.println(it.next());
        }
        System.out.println("===============");
        // 2、增强for循环
        for (String str : set) {
            System.out.println(str);
        }
    }
}

执行结果

HashSet集合

HashSet 实现Set接口，由哈希表支持(实际上是一个HashMap集合)

HashSet集合不能保证的迭代顺序与元素存储顺序相同。

HashSet集合，采用哈希表结构存储数据，保证元素唯一性的方式依赖于：hashCode()与equals()方法。

package com.oracle.demo3;
 
import java.util.HashSet;
 
public class HashSetDemo {
    public static void main(String[] args) {
        hash();
    }
    /*
     * set中存储数据是不能重复的
     * 1、计算你要存储的对象的哈希值，然后将这个哈希值放到集合中去看看
     *    有没有相同的哈希值
     * 2、拿着哈希值在集合中找，如果有相同的哈希值，那么就调用equals方法，
     *    "aab".equals("aab"),如果相同，返回true，就判定这是个重复元素，丢掉
     * 3、如果哈希值相同，则调用equals方法，如果返回false，那么存入set
     * */
    public static void hash(){
        HashSet<String> hs=new HashSet<String>();
        hs.add("aab");
        hs.add("aab");
        hs.add("bbc");
        hs.add("bbc");
        System.out.println(hs);
    }
}

执行结果：[bbc,aab] 说明set集合中是不能存储重复元素的

HashSet存储自定义类型的数据

如果要保证数据的唯一性依赖于：hashcode()和equals()方法

如果给HashSet中存储JavaAPI中提供的类型的元素时，不需要重写元素的hashcode和equals方法，

因为这两个方法，在JavaAPI的每个类中已经重写完毕，如String类、Integer类等。

给HashSet中存放自定义类型元素时，需要重写对象中的hashCode和equals方法，建立自己的比较方式，才能保证HashSet集合中的对象唯一

package com.oracle.demo3;
 
public class Person {
    String name;
    int age;
    public int hashCode(){
        return name.hashCode()+age*55;
    }
    public String toString(){
        return "name为"+name+" age为"+age;
    }
    public boolean equals(Object obj){
        if(obj==null){
            return false;
        }
        if(this==obj){
            return true;
        }
        if(obj instanceof Person){
            return ((Person) obj).age==this.age&&((Person)obj).name==this.name;
        }
        return false;
    }
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    public int getAge() {
        return age;
    }
 
    public void setAge(int age) {
        this.age = age;
    }
 
    public Person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
 
    public Person() {
    }
}

package com.oracle.demo3;
 
import java.util.HashSet;
import java.util.Iterator;
 
public class Test {
    public static void main(String[] args) {
        //创建hashset对象
        HashSet<Person> hs =new HashSet<Person>();
        hs.add(new Person("张三", 18));
        hs.add(new Person("李四", 58));
        hs.add(new Person("王五",30));
        hs.add(new Person("李四", 58));
        Iterator<Person> it=hs.iterator();
        while(it.hasNext()){
            Person p=(Person)it.next();
            System.out.println(p);
        }
    }
}

LinkedHashSet集合

HashSet保证元素唯一，但是元素存放进去是没有顺序的，那么我们要保证有序，就需要用到LinkedHashSet

在HashSet下面有一个子类LinkedHashSet，它是链表和哈希表组合的一个数据存储结构。

package com.oracle.demo3;
 
import java.util.LinkedHashSet;
 
public class LinkedHashSetDemo {
     public static void main(String[] args) {
        LinkedHashSet<String> list=new LinkedHashSet<String>();
        list.add("123");
        list.add("asd");
        list.add("3esd");
        System.out.println(list);
    }
}

判断集合元素是否唯一的原理

ArrayList的contains方法判断元素是否重复原理

ArrayList的contains方法会使用调用方法时，传入的元素的equals方法依次与集合中的旧元素所比较，从而根据返回的布尔值判断是否有重复元素。此时，当ArrayList存放自定义类型时，由于自定义类型在未重写equals方法前，判断是否重复的依据是地址值，所以如果想根据内容判断是否为重复元素，需要重写元素的equals方法。

HashSet的add/contains等方法判断元素是否重复原理