Java集合类的解析与实现

• 集合概念：

1.1集合可以看做是一个容器，如红色的衣服可以看做是一个集合，所有Java类的书也可以看做是一个集合。集合中的各个对象，很容易将其从集合中取出来。

1.2类似数组功能

和数组的区别：

1. 数组长度固定，集合长度不固定
2. 数组可以存储基本类型和引用类型，集合只能存储引用类型

位置；java.util.*;

• Collection体系接口集合

List接口特点：有序、有下标、元素可重

Set 接口特点：无序、无下标、元素不可重复

1. Collection中的一些方法

方法	功能描述
add(E e)	将指定的对象添加到该集合中
remove(Object o)	讲指定的对象从该集合中移除
isEmpty()	返回boolean值，用于判断当前集合是否为空
iterator()	返回在次Collection的元素上进行迭代的迭代器，用于遍历集合中的对象
size()	返回Int整型，获取该集合中元素的个数

2.1添加元素的实现

 

2.2删除元素

 

2.3 遍历使用增强for

 

2.3.1  使用迭代器（迭代器专门用来遍历集合的一种方式）

  （1）hasNext(); 有没有下一个元素

（2）next(); 获取下一个元素

（3）remove();删除点钱元素

注意：迭代当中是不允许用collection.remove

 

3.判断

 

同样的使用学生进行Collection

（1）新建一个Student类 代码如下

package assemble.demo01;
public class Student {
    private String name;
    private int age;
    public Student(){
    }
    public Student(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;
    }
    @Override
    public String toString() {
       return "Student [name=" + name + ",age=" + age + "]";

    }
}

（2）建立实现类demo02

public class demo02 {
    public static void main(String[] args) {
        Collection collection  = new ArrayList();

        Student s1 = new Student("张三",20);
        Student s2 = new Student("李明",15);
        Student s3 = new Student("小红",22);
        Student s4 = new Student("瑞兹",30);
    //添加数据
        collection.add(s1);
        collection.add(s2);
        collection.add(s3);
        collection.add(s3);
        System.out.println("元素的个数"+collection.size());
        System.out.println(collection.toString());
//删除元素  remove
        collection.remove(s1);
        System.out.println("元素的个数"+collection.size());
        //遍历，同样的使用for增强遍历
        System.out.println("------使用增强for------");
        for(Object object:collection){
            System.out.println(object);}
        //使用迭代器遍历
            System.out.println("================");
            Iterator it = collection.iterator();
            while (it.hasNext()){
                Student s = (Student) it.next();
                System.out.println(s);
            }
            //判断
        System.out.println(collection.isEmpty());//判断集合是否为空
        System.out.println(collection.contains(s2));
        }

    }

 

 

• List接口

List接口继承了Collection接口，因此包含Collection中的所以方法、此外，List接口还定义了其他重要的方法

 

get(int index)	获得指定索引位置的元素。
set(int index,Object obj)	将集合中指定索引位置的对象修改为指定的对象。

1. 添加元素 同样的add方法

 

（2）删除元素  同样的remove方法

 

1. 遍历

3.1同样的可以使用for循环进行遍历

 

3.2 for增强遍历

 

3.3使用迭代器进行遍历

3.4 使用列表迭代器进行遍历

 

1. 判断与获取位置

 

补充subList : 返回集合

 

补充数字类的List接口使用

 

三、（一）List接口 的实现类

常用ArrayList 、LinkedList

ArrayList类实现了可变的数组，允许保存所有元素，包括Null ,并可以根据索引 位置对集合进行快速的随机访问，缺点是向指定的索引位置插入对象或 删除对象的速度较慢

LinkedList类采用链表结构保存对象。这种结构的优点是便于向集合中插入和删 除对象，需要向集合中插入、删除对象时，使用LinkedList类实现的List 集合的效率较高；但对于随机访问集合中的对象，使用LinkedList类实现 集合的效率较低

ArrayList实现代码

package assemble.demo01;

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

//ArrayList 实现类
//结构特点和List 差不多
public class demo05 {
    public static void main(String[] args) {
        //创建对象
        ArrayList arrayList = new ArrayList();
        //添加集合
        //使用学生类进；
        Student s1 = new Student("梁敏芮",22);
        Student s2 = new Student("彭于晏",30);
        Student s3 = new Student("黄子韬",28);
        Student s4 = new Student("郭富城",25);
        //1添加到集合中
        arrayList.add(s1);
        arrayList.add(s2);
        arrayList.add(s3);
        arrayList.add(s4);
        System.out.println(arrayList.size());
        System.out.println(arrayList);

        //2删除元素
        arrayList.remove(s3);
        System.out.println(arrayList);
        //3遍历
        //3.1 使用Iterator
        Iterator it = arrayList.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }
        //3.2 使用列表Iterator
        ListIterator lit = arrayList.listIterator();
        while (lit.hasNext()){
            System.out.println(lit.nextIndex()+":"+lit.next());
        }
        while (lit.hasPrevious()){
            System.out.println(lit.previousIndex()+":"+lit.previous());
        }
        //4.判断
        System.out.println(arrayList.contains(s1));//判断元素是否存在
        System.out.println(arrayList.isEmpty());//判断集合是否为空

        //查找位置
        System.out.println(arrayList.indexOf(s1));
    }
}

LinkedList实现代码

public class demo02 {
    public static void main(String[] args) {
        //创建LinkedList 对象
        LinkedList linkedList = new LinkedList<>();
        Student s1 = new Student("梁敏芮",22);
        Student s2 = new Student("彭于晏",30);
        Student s3 = new Student("黄子韬",28);
        Student s4 = new Student("郭富城",25);
        //添加对象
        linkedList.add(s1);
        linkedList.add(s2);
        linkedList.add(s3);
        linkedList.add(s4);
        System.out.println(linkedList.size());
        System.out.println(linkedList);
        //删除
        //遍历
        //迭代器
        Iterator it = linkedList.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }

    }
}

四、Set集合

1.特点：Set集合中的对象不安特定的方式排序，知识简单地把对象加入集合中，但Set集合中不能包含重复对象。

2.Set接口常用的实现类有HashSet类和TreeSet类。

TreeSet类的方法

first()	返回此Set中当前第一个（最低）元素
Last()	返回此Set中当前最后一个（最高）元素
Comparator()	返回对此Set中的元素进行排序的比较器。如果此Set使用自然顺序，则返回null
headSet(E toElement)	返回一个新的Set集合，心机和是toElement(不包含)之前的所有对象
subSet(E fromElement,E fromElement)	返回一个新的Set集合，是fromElement(包含)对象与fromElement(不包含)对象之间的所有对象
tailSet(E fromElement)	返回一个新的Set集合，新集合包含对象fromElement(包含)之后的所有对象

代码实现

public class Demo01 {
    public static void main(String[] args) {
        //创建集合
        Set<String> set = new HashSet<>();
        set.add("芒果");
        set.add("苹果");
        set.add("火龙果");
        set.add("西瓜");
        set.add("哈密瓜");
        System.out.println("元素的个数"+set.size());
        System.out.println(set);
        //2.删除
        //3.遍历  没有下标的不能使用FOR循环
        //3.1 可以使用增强for
        System.out.println("========增强for======");
        for (String string :set){
            System.out.println(string);
        }
        //3.2使用迭代器 进行遍历
        System.out.println("========迭代器======");
        Iterator it = set.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }
        //4.判断
        System.out.println(set.contains("芒果"));
    }
}

（1）HashSet 接口实现

 

(2)TreeSet 的实现

 

 

想要实现名字的比较 ，必须要在Person类中 implements Comparable<Person>

并且重写里面的compareTo方法

 

• Map集合

1. 概述：Map集合没有集成Collection接口，其提供的是key到value的映射。Map中不能包含相同的key，每个key只能映射一个value。Key还决定了存储对象在映射中的存储位置。

1. Map接口

Map接口中的常用方法

方法	功能概述
put(K key,V value)	向集合中添加指定的key与value的映射关系
containsKey(Object key)	如果此映射包含指定key的映射关系，则返回true
containsValue(Object value)	如果此映射将一个或多个key映射到指定值，则返回true
get(Object key)	如果存在指定的key对象，则返回该对象对应的值。否则返回null
keySet()	返回该集合中的所有key对象形成的Set集合
value()	返回该集合中所有值对象形成的Collection集合

package assemble.demo04;

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

//Map 接口的使用
//特点：（1）存储键值对  （2）键不能重复，值可以重复 （3）无序
public class Demo01 {
    public static void main(String[] args) {
        //创建Map集合
        Map<String,String> map = new HashMap<>();
        //1.添加元素
        map.put("cn","中国");
        map.put("usa","美国");
        map.put("uk","英国");
        map.put("jp","日本");
        map.put("cn","中华人民共和国");

        System.out.println("元素的个数"+map.size());
        System.out.println(map.toString());


        //2.删除
        map.remove("jp");
        System.out.println(map.toString());

        //3.遍历
        //3.1使用keySet（）
        System.out.println("=====1使用keySet 进行遍历=====");
        Set<String> keyset = map.keySet();
        for (String key:keyset){
            System.out.println(key+"----"+map.get(key));
        }
    }
}