JavaSE 集合框架（1）- 集合框架基础以及List集合

妖狐艹你老母 2022-09-26 13:00 465阅读 0赞

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

集合类和数组同时容器，有何不同呢？  
数组虽然也可以存储对象，但是长度固定；集合长度是可变的。数组中可以存储基本数据类型，集合只能存储对象。

JAVA集合大致可以分成Set ,List,Queue, Map四个体系。Set代表无序、不可重复的集合；List代表有序、重复的集合；而Map则代表有映射关系的集合。以下是体系的框架图。

![这里写图片描述][20160922160227455]  
![这里写图片描述][SouthEast]

--------------------

## **集合与数组的联系与区别** ##

A:集合的由来  
　数组长度是固定,当添加的元素超过了数组的长度时需要对数组重新定义,太麻烦,java内部给我们提供了集合类,能存储任意对象,长度是可以改变的,随着元素的增加而增加,随着元素的减少而减少

B:数组和集合的区别  
　区别1 :  
　　数组既可以存储基本数据类型,又可以存储引用数据类型,基本数据类型存储的是值,引用数据类型存储的是地址值  
　　集合只能存储引用数据类型(对象)集合中也可以存储基本数据类型,但是在存储的时候会自动装箱变成对象  
　区别2:  
　　数组长度是固定的,不能自动增长  
　　集合的长度的是可变的,可以根据元素的增加而增长

C:数组和集合什么时候用  
　　1,如果元素个数是固定的推荐用数组  
　　2,如果元素个数不是固定的推荐用集合

D：数组和集合存储引用数据类型,存的都是地址值  
![这里写图片描述][SouthEast 1]

--------------------

## **（1）共性方法** ##

例子。 增删改查

class CollectionDemo{
        public static void main(String[] args)　{
            ArrayList a1 = new ArrayList(); //创建一个集合容器。使用Collection接口的子类。ArrayList 
            a1.add("java01")； //添加元素
            a1.add("java02")；
            a1.add("java03")；
            a1.add("java04")；
    
            ArrayList a2 = new ArrayList();
            a2.add("java01")； //添加元素
            a2.add("java02")；
            a2.add("java05")；
            a2.add("java06")；
    
            System.out.println("size:"+a1.size()); // 获取个数。集合长度
    
            System.out.println(a1); //打印集合
    
            a1.remove("java02"); //删除元素
    
            a1.clear(); // 清空集合
    
            System.out.println("java03是否存在："+a1.contains("java03")); //判断元素
            System.out.println("集合是否为空？"+a1.isEmpty());
    
            a1.retainAll(a2); //取交集，a1中只会保留和a2中相同的元素
            a1.removeAll(a2); //去交集，a1中只会保留和a2中不同的元素
    
            Iterator it = a1.iterator(); //获取只迭代器，用于取出集合中的元素。
            while(it.hasNext()) { //如果仍有元素可以迭代，则返回true
                System.out.println(it.next()); //返回迭代下一个元素
            }   
        }
    }

PS：Iterator仅用于遍历集合，Iterator本身并不提供盛装对象的能力，如果需要创建Iterator对象，则必须有一个被迭代的集合。Iterator必须依附于Collection对象，若有一个Iterator对象，则必然有一个与之对应的Collection对象。

**迭代器原理:**迭代器是对集合进行遍历,而每一个集合内部的存储结构都是不同的,所以每一个集合存和取都是不一样,那么就需要在每一个类中定义hasNext()和next()方法,这样做是可以的,但是会让整个集合体系过于臃肿,迭代器是将这样的方法向上抽取出接口,然后在每个类的内部,定义自己迭代方式,这样做的好处有二,第一规定了整个集合体系的遍历方式都是hasNext()和next()方法,第二,代码有底层内部实现,使用者不用管怎么实现的,会用即可

--------------------

## **（2）List集合** ##

List:元素是有序的，元素可以重复，因为该集合体系有索引。  
Set：元素是无序，元素不可以重复。该集合中没有索引。

List集合：特有方法，凡是可以操作角标的方法都是该体系特有的方法。

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

**ListIterator**  
List集合特有的迭代器。ListIterator的Iterator的子接口。在迭代时，不可以通过集合对象方法操作集合中的元素，因为会发生并发修改异常（ConcurrentModificationException）

List list = new ArrayList();
                list.add("a");
                list.add("b");
                list.add("world");
                list.add("d");
                list.add("e");
    
                /*Iterator it = list.iterator(); while(it.hasNext()) { String str = (String)it.next(); if(str.equals("world")) { list.add("javaee"); //这里会抛出ConcurrentModificationException并发修改异常 } }*/

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

ListIterator li = a1.ListIterator();
    while(li.hasNext()){
        Object obj = li.next();
    
        if(obj.equals("java02"))
            li.set("java06")              //将java02换成java06
    }

ArrayList:底层的数据结构使用的是数组结构。 特点：查询速度很快。但是增删稍慢。线程不同步。  
LinkedList:底层使用的链表数据结构。 特点：增删速度很快，查询稍慢  
Vector：底层是数组数据结构。 线程同步。 被ArrayList替代了。

**ArrayList存储自定义对象**

import java.util.*;
    /* 将自定义对象作为元素存到ArrayList集合中，并去除重复元素。 比如：存入对象。同姓名同年龄，视为同一个人，位重复元素 思路；1，对人描述，将数据封装进人对象 2，定义容器，将人存入。 3，取出。 List集合判断元素是否相同，依据的是元素的equals方法。 */
    
    class Person　{
        private String name;
        private int age;
        Person(String name,int age)　{
            this.name = name;
            this.age = age;
        }
        public boolean equals(Object obj)   {      //ArrayList中判断相同用的是equals()方法，如果不重写equals方法，会导致容器里所有对象都判断为不同
            if(!(obj instanceof Person))
                return false;
            Person p = (Person)obj;
            return this.name.equals(p.name) && this.age == p.age;
        }
        public String getName(){
            return name;
        }
        public int getAge()　{
            return age;
        }
    }
    
    
    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 Person("java01",30));        //a1.add(Object obj); Object obj = new Person("java01",30); 提升成了Objcet类
            a1.add(new Person("java02",31));
            a1.add(new Person("java03",32));
            a1.add(new Person("java03",32));
            a1.add(new Person("java04",33));
    
            a1 = singleElement(a1);
    
            sop("remove 04:"+a1.remove(new Person("java04",33)));   //删除元素，也要调用equals方法
    
            Iterator it = a1.iterator();
    
            while(it.hasNext()) {
                Object obj = it.next();
                Person p =(Person)obj;      //这两句也可以简写为 Person p = (Person)it.next(); 必须将其向下转型为Person类 才能调用Person类的方法
                sop(p.getName()+"::"+p.getAge());
            }
        }
        public static ArrayList singleElement(ArrayList a1){
            ArrayList newA1 = new ArrayList();
    
            Iterator it = a1.iterator();
    
            while(it.hasNext()) {
                Object obj = it.next();
                if(!newA1.contains(obj))
                    newA1.add(obj);
            }
            return newA1;
        }
    }

![这里写图片描述][20160926170844072]

[20160922160227455]: /images/20220717/0254ebf9fda14dc2ae2ea5d8934aa990.png
[SouthEast]: /images/20220717/d522fc2187b949fd8392c76e755a79e6.png
[SouthEast 1]: /images/20220717/92e53f85484648a882aa601543d43999.png
[20160926170844072]: /images/20220717/fc0f5fdf22d542f09cab626deb860e9f.png