JavaSE单列集合Collection接口

集合的概念

        集合是一个容器,在我们前面学习过的知识中,像是变量,类以及数组都是容器,可以存储数据。在我们使用数组存储数据的时候，数组的长度一旦给定，就无法再更改了，虽然使用数组时查询效率较高，但是数组比较难以扩展，程序运行的过程中，数据的数量大多时候都是变化的，此时单数组就无法满足数据操作的需求了。而集合可以满足java在数据操作中各种各样的操作过程，并且为不同的操作需求提供了不同的数据结构，java中对不同数据结构的实现是集合。

java中的数据结构

1.数组 2.链表 3.哈希表 4数

集合的体系

集合体系概述 Java的集合框架是由很多接口、抽象类、具体类组成的，都位于java.util包中

集合

Collection(接口,单列集合)

List(接口,数据元素可重复,存储有序)

ArrayList(实现类,数组集合)

LinkedList(实现类,链表集合)

Vector(实现类,线程安全的数组集合)

Set(接口,数据元素不重复)

HashSet(实现类)

TreeSet(实现类)

Map(接口,双列集合,键值对)

HashMap(实现类)

HashTable(实现类)

TreeMap(实现类)

Collection接口

单列集合中的顶级接口,其中包含了单列集合中共有的方法,方法一增删改查,判断,转换为主

方法:

boolean add(Object element);向集合中增加一个元素,返回一个boolean值

boolean remove(Object element);根据指定的内容删除集合中的元素,成功返回true否则放回false,也可以根据索引删除

void clear();清空集合中的元素

int size();返回集合中元素的个数

boolean isEmpty();判断是否集合是否为空集合,返回一个boolean值

boolean contains(Object element);判断集合中是否包含某元素,返回一个boolean值

boolean retainAll(Collection c);求交集,并删除与传入集合交集以外的元素,集合数据发生变化返回true,不变返回false

注:在集合中为了方便对数据进行操作,还是建议存储同一类型的元素, 通过设定泛型类型就可以限定集合中存储元素的类型

/*
        collection集合
        在集合中为了方便对数据进行操作,还是建议存储同一类型的元素
        通过设定泛型类型就可以限定集合中存储元素的类型
         */
        Collection<String> c=new ArrayList<>();//collection是集合不可以直接创建对象,此处使用ArrayList实例来举例子
        c.add("a");
        c.add("b");
        c.add("c");
        c.add("d");//add(),向集合中增加一个元素,返回一个boolean值
​
        Collection<String> c1=new ArrayList<>();
        c1.add("e");
        c1.add("f");
        c1.add("g");
        c1.add("h");
​
        c.addAll(c1);//向集合中添加另一个集合,返回一个boolean值
        //c.clear();//清空集合中所有的元素
        System.out.println(c.equals(c1));//比较集合中的元素是否相同,返回一个boolean值
        System.out.println(c.isEmpty());//判断集合中的元素是否为空如果是则返回true,否则返回false
        System.out.println(c.remove("a"));//根据指定的内容删除集合中的元素,成功返回true否则放回false
        //c.removeAll(c1);//删除一个集合,返回一个boolean值
        c.retainAll(c1);//删除与传入集合交集以外的元素,如果集合变化返回true,否则返回false
        System.out.println(c.size());//返回集合的元素个数,注意数组中获取长度用length属性,而字符串中获取长度使用length()方法
​
        Object[] o= c.toArray();//转换为一个Object类型的数组
        System.out.println(Arrays.toString(o));
        String[] s=c.toArray(new String[c.size()]);//转换为指定类型与长度的数组,参数传入的是数组对象
        System.out.println(Arrays.toString(s));
​
        System.out.println(c);
        System.out.println(c1);

List接口

数据对象有顺序且可以重复

ArrayList类

ArrayList类位于List接口下,底层由数组实现,特点是查找效率高,空间利用率低,但是数组中间的增删效率较低,ArrayList类中与其他类不同的方法是add(),get()方法,其余方法与其他类类似

方法:

add()方法:

ArrayList类中的add()方法,向底层数组中添加元素,创建对象的时候底层会默认创建一个的Object数组,第一次添加元素的时候会创建一个长度为10的数组,而在长度超过10之后底层会创建一个长度为原数组长度1.5倍的数组,并且将原数组复制过来,并将新数字的地址赋予新的数组

get(int indext)方法;

获取指定索引处的元素

/*
        ArrayList类
         */
        ArrayList<String> a=new ArrayList<>();
        a.add("a");//ArrayList类中的add()方法,向底层数组中添加元素,创建对象的时候底层会默认创建一个的Object数组,第一次添加元素的时候会创建
                   //一个长度为10的数组,而在长度超过10之后底层会创建一个长度为原数组长度1.5倍的数组,并且将原数组复制过来,并将新数字的地址赋予
                   //新的数组
        a.add("a");
        a.add("a");
        a.add("a");
        a.add("a");
        a.add("a");
        a.add("a");
        a.add("a");
        a.add("a");
        a.add("a");
        a.add("a");
​
        a.add(10,"b");//向指定位置处插入一个新元素
        System.out.println(a.get(10));//获取指定位置上的集合元素,而在当传入索引超出集合的长度的时候,底层方法中会抛出越界异常
        System.out.println(a.remove(9));//删除指定位置的元素,并且返回该位置处元素的值
        System.out.println(a.remove("a"));//删除集合中第一次出现的指定内容的元素,返回一个boolean值
        System.out.println(a.set(0,"b"));//替换数组中指定位置的元素,返回被替换的值
        System.out.println(a.size());//返回集合中的元素
​
        System.out.println(a);

LinkedList类

LinkedList类位于List接口下,底层由链表实现,特点是查找效率低,空间利用率高,但是数组中间的增删效率较高,LinkedList类中的add()方法与get()方法也与其他类不同,且有链表中特有的增加与删除方法

方法:

add();向链表末尾处添加一个元素,也可以传入索引在指定位置处添加元素

get();获取指定位置处的元素,若是指定索引小于size/2则从头开始查找, 若是指定索引大于size/2则从链表尾部开始查找

addFirst()/addLast();向头/尾结点中添加一个元素

removeFirst()/removeLast();删除头/尾结点的元素并返回

/*
        LinkedList类
         */
        LinkedList<String> llist=new LinkedList<>();
        llist.add("a");//向链表末尾结点处添加一个元素
        llist.add("b");
        llist.add("c");
        llist.add("d");
        llist.add("e");
​
        llist.add(1,"b");//向指定索引处添加一个元素
        System.out.println(llist.get(4));//获取指定位置处的元素,若是指定索引小于size/2则从头开始查找,
                                         // 若是指定索引大于size/2则从链表尾部开始查找
        //链表中的特有的方法,addFirst()/addLast()向头/尾结点中添加一个元素,removeFirst()/removeLast()删除头/尾结点的元素并返回,等方法
​
        System.out.println(llist);

Vector类

该类与ArrayList类的底层实现一致,但是是线程安全的数组集合,类似于StringBuffer与StringBuilder之间的关系

List接口下的集合的遍历

1.for循环遍历

在for循环遍历进行对集合的删除操作的时候,由于索引会随着每次循环进行自增而集合在删除过后会导致集合后面的元素整体向前移位,再下一次遍历的时候就会出现数组错位的情况

for (int i = 0; i < a.size(); i++) {
            if (a.get(i).equals("d")){
                a.remove(i);//删除后,集合移位而索引自增
            }
        }
        System.out.println(a);//[a, b, c, d, d, d]
2.增强for循环遍历

如果在遍历中对集合进行删除操作,会抛出ConcurrentModificationException异常(并发修改异常)

for (String s : a) {
            if (s.equals("d")) {
                a.remove(s);//此时改变集合中下一个元素的位置的操作会抛出异常
            }
        }

3.针对list集合的迭代器遍历

①iterator()方法,会返回一个ArrayList类的内部类Itr类中的对象该类实现了Iterator接口,是专门用作对集合遍历的控制的类

Iterator<String> it=a.iterator();
        while(it.hasNext()){//hasNext()方法判断集合中还有没有元素存在
            String e= it.next();//获取集合的中的元素
            if (e.equals("d")){
                it.remove();//Itr类中的remove方法,可以删除当前遍历中的元素,如果在遍历中需要删除元素,则使用迭代器中的remove方法
    }
    System.out.println(a);
②listIterator()方法,list接口下的类中独有的方法,返回一个ListItr类的对象该方法与iterator()方法类似,但是可以传入参数,从指定位置处开始遍历

ListIterator<String> it2=a.listIterator(2);
        while(it2.hasNext()){//hasNext()方法判断集合中还有没有元素存在
            String e= it2.next();//获取集合的中的元素
            if (e.equals("d")){
                it2.remove();
            }
        }
        System.out.println(a);
​
//还可以使用previous()与hasPrevious()方法实现向前遍历
        ListIterator<String> it3=a.listIterator(a.size());
        while(it3.hasPrevious()){//hasNext()方法判断集合中还有没有元素存在
            String e= it3.previous();//获取集合的中的元素
            if (e.equals("d")){
                it3.remove();
            }
            System.out.println(e);
        }

Set接口

        数据对象没有顺序(不按添加顺序存储)且不可以重复，该接口下的集合也继承了Collection接口中的方法

HashSet类

        HashSet类位于Set接口下,实现了Collection接口下的方法,底层使用HashMap中取键值一列来实现的,该类中的元素存储无序,并且元素不可重复

 /*
        构造方法
        public HashSet() {
        map = new HashMap<>();
        }
         */
        HashSet<String> hset=new HashSet<>();
        hset.add("a");
        hset.add("d");
        hset.add("b");
        hset.add("a");//add()方法添加重复元素的时候,会判断元素是否重复再做添加,返回一个boolean值,且可以添加一个单列集合
        hset.add("y");
        hset.add("f");
​
        System.out.println(hset);//[a, b, d, f, y]存储时不会按添加顺序存储
​
        //单列集合中的方法都可以使用
        //例如,clear(),remove(),isEmpty()等方法
​

TreeSet类

        HashSet类位于Set接口下,实现了Collection接口下的方法,底层使用TreeMap中取键值一列来实现的,该类中的元素存储按照元素的自然顺序存储,由于需要排序,故在存储引用类型的数据时需要实现Comparable接口,并且元素不可重复

 /*
        构造方法
         public TreeSet() {
        this(new TreeMap<E,Object>());
        }
         */
        TreeSet<String> tset=new TreeSet<>();
        tset.add("d");
        tset.add("q");
        tset.add("a");
        tset.add("c");
        tset.add("g");
        tset.add("d");//add()方法存储重复元素时会自动判断,返回一个boolean值,也支持添加一个单列集合
        tset.add("v");
​
        System.out.println(tset);//[a, c, d, g, q, v]集合元素按自然顺序存储
​
        //单列集合间可以通过构造方法互相转换
        HashSet<String> h1=new HashSet<>(tset);
        System.out.println(h1);//[a, q, c, d, v, g]
​
        ArrayList<String> a1=new ArrayList<>(tset);
        System.out.println(a1);//[a, c, d, g, q, v]
​
        LinkedList<String> l1=new LinkedList<>(tset);
        System.out.println(l1);//[a, c, d, g, q, v]

单列集合之间可以通过构造方法相互转换

Set集合遍历

1.增强for循环遍历

2.迭代器遍历

Set集合中的遍历方式与List集合中的遍历方法相同，不再过多赘述