JAVA基础学习(十四)--集合一List和HashSet

一、集合的出现

1.1、集合简述

面向对象语言对事物的体现都是以对象形式，为了方便对多个对象的操作，就对象对象进行存储，集合就是存仪储对象最常用的一种试

1.2、数组和集合都是容器

数组也存对象，存储同一种类型，但数组是固定长度的，集合长度是可变。

数组中可以存储基本数据类型，集合只能存储对象

1.3、集合特点

集合只用于存储对象，集合长度是可变的，集合可以存储不同类型的对象。

1.4、结构

 

二、集合共性方法

2.1、Collection接口顶级

Collection 层次结构 中的根接口。Collection 表示一组对象，这些对象也称为 collection 的元素。一些 collection 允许有重复的元素，而另一些则不允许。一些 collection 是有序的，而另一些则是无序的。JDK 不提供此接口的任何直接 实现：它提供更具体的子接口（如 Set 和 List）实现。此接口通常用来传递 collection，并在需要最大普遍性的地方操作这些 collection。

2.2、共性方法

 

方法摘要booleanadd(E e) 
确保此 collection 包含指定的元素（可选操作）。booleanaddAll(Collection<? extends E> c) 
将指定 collection 中的所有元素都添加到此 collection 中（可选操作）。voidclear() 
移除此 collection 中的所有元素（可选操作）。booleancontains(Object o) 
如果此 collection 包含指定的元素，则返回 true。booleancontainsAll(Collection<?> c) 
如果此 collection 包含指定 collection 中的所有元素，则返回 true。booleanequals(Object o) 
比较此 collection 与指定对象是否相等。inthashCode() 
返回此 collection 的哈希码值。booleanisEmpty() 
如果此 collection 不包含元素，则返回 true。Iterator<E>iterator() 
返回在此 collection 的元素上进行迭代的迭代器。booleanremove(Object o) 
从此 collection 中移除指定元素的单个实例，如果存在的话（可选操作）。booleanremoveAll(Collection<?> c) 
移除此 collection 中那些也包含在指定 collection 中的所有元素（可选操作）。booleanretainAll(Collection<?> c) 
仅保留此 collection 中那些也包含在指定 collection 的元素（可选操作）。intsize() 
返回此 collection 中的元素数。Object[]toArray() 
返回包含此 collection 中所有元素的数组。<T> T[]toArray(T[] a) 
返回包含此 collection 中所有元素的数组；返回数组的运行时类型与指定数组的运行时类型相同。

 2.3、ArrayList示例

 

import java.util.*;class CollectionDemo {    public static void main(String[] args) {        // 声明2个集合容器，并添加元素        List<String> ar1 = new ArrayList<String>();        ar1.add("a");        ar1.add("b");        ar1.add("c");        ar1.add("d");        ar1.add("e");        // 遍历        sop("ar1遍历:");        getIterator(ar1);        List<String> ar2 = new ArrayList<String>();        ar2.add("a");        ar2.add("b");        ar2.add("f");        ar2.add("q");        ar2.add("w");        // 增强for循环遍历        sop("ar2遍历:");        getFor(ar2);        // 求集合的长度        sop("ar1的长度:" + ar1.size());        sop("ar2的长度:" + ar2.size());        // 比较判断        sop("ar1中有字符a吗 : " + ar1.contains("a"));        // 整个集合比较        sop("ar1中有字符ar2吗 : " + ar1.containsAll(ar2));        // 求交集        ar1.retainAll(ar2);        sop("求交集");        getFor(ar1);        // addALL        ar1.addAll(ar2);        // 增强for循环遍历        sop("添加ar2后的ar1:");        getFor(ar1);        // 删除        ar1.remove("c");        sop("ar1删除指定c后");        getFor(ar1);        sop("ar1删除指定集合");        ar1.removeAll(ar2);        getFor(ar1);        sop("ar1是空吗？" + ar1.isEmpty());        // 清空        ar1.clear();        sop(ar1.size());    }    // iterator遍历集合    public static void getIterator(List<String> list) {        Iterator<String> iterator = list.iterator();        while (iterator.hasNext()) {            String str = iterator.next();            sop(str);        }    }    // forEach遍历    public static void getFor(List<String> list) {        for (String str : list) {            sop(str);        }    }    // 打印    public static void sop(Object obj) {        System.out.println(obj);    }}

 

结果：

ar1遍历:abcdear2遍历:abfqwar1的长度:5ar2的长度:5ar1中有字符a吗 : truear1中有字符ar2吗 : false求交集ab添加ar2后的ar1:ababfqwar1删除指定c后ababfqwar1删除指定集合ar1是空吗？true0

2.4、Iterator

 

方法摘要booleanhasNext() 
如果仍有元素可以迭代，则返回 true。Enext() 
返回迭代的下一个元素。voidremove() 
从迭代器指向的 collection 中移除迭代器返回的最后一个元素（可选操作）。

 2.5、ArrayList

 

import java.util.ArrayList;import java.util.Iterator;import java.util.List;/** * List:元素是有序的，元素可以重复，该集合体系有索引 * Set:元素是无序，元素不可以重复 * List: *         特有方法：可以操作索引的方法都 是特有 *     add(index ,element) * addAll(index,Collection); * remove (index) * set(index,element) * get(index); * subList(from,to) * listIterator() *  *  */public class ListDemo {    public static void main(String[] args) {        //add();        //remove();        //set();        //getIndex();        indexSub();    }        //indexOf和subList    public static void indexSub(){        List<String> list=new ArrayList<String>();        //添加元素        list.add("java01");        list.add("java02");        list.add("java03");        list.add("java04");        list.set(2,"hello");        sop(list.indexOf("java04"));//3        sop(list.indexOf("java09"));//-1        sop(list.lastIndexOf("hello"));//2        List<String> subList=list.subList(1, 3);        sop(subList);//hello,java03    }        //遍历    public static void getIndex(){        List<String> list=new ArrayList<String>();        //添加元素        list.add("java01");        list.add("java02");        list.add("java03");        list.add("java04");        list.set(2,"hello");        //循环遍历，通过索引的方式遍历和数组一样        for(int x=0;x<list.size();x++){            sop("list["+x+"]="+list.get(x));        }            }        //修改        public static void set(){            List<String> list=new ArrayList<String>();            //添加元素            list.add("java01");            list.add("java02");            list.add("java03");            list.add("java04");            list.set(2,"hello");            //遍历            get(list);        }    //删除元素    public static void remove(){        List<String> list=new ArrayList<String>();        //添加元素        list.add("java01");        list.add("java02");        list.add("java03");        list.add("java04");        list.remove(2);        //遍历        get(list);    }        //添加元素    public static void add(){        List<String> list=new ArrayList<String>();        //添加元素        list.add("java01");        list.add("java02");        list.add("java03");        //遍历        get(list);        //在指定位置添加        list.add(1,"java09");        //遍历        System.out.println("========在指定位置添加后==========");        get(list);    }    //遍历    public static void get(List<String> list){        for(Iterator<String> it=list.iterator();it.hasNext();){            sop(it.next());        }    }    public static void sop(Object obj){        System.out.println(obj);    }    }

2.6、列表迭代器 listIterator

iterator，只能做判断、删除、取出，不能做其它操作

listIterator

public ListIterator<E> listIterator(int index)

返回列表中元素的列表迭代器（按适当顺序），从列表的指定位置开始。指定的索引表示 next 的初始调用所返回的第一个元素。previous 方法的初始调用将返回索引比指定索引少 1 的元素。

此实现返回 ListIterator 接口的直接实现，扩展了由 iterator() 方法返回的 Iterator 接口的实现。ListIterator 实现依赖于底层实现列表的 get(int)、set(int, E)、add(int, E) 和 remove(int) 方法。

注意，除非重写列表的 remove(int)、set(int, E) 和 add(int, E) 方法，否则此实现返回的列表迭代器将抛出UnsupportedOperationException 来响应其 remove、set 和 add 方法。

根据 (protected) modCount 字段规范中的描述，在面临并发修改时，可以使此实现抛出运行时异常。 

 

方法摘要voidadd(E e) 
将指定的元素插入列表（可选操作）。booleanhasNext() 
以正向遍历列表时，如果列表迭代器有多个元素，则返回 true（换句话说，如果 next 返回一个元素而不是抛出异常，则返回 true）。booleanhasPrevious() 
如果以逆向遍历列表，列表迭代器有多个元素，则返回 true。Enext() 
返回列表中的下一个元素。intnextIndex() 
返回对 next 的后续调用所返回元素的索引。Eprevious() 
返回列表中的前一个元素。intpreviousIndex() 
返回对 previous 的后续调用所返回元素的索引。voidremove() 
从列表中移除由 next 或 previous 返回的最后一个元素（可选操作）。voidset(E e) 
用指定元素替换 next 或 previous 返回的最后一个元素（可选操作）。

 

 

package com.pb.list.demo1;import java.util.ArrayList;import java.util.List;import java.util.*;public class ListIteratorDemo {    public static void main(String[] args) {        List<String> list=new ArrayList<String>();        //添加元素        list.add("java01");        list.add("java02");        list.add("java03");        list.add("java04");        list.add("java05");        //获取listIterator迭代器        ListIterator<String> listIterator=list.listIterator();        while(listIterator.hasNext()){            if(listIterator.next().equals("java02")){//判断                //修改                listIterator.set("java007");                //添加                listIterator.add("hello");            }                    }        sop(list);        //倒序输出遍历        while(listIterator.hasPrevious()){            sop(listIterator.previous());        }            }    public static void sop(Object obj){        System.out.println(obj);                }}

 

2.7、Vector

 

package com.pb.list.demo1;import java.util.ArrayList;import java.util.Enumeration;import java.util.List;import java.util.Vector;public class VectorDemo {    public static void main(String[] args) {        Vector<String> vector=new Vector<String>();        //添加元素        vector.add("java01");        vector.add("java02");        vector.add("java03");        vector.add("java04");        vector.add("java05");                //获取枚举        Enumeration<String> en=vector.elements();        while(en.hasMoreElements()){            System.out.println(en.nextElement());        }    }}

 

 

2.8、LinkedList

 

package com.pb.list.demo1;import java.util.LinkedList;/** * LinkedList特有方法：  * 添加元素到第一个索引位置 addFirst();* 添加元素到最后一个索引位置 addLast(); * 获取索引为0的元素 getFirst();  * 获取索引最后的元素 getLast();  * 删除索引为0的元素 removeFirst(); *  删除索引为size()-1的元素 * removeLast(); */public class LinkedListDemo {    public static void main(String[] args) {        // 声明一个链表集合        LinkedList<String> list = new LinkedList<String>();        // 添加到第一个元素        list.addFirst("1");        list.add("2");        list.add("3");        sop(list);// 3,2,1        // 将元素添加到最后        list.addLast("6");        list.addLast("5");        list.addLast("4");// 3,2,1,6,5,4        sop(list);// 获取第一个元素        sop(list.getFirst());//3        // 获取最后一个元素        sop(list.getLast());// 4        // 删除第一个元素        sop(list.removeFirst());        // 删除最后一个        sop(list.removeLast());        sop(list);// 2,1,6,5        /*         * 获取集合全部元素，不使用迭代器         */        while (!list.isEmpty()) {            list.removeFirst();// list.removeLast();        }    }    public static void sop(Object obj) {        System.out.println(obj);    }}

removeFirst或者removeLast

public E removeFirst()

移除并返回此列表的第一个元素。

 

指定者：

接口 Deque<E> 中的 removeFirst

返回：

此列表的第一个元素

抛出：

NoSuchElementException - 如果此列表为空

JDK 1.6之后提供了新的方法

pollFirst或者pollLast

public E pollFirst()

获取并移除此列表的第一个元素；如果此列表为空，则返回 null。

 

指定者：

接口 Deque<E> 中的 pollFirst

返回：

此列表的第一个元素；如果此列表为空，则返回 null

从以下版本开始：

1.6 

示例

package com.pb.list.demo1;import java.util.LinkedList;/** * JDK 1.6提供了新的方法 * offerFirst()，添加元素到第个 * offerLast(),添加元素到最后一位 *  * peekFirst()获取第一个元素 * peekLast()获取最后一个元素 *  * pollFirst()删除第一个元素 * pollLast()删除最后一个元素 * */public class LinkedListDemo1 {        public static void main(String[] args) {    // 声明一个链表集合            LinkedList<String> list = new LinkedList<String>();            // 添加到第一个元素            list.offerFirst("1");            list.offerFirst("2");            list.offerFirst("3");            sop(list);// 3,21            // 将元素添加到最后            list.offerLast("6");            list.offerLast("5");            list.offerLast("4");// 3,2,1,6,5,4            sop(list);            // 获取第一个元素            sop(list.peekFirst());// 3            // 获取最后一个元素            sop(list.peekLast());// 4            // 删除第一个元素            sop(list.pollFirst());            // 删除最后一个            sop(list.pollLast());            sop(list);// 2,1,6,5            /*             * 获取集合全部元素，不使用迭代器             */            while (!list.isEmpty()) {                list.pollFirst();// list.pollLast()            }        }        public static void sop(Object obj) {            System.out.println(obj);        }}

 

示例：

package com.pb.list.demo1;import java.util.LinkedList;/** * 使用LinkedList模拟一个堆栈或者队列数据结构 * 堆栈：先进后出 * 队列：先进先出  *  * */public class LinkedListDemo2 {    public static void main(String[] args) {        Que q=new Que();        q.myAdd("java01");        q.myAdd("java02");        q.myAdd("java03");        q.myAdd("java04");        q.myAdd("java05");        while(!q.isNUll()){            //输出            System.out.println(q.myGet());        }    }}class Que{    private LinkedList list=null;    public Que(){        list=new LinkedList();            }        //判断是不是NULL    public boolean isNUll(){        return list.isEmpty();    }    //添加    public void myAdd(Object obj){        list.offerFirst(obj);    }    //删除    public Object myGet(){        return list.pollLast(); //先出        // return list.pollFirst();    }}

示例，去除list的重复元素

package com.pb.list.demo1;import java.util.ArrayList;import java.util.Iterator;/** * 去除ArrayList中的重复元素 * @author Administrator * */public class ArrayListDemo1 {    public static void main(String[] args) {        ArrayList list=new ArrayList();        list.add("java01");        list.add("java01");        list.add("java02");        list.add("java02");        list.add("java03");        list.add("java03");        list.add("java019");        System.out.println(getSingle(list));    }    public static ArrayList getSingle(ArrayList list){        ArrayList tempList=new ArrayList();        for(Iterator it=list.iterator();it.hasNext();){            Object obj=it.next();            if(!tempList.contains(obj)){                tempList.add(obj);            }        }                return tempList;    }}

 

 示例，去除list的重复对象

package com.pb.list.demo1;public class Person {    private String name;    private int age;                    //重写equals    @Override    public boolean equals(Object obj) {        if(!(obj instanceof Person)){            return false;        }        Person p=(Person)obj;        return this.name.equals(p.name)&&this.age==p.age;    }    public Person() {        super();        // TODO Auto-generated constructor stub    }    public Person(String name, int age) {        super();        this.name = name;        this.age = age;    }    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 void show(){        System.out.println(this.name+"........"+this.age);    }}

 

 

 

package com.pb.list.demo1;import java.util.ArrayList;import java.util.Iterator;/** * 去除ArrayList中的重复元素 * @author Administrator * */public class ArrayListDemo1 {    public static void main(String[] args) {        Person p1=new Person("张三",19);        Person p2=new Person("张三",19);        Person p3=new Person("李四",23);        Person p4=new Person("李四",23);        Person p5=new Person("王五",33);        Person p6=new Person("王五",23);        Person p7=new Person("赵六",18);                ArrayList<Person> list=new ArrayList<Person>();        list.add(p1);        list.add(p2);        list.add(p3);        list.add(p4);        list.add(p5);        list.add(p6);                //遍历去掉重复后的        for(Person p:getSingle(list)){            p.show();        }            }    public static ArrayList<Person> getSingle(ArrayList<Person> list){        ArrayList<Person> tempList=new ArrayList<Person>();        for(Iterator<Person> it=list.iterator();it.hasNext();){            Person p=it.next();            if(!tempList.contains(p)){ //contains也是调用对象equals方法                tempList.add(p);            }                    }                return tempList;    }}

 

 

2.9、三种集合区别

ArrayList：底层的数据结构使用是数组结构,遍历快，增、删、改，慢,线程不同步

LinkedList：底层的数据结构使用链表数据结构，遍历慢，增、删、改，快，

Vector:底层的数据结构使用是数组结构,线程同步的，被ArrayList替代了。

 

 

三、Set

3.1、List和Set区别

 List:元素是有序的，元素可以重复，该集合体系有索引
Set:元素是无序，元素不可以重复

一个不包含重复元素的 collection。更确切地讲，set 不包含满足 e1.equals(e2) 的元素对 e1 和 e2，并且最多包含一个 null 元素。

3.2、常见子类

HashSet--哈希表,TreeSet

3.3、功能方法

Set的方法和Collection一样，使用方式也一样

 

 

package com.pb.list.demo1;public class Person {    private String name;    private int age;                //重写hashCode    @Override    public int hashCode() {        System.out.println("========hashCode");        return name.hashCode()+age*39;    }    //重写equals    @Override    public boolean equals(Object obj) {        if(!(obj instanceof Person)){            return false;        }        Person p=(Person)obj;        System.out.println(p.name+"========equals"+p.age);        return this.name.equals(p.name)&&this.age==p.age;    }    public Person() {        super();        // TODO Auto-generated constructor stub    }    public Person(String name, int age) {        super();        this.name = name;        this.age = age;    }    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 void show(){        System.out.println(this.name+"........"+this.age);    }}

 

package com.pb.list.demo1;import java.util.HashSet;import java.util.Iterator;public class Demo1 {    public static void main(String[] args) {        Person p1=new Person("张三",19);        Person p2=new Person("李四",20);        Person p3=new Person("张三",19);        Person p4=new Person("李四",20);        Person p5=new Person("五一",19);        Person p6=new Person("五一",19);        HashSet<Person> set=new HashSet<Person>();        set.add(p6);        set.add(p5);        set.add(p4);        set.add(p3);        set.add(p2);        set.add(p1);        Iterator<Person> iterator=set.iterator();        while(iterator.hasNext()){            Person p=iterator.next();            p.show();        }            }}

========hashCode========hashCode五一========equals19========hashCode========hashCode========hashCode李四========equals20========hashCode张三========equals19李四........20张三........19五一........19

ArrayList:判断元素是否存或者删除依赖的方法equals()方法

Set:判断元素是否存或者删除，依赖的方法hashCode()和equals()方法,先判断hashCode如果有再判断equals