JAVA基础学习day14--集合一

时间：2021-07-06 09:25:18

一、集合的出现

1.1、集合简述

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

1.2、数组和集合都是容器

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

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

1.3、集合特点

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

1.4、结构

JAVA基础学习day14--集合一

二、集合共性方法

2.1、Collection接口*

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

2.2、共性方法

方法摘要
boolean add(E e)
确保此 collection 包含指定的元素（可选操作）。
boolean addAll(Collection<? extends E> c)
将指定
collection 中的所有元素都添加到此 collection 中（可选操作）。
void clear()

移除此 collection 中的所有元素（可选操作）。
boolean contains(Object o)

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

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

比较此 collection 与指定对象是否相等。
int hashCode()

返回此 collection 的哈希码值。
boolean isEmpty()

如果此 collection 不包含元素，则返回 true。
Iterator<E> iterator()

返回在此 collection 的元素上进行迭代的迭代器。
boolean remove(Object o)

从此 collection 中移除指定元素的单个实例，如果存在的话（可选操作）。
boolean removeAll(Collection<?> c)

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

仅保留此 collection 中那些也包含在指定 collection 的元素（可选操作）。
int size()

返回此 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遍历:

a

b

c

d

e

ar2遍历:

a

b

f

q

w

ar1的长度:5

ar2的长度:5

ar1中有字符a吗 : true

ar1中有字符ar2吗 : false

求交集

a

b

添加ar2后的ar1:

a

b

a

b

f

q

w

ar1删除指定c后

a

b

a

b

f

q

w

ar1删除指定集合

ar1是空吗？true

0

2.4、Iterator

方法摘要
boolean hasNext()
如果仍有元素可以迭代，则返回 true。
E next()

返回迭代的下一个元素。
void remove()

从迭代器指向的 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"));//

        sop(list.indexOf("java09"));//-1

        sop(list.lastIndexOf("hello"));//

        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 字段规范中的描述，在面临并发修改时，可以使此实现抛出运行时异常。

方法摘要
void add(E e)
将指定的元素插入列表（可选操作）。
boolean hasNext()

以正向遍历列表时，如果列表迭代器有多个元素，则返回 true（换句话说，如果 next
返回一个元素而不是抛出异常，则返回 true）。
boolean hasPrevious()

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

返回列表中的下一个元素。
int nextIndex()

返回对 next 的后续调用所返回元素的索引。
E previous()

返回列表中的前一个元素。
int previousIndex()

返回对 previous 的后续调用所返回元素的索引。
void remove()

从列表中移除由 next 或 previous
返回的最后一个元素（可选操作）。
void set(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

相关文章