Java基础集合框架共性方法迭代器 ArrayList LinkedList Vector HashSet TreeSet

最新推荐文章于 2022-03-23 11:41:43 发布

MagicTurto-BD

最新推荐文章于 2022-03-23 11:41:43 发布

阅读量469

点赞数

分类专栏： Java学习基础视频教程

本文链接：https://blog.csdn.net/cjh1005221032/article/details/46489967

版权

Java学习基础视频教程专栏收录该内容

21 篇文章 0 订阅

订阅专栏

集合

Collection

接口java.util.Collection
包含许多对集合的操作方法
集合类的关系
常用实现类：

ArrayList

List 接口的大小可变数组的实现。实现了所有可选列表操作，并允许包括 null 在内的所有元素。除了实现 List 接口外，此类还提供一些方法来操作内部用来存储列表的数组的大小。（此类大致上等同于 Vector 类，除了此类是不同步的。）

添加修改元素

boolean add(E e)
将指定的元素添加到此列表的尾部。
void add(int index, E element)
将指定的元素插入此列表中的指定位置。
boolean addAll(Collection < ? extends E> c)
按照指定 collection 的迭代器所返回的元素顺序，将该 collection 中的所有元素添加到此列表的尾部。
boolean addAll(int index, Collection< ? extends E> c)
从指定的位置开始，将指定 collection 中的所有元素插入到此列表中。
E set(int index, E element)
用指定的元素替代此列表中指定位置上的元素。

删除元素

E remove(int index)
移除此列表中指定位置上的元素。
boolean remove(Object o)
移除此列表中首次出现的指定元素（如果存在）。
public boolean removeAll(Collection< ?> c)
移除此 collection 中那些也包含在指定 collection 中的所有元素（可选操作）。此调用返回后，collection 中将不包含任何与指定 collection 相同的元素。
void clear()
移除此列表中的所有元素。

获取

E get(int index)
返回此列表中指定位置上的元素。
int size()
返回此列表中的元素数。
boolean isEmpty()
如果此列表中没有元素，则返回 true
int lastIndexOf(Object o)
返回此列表中最后一次出现的指定元素的索引，或如果此列表不包含索引，则返回 -1。
boolean contains(Object o)
如果此列表中包含指定的元素，则返回 true。
public boolean retainAll(Collection< ?> c)
仅保留此 collection 中那些也包含在指定 collection 的元素（可选操作）。换句话说，移除此 collection 中未包含在指定 collection 中的所有元素。

获取迭代器

public Iterator< E> iterator()
返回以恰当顺序在此列表的元素上进行迭代的迭代器。
- 方法摘要
- boolean hasNext()
  如果仍有元素可以迭代，则返回 true。
- E next()
  返回迭代的下一个元素。
- void remove()
  从迭代器指向的 collection 中移除迭代器返回的最后一个元素（可选操作）。

集合演示


import java.util.*;
class CollectionDemo
{
    public static void main(String[] args)
    {
        //method_1();
        //method_2();
        get();

    }
    public static void get()
    {
        ArrayList al=new ArrayList();

        //1.添加元素
        al.add("今天");
        al.add("天气");
        al.add("很好");

        /* Iterator it = al.iterator();//获取迭代器用于取出集合中的元素
        while(it.hasNext())
        {
            sop(it.next());
        } */

        for(Iterator it = al.iterator();it.hasNext();)
        {
            sop(it.next());
        }
    }
    public static void method_1()
    {
        //创建一个集合容器。使用Collecion接口的子类.ArrayList
        ArrayList al=new ArrayList();
        ArrayList al2=new ArrayList();
        //1.添加元素
        al.add("今天");
        al.add("天气");
        al.add("很好");

        al2.add("今天");
        al2.add("心情");
        al2.add("很好");

        sop("al:"+al);
        sop("al2:"+al2);
        sop("alsize:"+al.size());
        al.retainAll(al2);//取交集

        sop("al:"+al);
        sop("al2:"+al2);
        sop("alsize:"+al.size());
    }
    public static void method_2()
    {
        ArrayList al=new ArrayList();
        ArrayList al2=new ArrayList();
        al.add("今天的");
        al.add("天气");
        al.add("很好");
        al.add("!");

        al2.add("今天");
        al2.add("心情");
        al2.add("很好");
        al2.add("!");

        sop("al:"+al);
        sop("al2:"+al2);
        al.remove("天气");
        sop("al.remove(\"天气\")");
        sop("al:"+al);

        al.removeAll(al2);
        sop("al.removeAll(al2)");
        sop("al:"+al);
    }
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
}

get方法输出:
今天
天气
很好

method_1输出:
al:[今天, 天气, 很好]
al2:[今天, 心情, 很好]
alsize:3
al:[今天, 很好]
al2:[今天, 心情, 很好]
alsize:2

method_2输出:
al:[今天的, 天气, 很好, !]
al2:[今天, 心情, 很好, !]
al.remove(“天气”)
al:[今天的, 很好, !]
al.removeAll(al2)
al:[今天的]

List集合共性方法

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.*;
class ListDemo
{
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
    public static void main(String[] args)
    {
        ArrayList al=new ArrayList();

        al.add("java01");
        al.add("java02");
        al.add("java03");

        sop("原集合是:"+al);
        //在指定位置添加元素
        al.add(1,"java09");
        sop(al);
        //删除指定位置的元素
        al.remove(2);
        sop(al);

        //修改元素
        al.set(2,"java07");
        sop(al);

        sop("get(1):"+al.get(1));

        for(int x=0;x<al.size();x++)//通过循环获取List中的元素
        {
            sop("al("+x+")="+al.get(x));
        }

        for(Iterator it=al.iterator();it.hasNext();)//通过迭代器获取元素
        {
            sop(it.next());
        }

    }
}

ListIterator 迭代器

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

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

该接口只能通过List集合的ListIterator方法获取.

    public static void main(String[] args)
    {
        //演示列表迭代器
        ArrayList al=new ArrayList();

        al.add("java01");
        al.add("java02");
        al.add("java03");
        sop("原列表:"+al);
        //在迭代过程中,准备添加或者删除元素
        for(Iterator it=al.iterator();it.hasNext();)//通过迭代器获取元素
        {
            Object obj = it.next();
            if(obj.equals("java02"))
            {
                //al.add("java008"); 运行时错误,不允许并发修改列表
                it.remove();//将java02的引用从集合中删除了
            }
            //sop("obj="+obj);

        }
        sop("通过iterator迭代器删除java02");
        sop(al);
        sop("恢复原列表");
        al.add(1,"java02");
        sop(al);
        ListIterator lit=al.listIterator();
        for(;lit.hasNext();)
        {
            Object obj=lit.next();
            if(obj.equals("java02"))
            {
                lit.set("java10");
                lit.add("java11");//插入元素到当前元素之后
            }
        }
        sop("通过ListIterator.set修改java02为java10");
        sop(al);

        for(;lit.hasPrevious();)//向前判断
        {
            sop(lit.previous());//倒序输出
        }
    }

Vector 矢量

import java.util.*;
/*
枚举就是Vector特有的取出方式.
枚举和迭代器很像
其实枚举和迭代是一样的
因为枚举的名称以及方法的名称都过长
所以被迭代器取代了

*/
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());
        }
    }
}

类 LinkedList< E> 链表


import java.util.*;
/*
LinkedList:特有方法：
addFirst();
addLast();

getFirst();
getLast();

removeFirst();
removeLast();
*/
class LinkedListDemo
{
    public static void main(String[] args)
    {
        LinkedList ll=new LinkedList();
        ll.addFirst("java01");
        ll.addLast("java02");
        ll.addLast("java03");
        ll.addLast("java04");

        ll.offerFirst("java00");//插入第一个元素
        sop(ll.peekLast());//获取最后一个元素,不删除
        sop(ll.pollLast());//获取并删除最后一个元素
        sop(ll);
        sop("First:"+ll.getFirst());
        sop("Last:"+ll.getLast());
        sop("remove:"+ll.removeFirst());
        sop("size:"+ll.size());
    }
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
}

HashSet 哈希表

public class HashSet<E> extends AbstractSet<E> implements Set<E>, Cloneable, Serializable
//此类实现 Set 接口，由哈希表（实际上是一个 HashMap 实例）支持。它不保证 set 的迭代顺序；特别是它不保证该顺序恒久不变。此类允许使用 null 元素。 
public interface Set<E> extends Collection<E>
//一个不包含重复元素的 collection。

方法摘要
boolean add(E e)
如果此 set 中尚未包含指定元素，则添加指定元素。

Set:元素是无序(存入和取出的顺序不一定一致),元素不可以重复。
HashSet:底层数据结构是哈希表
- HashSet 是如何保证元素唯一性的呢？
- 是通过元素的两个方法,hashCode和equals来完成
- 如果元素的HashCode值相同，才会判断equals是否为true
- 如果元素的hashcode值不同，不会调用equals。
- 对于判断元素是否存在，以及删除等操作，依赖的方法是元素的hashcode和equals方法。
TreeSet:

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

import java.util.*;

class HashSetTest
{
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
    public static void main(String[] args)
    {
        HashSet hs = new HashSet();

        hs.add(new Person("a1",11));
        hs.add(new Person("a2",12));
        hs.add(new Person("a3",13));
        hs.add(new Person("a4",14));
        hs.add(new Person("a1",11));

        Iterator it=hs.iterator();

        while(it.hasNext())
        {
            Person p=(Person)it.next();
            sop(p.getName()+"::"+p.getAge());
        }
    }
}

class Person{
    private String name;
    private int age;
    Person(String name,int age)
    {
        this.name=name;
        this.age=age;
    }
    public int hashCode()
    {
        System.out.println(this.name+"hashCode");
        return name.hashCode()+age*2;
    }
    public boolean equals(Object obj)
    {
        if(!(obj instanceof Person))
            return false;

        Person p=(Person)obj;
        System.out.println(this.name+"...equals..."+p.name);
        return this.name.equals(p.name) && this.age==p.age;
    }
    public String getName()
    {
        return name;
    }
    public int getAge()
    {
        return age;
    }
}

输出：
a1hashCode
a2hashCode
a3hashCode
a4hashCode
a1hashCode
a1…equals…a1
a1::11
a2::12
a3::13
a4::14

TreeSet 二叉树表

HashSet: 数据结构是哈希表。线程是非同步的。
保证元素唯一性的原理：判断元素的hashCode值是否相同。
如果相同，还会继续判断元素的equals方法，是否为true。
TreeSet:可以对Set集合中的元素进行排序。
底层数据结构是二叉树
保证元素唯一性的依据：compareTo方法return 0.
1. TreeSet排序的第一种方式：让元素自身具备比较性。
  元素需要实现Comparable接口，覆盖compareTo方法.
  这种方式也称为元素的自然顺序，或者叫做默认顺序。
2. TreeSet的第二种排序方式：
  当元素自身不具备比较性时，或者具备的比较性不是所需要的。
  这时就需要让集合自身具备比较性。创建比较器,并让集合容器使用这个比较器进行比较。

import java.util.*;

class TreeSetDemo
{
    public static void main(String[] args)
    {
        TreeSet ts=new TreeSet();
        ts.add("efg");
        ts.add("abc");
        ts.add("bcd");

        Iterator it = ts.iterator();
        while(it.hasNext())
        {
            System.out.println(it.next());
        }
    }
}

输出:
abc
bcd
efg

1.TreeSet 对象自身的可比较性

TreeSet存储自定义对象

TreeSet添加的对象实现 Comparable接口

实现int compareTo()方法

import java.util.*;

class TreeSetDemo
{
    public static void main(String[] args)
    {
        TreeSet ts=new TreeSet();

        ts.add(new Student("lisi02",22));
        ts.add(new Student("lisi007",20));
        ts.add(new Student("lisi01",40));
        ts.add(new Student("lisi09",19)); 
        ts.add(new Student("lisi08",19)); 
        Iterator it = ts.iterator();
        while(it.hasNext())
        {
            Student st=(Student) it.next();
            System.out.println(st.getName()+"--"+st.getAge());
        }
    }
}

class Student implements Comparable//该接口强制让学生具备比较性
{
    private String name;
    private int age;

    Student(String name,int age)
    {
        this.name=name;
        this.age=age;
    }
    public String getName()
    {
        return name;
    }
    public int getAge()
    {
        return age;
    }
    //排序时，当主要条件相同时，一定要判断一下次要条件
    public int compareTo(Object obj)
    {
        if(!(obj instanceof Student))
            throw new RuntimeException("不是学生对象");
        Student s=(Student)obj;
        System.out.println(this.name+"...compareto..."+s.name);
        if(this.age>s.age)
            return 1;
        else if(this.age==s.age)
            return this.name.compareTo(s.name);
        else 
            return -1;
    }
}

2.TreeSet 使用 Comparator接口创建比较器

import java.util.*;

/*
当元素自身不具备比较性，或者具备的比较性不是所需要的。
这时需要让容器自身具备比较性。
定义了比较器，将比较器对象作为参数传递给TreeSet集合的构造函数

当两种排序都存在时，以比较器为主。

定义一个类，实现Comparator接口，覆盖compare方法。
*/

class MyComparator implements Comparator
{
    public int compare(Object o1,Object o2)
    {
        if(!((o1 instanceof Student)&&(o2 instanceof Student)))
            throw new ClassCastException("不是学生对象!");
        Student t1=(Student)o1;
        Student t2=(Student)o2;

        if(t1.getAge()>t2.getAge())
            return 1;
        else if(t1.getAge()<t2.getAge())
            return -1;
        else
        {
            return t1.getName().compareTo(t2.getName());
        }
    }

}

class TreeSetDemo2
{
    public static void main(String[] args)
    {
        MyComparator mc=new MyComparator();
        TreeSet ts=new TreeSet(mc);
        ts.add(new Student("lili",25));
        ts.add(new Student("koko",27));
        ts.add(new Student("titi",18));
        ts.add(new Student("lili",25));
        Iterator it=ts.iterator();
        while(it.hasNext())
        {
            Student s=(Student)it.next();
            System.out.println(s.getName()+"--"+s.getAge());
        }

    }
}

class Student
{
    private String name;
    private int age;

    Student(String name,int age)
    {
        this.name=name;
        this.age=age;
    }
    public String getName()
    {
        return name;
    }
    public int getAge()
    {
        return age;
    }
}

3.TreeSet 练习

将String类型的元素存入TreeSet容器,根据字符串长度进行排序

创建一个比较器,比较字符串长度

使用迭代器输出

import java.util.*;

class StringLenComparator implements Comparator
{
    public int compare(Object o1,Object o2)
    {
        if(!((o1 instanceof String)&&(o2 instanceof String)))
            throw new ClassCastException("传入的不是字符串");
        String s1=(String)o1;
        String s2=(String)o2;

        if(s1.length()>s2.length())
            return 1;
        if(s1.length()<s2.length())
            return -1;

        return s1.compareTo(s2);

    }
}
class TreeSetTest
{
    public static void main(String[] args)
    {
        StringLenComparator slc=new StringLenComparator();//创建比较器
        TreeSet ts=new TreeSet(slc);//创建二叉树容器，使用slc比较器
        ts.add("hello");
        ts.add("java");
        ts.add("hi");
        ts.add("world!");
        ts.add("hi");//添加元素
        Iterator it=ts.iterator();//创建迭代器.使用ts容器的迭代器

        while(it.hasNext())
        {
            System.out.println(it.next());
        }
    }
}

MagicTurto-BD

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java基础集合框架共性方法迭代器 ArrayList LinkedList Vector HashSet TreeSet

———–android培训、java培训、java学习型技术博客、期待与您交流！————集合Collection接口java.util.Collection 包含许多对集合的操作方法常用实现类：ArrayListList 接口的大小可变数组的实现。实现了所有可选列表操作，并允许包括 null 在内的所有元素。除了实现 List 接口外，此类还提供一些方法来操作内部用来存储列表的数组的大小。
复制链接

扫一扫