Java 集合

作者: 一亩三分甜 | 来源:发表于2019-09-14 23:29 被阅读0次

数组和集合类同是容器，有何不同？

数组虽然也可以存储对象，但长度是固定的；集合长度是可变的。数组中可以存储基本数据类型，集合只能存储对象。

1.add方法的参数类型是Object,以便于接收任意类型对象。

2.集合中存储的都是对象的引用(地址)。
什么事迭代器呢？
其实就是集合的取出元素的方式。

import java.util.*;
public class CollectionDemo {
    public static void main(String[] args) {
        method_2();
    }
    public static void method_2()
    {
        ArrayList a11 = new ArrayList();
        a11.add("java01");
        a11.add("java02");
        a11.add("java03");
        a11.add("java04");
        ArrayList a12 = new ArrayList();
        a12.add("java07");
        a12.add("java08");
        a12.add("java05");
        a12.add("java06");
        a12.add("java04");
        a12.retainAll(a12);//去交集，all中只会保留和a12中相同的元素
        sop("a11:"+a11);
        sop("a12:"+a12);
    }
    public static void method_base()
    {
        //创建一个集合容器，使用Collection接口的子类。ArrayList
        ArrayList al = new ArrayList();
        //1.添加元素
        al.add("java01");
        al.add("java02");
        al.add("java03");
        al.add("java04");
        //获取个数，集合长度
        //打印原集合
        sop("原集合:"+al);
        //3.删除元素
        al.remove("java02");
        al.clear();
        //4.判断元素、
        sop("java03是否存在:"+al.contains("java03"));
        sop("集合是否为空？"+al.isEmpty());
        //2.获取个数，集合长度
        sop("size:"+al.size());
        //打印改变后的集合
        sop(al);
    }
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
}

迭代器

把取出方式定义在集合的内部，这样取出方式就可以直接访问集合内容的元素。那么取出方式就被定义成了内部类。而每一个容器的数据结构不同，所以取出的动作细节不一样。但是都有共性内容判断和取出，那么可以将这些共性抽取。
那么这些内部类都符合一个规则。该规则是Iterator。如何获取集合的取出对象呢？通过一个对外提供的方法。iterator();

import java.util.*;
public class CollectionDemo0 {
    public static void main(String[] args) {
        ArrayList a1 = new ArrayList();
        a1.add("java01");
        a1.add("java02");
        a1.add("java03");
        a1.add("java04");

        Iterator it = a1.iterator();//获取迭代器，用于取出集合中的元素。
        while(it.hasNext())
        {
            sop(it.next());
        }
    }
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
}
//输出结果
java01
java02
java03
java04

Collection

List:元素是有序的，元素可以重复。因为该集合体系有索引。
ArrayList:底层的数据结构使用的是数组结构。特点:查询速度很快。但是增删稍慢，线程不同步。
LinkedList:底层使用的链表数据结构。特点:增删速度很快，查询稍慢。
Vector:底层是数组数据结构。线程同步。被ArrayList替代了。

Set:元素是无序，元素不可以重复。

List:
特有方法:凡是可以操作角标的方法都是该体系特有的方法。

增
add(index,element);
addAll(index,Collection);
删
remove(index);
改
set(index,element);
查
get(index);
subList(from,to);
listIterator();

import java.util.*;
public class ListDemo {
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
    public static void main(String[] args) {
        ArrayList a1 = new ArrayList();
        //添加元素
        a1.add("java01");
        a1.add("java02");
        a1.add("java03");
        a1.add("java04");

        sop("原集合是："+a1);
        //在指定位置添加元素
        a1.add(1,"java09");
        //删除指定位置的元素
        //a1.remove(2);
        //修改元素
        //a1.set(2,"java007");
        //通过角标获取元素
        sop("get(1):"+a1.get(1));
        sop(a1);
        //获取所有的元素
        for (int x = 0;x<a1.size();x++)
        {
            System.out.println("a1("+x+")="+a1.get(x));
        }

        Iterator it = a1.iterator();
        while (it.hasNext())
        {
            sop("next:"+it.next());
        }
    }
}
//输出结果
原集合是：[java01, java02, java03, java04]
get(1):java09
[java01, java09, java02, java03, java04]
a1(0)=java01
a1(1)=java09
a1(2)=java02
a1(3)=java03
a1(4)=java04
next:java01
next:java09
next:java02
next:java03
next:java04

List集合特有的迭代器，ListIterator是Iterator的子接口。

在迭代时，不可以通过集合对象的方法操作集合中的元素。
因为会发生ConcurrentModificationException异常。
所以，在迭代时，只能用迭代器的方法操作元素，可是Iterator方法是有限的，只能对于元素进行判断，取出，删除的操作，如果想要其他的操作如添加，修改等，就需要使用其子接口，ListIterator。该接口只能通过List集合的ListIterator方法获取。

import java.util.*;

public class ListDemo0 {
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
    public static void main(String[] args) {
        ArrayList a1 = new ArrayList();
        //添加元素
        a1.add("java01");
        a1.add("java02");
        a1.add("java03");
        a1.add("java04");

        sop("原集合是："+a1);

        //在迭代过程中，准备添加或者删除元素。

        Iterator it = a1.iterator();

        while (it.hasNext())
        {
            Object obj = it.next();

            if (obj.equals("java02"))
            a1.add("java008");

            sop("obj="+obj);
        }
        sop(a1);
    }
}
//输出结果
原集合是：[java01, java02, java03, java04]
Exception in thread "main" java.util.ConcurrentModificationException
obj=java01
    at java.base/java.util.ArrayList$Itr.checkForComodification(ArrayList.java:939)
obj=java02
    at java.base/java.util.ArrayList$Itr.next(ArrayList.java:893)
    at ListDemo0.main(ListDemo0.java:24)
    
import java.util.*;

public class ListDemo0 {
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
    public static void main(String[] args) {
        ArrayList a1 = new ArrayList();
        //添加元素
        a1.add("java01");
        a1.add("java02");
        a1.add("java03");
        a1.add("java04");

        sop("原集合是："+a1);

        //在迭代过程中，准备添加或者删除元素。

        Iterator it = a1.iterator();

        while (it.hasNext())
        {
            Object obj = it.next();

            if (obj.equals("java02"))
//            a1.add("java008");
             it.remove();//将java02的引用从集合中删除了。

            sop("obj="+obj);
        }
        sop(a1);
    }
}
//输出
原集合是：[java01, java02, java03, java04]
obj=java01
obj=java02
obj=java03
obj=java04
[java01, java03, java04]

import java.util.*;

public class ListDemo1 {
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
    public static void main(String[] args) {
        ArrayList a1 = new ArrayList();
        //添加元素
        a1.add("java01");
        a1.add("java02");
        a1.add("java03");
        a1.add("java04");

        sop("原集合是："+a1);

        ListIterator li = a1.listIterator();

        sop("hasPrevious():"+li.hasPrevious());

        while (li.hasNext())
        {
            Object obj = li.next();

            if (obj.equals("java02"))
                //li.add("java009");
            li.set("java006");
        }

        while (li.hasPrevious())
        {
            sop("pre::"+li.previous());
        }
        sop(a1);
    }
}
//输出
原集合是：[java01, java02, java03, java04]
hasPrevious():false
pre::java04
pre::java03
pre::java006
pre::java01
[java01, java006, java03, java04]

Vector

枚举就是Vector特有的取出方式。
发现枚举和迭代器很像。
其实枚举和迭代是一样的。
因为枚举的名称以及方法的名称都过长。
所以被迭代器取代了。
枚举郁郁而终了。

import java.util.Enumeration;
import java.util.Vector;

public class VectorDemo {
    public static void main(String[] args) {
        Vector v = new Vector();
        v.add("java01");
        v.add("java02");
        v.add("java03");
        v.add("java04");
        Enumeration en = v.elements();
        while (en.hasMoreElements())
        {
            System.out.println(en.nextElement());
        }
    }
}
//输出
java01
java02
java03
java04

LinkedList:特有方法：

addFirst();
addLast();

getFirst();
getLast();
获取元素，但不删除元素。如果集合中没有元素，会出现NoSuchElementException

removeFirst();
removeLast();
获取元素，但是元素被删除。如果集合中没有元素，会出现NoSuchElementException

在JDK1.6出现了替代方法
offerFirst();
offerLast();

peekFirst();
peekLast();
获取元素，但不删除元素。如果集合中没有元素，会返回null。

pollFirst();
pollLast();
获取元素，但是元素被删除。如果集合中没有元素，会返回null。

import java.util.*;

public class LinkedListDemo {
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
    public static void main(String[] args) {
        LinkedList link = new LinkedList();
        link.addLast("java01");
        link.addLast("java02");
        link.addLast("java03");
        link.addLast("java04");
        sop(link);
        sop(link.getFirst());
        sop(link.getLast());
        sop(link.removeFirst());
        sop(link);
        sop("size="+link.size());
    }
}
//输出
[java01, java02, java03, java04]
java01
java04
java01
[java02, java03, java04]
size=3

import java.util.*;

public class LinkedListDemo0 {
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
    public static void main(String[] args) {
        LinkedList link = new LinkedList();
        link.addLast("java01");
        link.addLast("java02");
        link.addLast("java03");
        link.addLast("java04");
        sop(link);
        sop(link.getFirst());
        sop(link.getLast());
        sop(link.removeFirst());
        sop(link);
        sop("size="+link.size());
        while(!link.isEmpty())
        {
            sop(link.removeFirst());
        }
    }
}
//输出
[java01, java02, java03, java04]
java01
java04
java01
[java02, java03, java04]
size=3
java02
java03
java04

使用LinkedList模拟一个堆栈或者队列数据结构

堆栈:先进后出如同一个杯子。
队列:先进先出 First in First out FIFO 如同一个水管。

import java.util.LinkedList;

class Queue
{
    private LinkedList link;
    Queue()
    {
        link = new LinkedList();
    }
    public void  myAdd(Object obj)
    {
        link.addFirst(obj);
    }
    public Object myGet()
    {
        return link.removeLast();
    }
    public boolean isNull()
    {
        return link.isEmpty();
    }
}
public class LinkedListTest {
    public static void main(String[] args) {
        Queue q = new Queue();
        q.myAdd("java01");
        q.myAdd("java02");
        q.myAdd("java03");
        q.myAdd("java04");
        while (!q.isNull())
        System.out.println(q.myGet());
    }
}
//输出:先进先出
java01
java02
java03
java04

import java.util.LinkedList;

class Queue
{
    private LinkedList link;
    Queue()
    {
        link = new LinkedList();
    }
    public void  myAdd(Object obj)
    {
        link.addFirst(obj);
    }
    public Object myGet()
    {
        return link.removeFirst();
    }
    public boolean isNull()
    {
        return link.isEmpty();
    }
}
public class LinkedListTest {
    public static void main(String[] args) {
        Queue q = new Queue();
        q.myAdd("java01");
        q.myAdd("java02");
        q.myAdd("java03");
        q.myAdd("java04");
        while (!q.isNull())
        System.out.println(q.myGet());
    }
}
//输出:先进后出
java04
java03
java02
java01

取出ArrayList集合中的重复元素

在迭代时循环中next调用一次，就要hasNest判断一次。

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

public class ArrayListTest {
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
    public static void main(String[] args) {
        ArrayList a1 = new ArrayList();
        a1.add("java01");
        a1.add("java02");
        a1.add("java01");
        a1.add("java02");
        a1.add("java03");
        sop("原集合:"+a1);
        Iterator it = a1.iterator();
        while (it.hasNext())
        {
            sop(it.next()+"..."+it.next());//偶数情况下不会发生异常，奇数情况一定发生异常。
        }
    }
}
//输出
原集合:[java01, java02, java01, java02, java03]
java01...java02
java01...java02
Exception in thread "main" java.util.NoSuchElementException
    at java.base/java.util.ArrayList$Itr.next(ArrayList.java:896)
    at ArrayListTest.main(ArrayListTest.java:20)
    
import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Iterator;

public class ArrayListTest0 {
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
    public static void main(String[] args) {
        ArrayList a1 = new ArrayList();
        a1.add("java01");
        a1.add("java02");
        a1.add("java01");
        a1.add("java02");
        a1.add("java03");
        sop("原集合:"+a1);

        a1 = singleElement(a1);
        sop("新集合"+a1);
    }
    public static ArrayList singleElement(ArrayList list)
    {
        //定义一个临时容器
        ArrayList newAl = new ArrayList();
        Iterator it = list.iterator();
        while (it.hasNext())
        {
            Object obj = it.next();
            if (!newAl.contains(obj))
                newAl.add(obj);
        }
        return newAl;
    }
}
//输出
原集合:[java01, java02, java01, java02, java03]
新集合[java01, java02, java03]

将自定义对象作为元素存到ArrayList集合中，并去除重复元素。比如:存入人对象。同姓名同年龄，视为同一个人。为重复元素。

思路:
1.对人描述，将数据封装进人对象。
2.定义容器，将人存入。
3.取出。

List集合判断元素是否相同，依据是元素的equals方法。

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

class Person1
{
    private String name;
    private int age;
    Person1(String name,int age)
    {
       this.name = name;
       this.age = age;
    }
    public boolean equals(Object obj)
    {
        if (!(obj instanceof Person1))
            return false;
        Person1 p = (Person1)obj;
        System.out.println(this.name+"....."+p.name);
        return this.name.equals(p.name) && this.age == p.age;
    }
    public void setName(String name) {
        this.name = name;
    }
    public  String getName()
    {
        return name;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public  int getAge()
    {
        return age;
    }
}
public class ArrayListTest1 {
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
    public static void main(String[] args) {
        ArrayList a1 = new ArrayList();
        a1.add(new Person1("lisi01",30));
        a1.add(new Person1("lisi02",32));
        a1.add(new Person1("lisi02",32));
        a1.add(new Person1("lisi03",33));
        a1.add(new Person1("lisi04",35));
        a1.add(new Person1("lisi04",35));

        sop("原集合:"+a1);
        a1 = singleElement(a1);
        sop("新集合:"+a1);
        Iterator it = a1.iterator();

        while (it.hasNext())
        {
            Person1 p = (Person1) it.next();
            sop(p.getName()+"::"+p.getAge());
        }
    }
    public static ArrayList singleElement(ArrayList list)
    {
        //定义一个临时容器
        ArrayList newAl = new ArrayList();
        Iterator it = list.iterator();
        while (it.hasNext())
        {
            Object obj = it.next();
            if (!newAl.contains(obj))
                newAl.add(obj);
        }
        return newAl;
    }
}
//输出
原集合:[Person1@7d417077, Person1@7dc36524, Person1@35bbe5e8, Person1@2c8d66b2, Person1@5a39699c, Person1@3cb5cdba]
lisi02.....lisi01
lisi02.....lisi01
lisi02.....lisi02
lisi03.....lisi01
lisi03.....lisi02
lisi04.....lisi01
lisi04.....lisi02
lisi04.....lisi03
lisi04.....lisi01
lisi04.....lisi02
lisi04.....lisi03
lisi04.....lisi04
新集合:[Person1@7d417077, Person1@7dc36524, Person1@2c8d66b2, Person1@5a39699c]
lisi01::30
lisi02::32
lisi03::33
lisi04::35

contains和remove底层都调用了equals方法。

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

class Person2
{
    private String name;
    private int age;
    Person2(String name,int age)
    {
        this.name = name;
        this.age = age;
    }
    public boolean equals(Object obj)
    {
        if (!(obj instanceof Person2))
            return false;
        Person2 p = (Person2)obj;
        System.out.println(this.name+"....."+p.name);
        return this.name.equals(p.name) && this.age == p.age;
    }
    public void setName(String name) {
        this.name = name;
    }
    public  String getName()
    {
        return name;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public  int getAge()
    {
        return age;
    }
}
public class ArrayListTest2 {
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
    public static void main(String[] args) {
        ArrayList a1 = new ArrayList();
        a1.add(new Person2("lisi01",30));
        a1.add(new Person2("lisi02",32));
        a1.add(new Person2("lisi04",35));
        a1.add(new Person2("lisi03",33));
        sop("原集合:"+a1);
        sop("remove 03 :"+a1.remove(new Person2("lisi03",33)));
        Iterator it = a1.iterator();

        while (it.hasNext())
        {
            Person2 p = (Person2) it.next();
            sop(p.getName()+"::"+p.getAge());
        }
    }
}
//输出
原集合:[Person2@7d417077, Person2@7dc36524, Person2@35bbe5e8, Person2@2c8d66b2]
lisi03.....lisi01
lisi03.....lisi02
lisi03.....lisi04
lisi03.....lisi03
remove 03 :true
lisi01::30
lisi02::32
lisi04::35

HashSet

Set:元素是无序（存入和取出的顺序不一定一致）,元素不可以重复。

HashSet:底层数据结构是哈希表。
HashSet是如何保证元素唯一性的呢？是通过元素的两个方法，hashCode和equals来完成。如果元素的HashCode值相同，才会判断equals是否为true。
如果元素的hashcode值不同，不会调用equals。
注意,对于判断元素是否存在，以及删除等操作，依赖的方法是元素的hashcode和equals方法。

TreeSet:
Set集合的功能和Collection是一致的。

import java.util.HashSet;
import java.util.Iterator;

public class HashSetDemo {
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
    public static void main(String[] args) {
        HashSet hs = new HashSet();
        sop(hs.add("java01"));
        sop(hs.add("java01"));
        hs.add("java02");
        hs.add("java03");
        hs.add("java03");
        hs.add("java04");

        Iterator it = hs.iterator();
        while (it.hasNext())
        {
            sop(it.next());
        }
    }
}
//输出
true
false
java04
java03
java02
java01

import java.util.HashSet;
import java.util.Iterator;

class Person3
{
    private String name;
    private int age;
    Person3(String name,int age)
    {
        this.name = name;
        this.age = age;
    }
    public int hashCode()
    {
        System.out.println(this.name+"......hashCode");
        return name.hashCode()+age*39;
    }
    public boolean equals(Object obj)
    {
        if (!(obj instanceof Person3))
            return false;
        Person3 p = (Person3)obj;
        System.out.println(this.name+"...equals.."+p.name);
        return this.name.equals(p.name) && this.age == p.age;
    }
    public void setName(String name) {
        this.name = name;
    }
    public  String getName()
    {
        return name;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public  int getAge()
    {
        return age;
    }
}
public class HashSetDemo0 {
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
    public static void main(String[] args) {
        HashSet hs = new HashSet();
        hs.add(new Person3("a1",11));
        hs.add(new Person3("a2",12));
        hs.add(new Person3("a3",13));
        hs.add(new Person3("a2",12));
        hs.add(new Person3("a4",14));

        Iterator it = hs.iterator();
        while (it.hasNext())
        {
            Person3 p = (Person3)it.next();
            sop(p.getName()+"::"+p.getAge());
        }
    }
}
//输出
a1......hashCode
a2......hashCode
a3......hashCode
a2......hashCode
a2...equals..a2
a4......hashCode
a2::12
a4::14
a1::11
a3::13

import java.util.HashSet;
import java.util.Iterator;

class Person4
{
    private String name;
    private int age;
    Person4(String name,int age)
    {
        this.name = name;
        this.age = age;
    }
    public int hashCode()
    {
        System.out.println(this.name+"......hashCode");
        return name.hashCode()+age*39;
    }
    public boolean equals(Object obj)
    {
        if (!(obj instanceof Person4))
            return false;
        Person4 p = (Person4)obj;
        System.out.println(this.name+"...equals.."+p.name);
        return this.name.equals(p.name) && this.age == p.age;
    }
    public void setName(String name) {
        this.name = name;
    }
    public  String getName()
    {
        return name;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public  int getAge()
    {
        return age;
    }
}
public class HashSetDemo1 {
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
    public static void main(String[] args) {
        HashSet hs = new HashSet();
        hs.add(new Person4("a1",11));
        hs.add(new Person4("a2",12));
        hs.add(new Person4("a3",13));
        hs.add(new Person4("a4",14));

        sop("a1:"+hs.contains(new Person4("a2",12)));

        Iterator it = hs.iterator();
        while (it.hasNext())
        {
            Person4 p = (Person4)it.next();
            sop(p.getName()+"::"+p.getAge());
        }
    }
}
//输出
a1......hashCode
a2......hashCode
a3......hashCode
a4......hashCode
a2......hashCode
a2...equals..a2
a1:true
a2::12
a4::14
a1::11
a3::13

import java.util.HashSet;
import java.util.Iterator;

class Person4
{
    private String name;
    private int age;
    Person4(String name,int age)
    {
        this.name = name;
        this.age = age;
    }
    public int hashCode()
    {
        System.out.println(this.name+"......hashCode");
        return name.hashCode()+age*39;
    }
    public boolean equals(Object obj)
    {
        if (!(obj instanceof Person4))
            return false;
        Person4 p = (Person4)obj;
        System.out.println(this.name+"...equals.."+p.name);
        return this.name.equals(p.name) && this.age == p.age;
    }
    public void setName(String name) {
        this.name = name;
    }
    public  String getName()
    {
        return name;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public  int getAge()
    {
        return age;
    }
}
public class HashSetDemo1 {
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
    public static void main(String[] args) {
        HashSet hs = new HashSet();
        hs.add(new Person4("a1",11));
        hs.add(new Person4("a2",12));
        hs.add(new Person4("a3",13));
        hs.add(new Person4("a4",14));

//        sop("a1:"+hs.contains(new Person4("a2",12)));
        hs.remove(new Person4("a4",13));
        Iterator it = hs.iterator();
        while (it.hasNext())
        {
            Person4 p = (Person4)it.next();
            sop(p.getName()+"::"+p.getAge());
        }
    }
}
//输出
a1......hashCode
a2......hashCode
a3......hashCode
a4......hashCode
a4......hashCode
a2::12
a4::14
a1::11
a3::13

Java 集合

数组和集合类同是容器，有何不同？

迭代器

Collection

List集合特有的迭代器，ListIterator是Iterator的子接口。

Vector

LinkedList:特有方法：

使用LinkedList模拟一个堆栈或者队列数据结构

取出ArrayList集合中的重复元素

将自定义对象作为元素存到ArrayList集合中，并去除重复元素。比如:存入人对象。同姓名同年龄，视为同一个人。为重复元素。

List集合判断元素是否相同，依据是元素的equals方法。

contains和remove底层都调用了equals方法。

HashSet

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

Java