java基础-集合类

1、是什么

   java.util包中包含了一些集合类，又被称为容器，集合类和数组的不同之处在于，数组的长度是固定的，集合类的长度是可变的，数组用来存放基本类型数据，集合类存放对象的引用，常用的有List集合、Map集合、Set集合，其中List与Set继承了Collection接口，各接口和提供了不同的实现类。

2、Collocation接口

    Collection接口时层次结构的根接口，构成Collection 的单位称为元素，Collection接口通常不能直接使用，但是改接口提供了添加元素、删除元素、管理数据的方法，List接口和Set接口继承自Collection接口，所以这些方法在List集合和Set集合是通用的。

    代码示例（遍历集合）：

import java.util.*; //导入java.util包
public class Muster {
    public static void main(String[] args) {
        Collection<String>list = new ArrayList<>();//实例化集合类对象
        list.add("a");//向集合中添加元素
        list.add("b");
        list.add("c");

        Iterator<String>it = list.iterator();//创建一个迭代器
        while (it.hasNext()){
            String str = (String) it.next();
            System.out.println(str);
        }

    }
}

   注意： iterator的next()方法返回的是Object

3、List集合

   List集合包括List接口以及List接口所有的实现类，List集合中的元素允许重复，各元素的顺序是对象插入的顺序，类似于数组，可以使用索引类方位集合中的元素。

    （1）List接口

    List接口继承自Collection接口，包含Collection中的所有 方法，此外还有：

    get(int index) : 获得指定索引位置的元素

    set(int index,Object obj) : 将集合中指定索引位置的对象改为指定对象

    （2）List接口的实现类

    List接口常用的实现类有ArrayList和LinkedList。

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

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

    拓展：

    ArrayList和linkedlist有什么区别？

    简单的区别：

    1.ArrayList是实现了基于动态数组的数据结构，LinkedList基于链表的数据结构。 （LinkedList是双向链表，有next也有previous）

    2.对于随机访问get和set，ArrayList觉得优于LinkedList，因为LinkedList要移动指针。

    3.对于新增和删除操作add和remove，LinedList比较占优势，因为ArrayList要移动数据。

    深度的区别：

    1．对ArrayList和LinkedList而言，在列表末尾增加一个元素所花的开销都是固定的。对ArrayList而言，主要是在内部数组中增加一项，指向所添加的元素，偶尔可能会导致对数组重新进行分配；而对LinkedList而言，这个开销是统一的，分配一个内部Entry对象。

    2．在ArrayList的中间插入或删除一个元素意味着这个列表中剩余的元素都会被移动；而在LinkedList的中间插入或删除一个元素的开销是固定的。

    3．LinkedList不支持高效的随机元素访问。

    4．ArrayList的空间浪费主要体现在在list列表的结尾预留一定的容量空间，而LinkedList的空间花费则体现在它的每一个元素都需要消耗相当的空间

    使用List集合时通常声明List类型，可通过不同的实现类来实例化集合：

    List<E>list = new ArrayList<>();

    List<E> list2 = new LinkedList<>();

    以上代码中，E是合法的java数据类型。如果集合中的元素是字符串类型，E可以改为String。

    代码示例：

import java.util.*;
public class Gather {
    public static void main(String[] args) {
        List list = new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("c");

        int i = (int)(Math.random()*list.size());//获取0-2之间的随机数
        System.out.println("随机获取数组中的元素：" + list.get(i));
        list.remove(2);//删除指定索引位置上的元素
        System.out.println("索引为‘2’的元素从数组中删除之后，数组中的元素是：");
        for(int j = 0 ; j < list.size() ; j++){
            System.out.println(list.get(j));
        }
    }
}

4、Set集合

　Set集合中的对象不按特定方式排序，只是简单的把对象放在集合中，里面不能包含重复元素。Set集合是Set接口和Set接口实现的类组成，Set接口继承了Collection接口，包含Collection接口中的所有方法 。

    Set的构造中有一个约束条件，传入的Collection对象不能有重复值，必须小心操作可变对象（Mutable Object）。如果一个Set的可变元素改变了自身状态导致Object.equals(Object) = true，会出现一些问题。

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

    HashSet类实现Set接口，由哈希表支持，不保证Set的迭代顺序，特别是不保证该顺序恒久不变，此类允许使用null元素。

    TreeSet类不仅实现了Set接口，还实现了java.util.SortedSet接口，TreeSet类实现了Set集合在变量集合是按照自然顺序递增排序，也可以按照指定比较器递增排序，也就是说，TreeSet类实现的Set集合  ，里面的元素，可以通过指定比较器进行排序。

    代码示例：

import sun.reflect.generics.tree.Tree;

import java.util.Iterator;
import java.util.TreeSet;
public class UpdateStu implements Comparable<Object>{
    String name ;
    long id;

    public UpdateStu(String name, long id){//构造方法
        this.name = name;
        this.id = id;
    }

    // 重写接口中的compareTo方法，用来比较对象与指定对象的顺序，如果该对象小于、等于、大于指定对象，返回负整数、0、正整数
    public int compareTo(Object o){
        UpdateStu upstu = (UpdateStu) o;
        int result = id > upstu.id?1:(id == upstu.id?0:-1);
        return result;
    }

    public String getName(){
        return name;
    }

    public void setName(String name){
        this.name = name;
    }

    public long getId(){
       return id;
    }

    public void setId(long id){
        this.id = id;
    }

    public static void main(String[] args) {
        UpdateStu stu1 = new UpdateStu("嬴荣泽",1101);
        UpdateStu stu2 = new UpdateStu("双佳毅",1102);
        UpdateStu stu3 = new UpdateStu("经子君",1103);
        UpdateStu stu4 = new UpdateStu("壬光明",1104);

        TreeSet<UpdateStu> tree = new TreeSet<>();
        tree.add(stu1);//向集合中添加对象
        tree.add(stu2);//向集合中添加对象
        tree.add(stu3);//向集合中添加对象
        tree.add(stu4);//向集合中添加对象

        Iterator<UpdateStu> it = tree.iterator();//Set集合中所有对象的迭代器
        System.out.println("Set集合中所有的元素：");
        while(it.hasNext()){ // 遍历集合
            UpdateStu stu = (UpdateStu)it.next();
            System.out.println(stu.getId()+" "+stu.getName());
        }

        it =tree.headSet(stu2).iterator();//截取排在str2对象之前的对象
        System.out.println("截取前面部分的集合");
        while (it.hasNext()){//遍历集合
            UpdateStu stu = (UpdateStu)it.next();
            System.out.println(stu.getId()+" "+stu.getName());
        }

        it = tree.subSet(stu2,stu3).iterator(); // 截取排在stu2和stu3之间的对象
        System.out.println("截取中间部分集合；");
        while (it.hasNext()){
            UpdateStu stu = (UpdateStu) it.next();
            System.out.println(stu.getId()+" "+stu.getName());
        }

    }

}

    headSet()、subSet()、tailSet()方法截取对象生成的新集合时，是否包含指定的参数，可以通过如下方法判断：如果指定参数位于新集合的起始位置，则包含该对象，如subSet()方法的第一个参数和tailSet()方法的参数；如果指定参数是新集合的终止位置，则不包含该参数，如headSet()方法中的入口参数和sunSet()方法中的第二个入口参数。

5、Map集合

 　Map集合没有继承自Collection接口，提供的是key到value的映射。Map中不能包含相同的Key，每个Key只能映射一个Value。Key还决定了存储对象在映射中的存储位置，但不是由Key对象本身决定的，而是通过一种“散列技术”进行处理，产生一个散列码的整数值。散列码通常用作一个偏移量，该偏移量对应分配给映射的内存区域的起始位置。从而决定存储对象在映射中的存储位置。Map集合包括Map接口和Map接口实现的类。

    （1）Map接口

    Map接口提供了将Key映射到值得对象，一个映射不能包含重复的Key，每个Key最多只能映射到一个值。

 

  代码示例：

import java.util.*;

public class UpdateStu2 {
    public static void main(String[] args) {
        Map<String,String> map = new HashMap<>();//创建Map实例
        map.put("1101","壬光明"); // 向集合中添加对象
        map.put("1102","双佳毅");

        Set<String>set = map.keySet(); // 构建Map集合中所key对象的集合
        Iterator<String> it = set.iterator();//创建集合迭代器
        System.out.println("Key集合中的元素：");
        while (it.hasNext()){
            System.out.println(it.next());
        }
        Collection<String> coll = map.values();//构建Map集合中所有values值得集合
        it = coll.iterator();
        System.out.println("valies集合中的元素：");
        while (it.hasNext()){
            System.out.println(it.next());
        }
    }
}

    注意：Map集合中允许值对象时null，而且没有个数限制。例如“map.put('111',null)”

    

    （2）Map接口的实现类

    Map接口常用的实现类有HashMap和TreeMap，HashMap类实现的Map集合添加和删除映射关系效率更高。HashMap类是基于哈希表的Map接口实现，HashMap通过哈希码对其内部映射关系快速查找，而TreeMap中的映射关系存在一定顺序，如果希望Map集合中的对象也有一定顺序，那就需要使用TreeMap实现Map集合。

    

    HashMap类是基于哈希表的Map接口实现，此实现提供所有可选的映射操作，并允许使用null值和null键，但是需要保证键的唯一性，HashMap通过哈希表对内部映射进行快速查找，不保证映射顺序，不保证该顺序恒久不变。

    TreeMap不仅实现了Map接口，还实现了java,util.SortedMap接口，因此，集合中映射关系有一定顺序，但是在添加、删除、定位映射时，TreeMap比HashMap性能稍差，TreeMap类实现的Map集合中的映射关系是根据键对象按照一定顺序排列的，因此不允许键对象是null。 

 

    代码示例：

public class Emp {
    private String e_id;
    private  String e_name;
    public Emp(String e_id,String e_name){//构造方法
        this.e_id = e_id;
        this.e_name = e_name;
    }
      public String getE_id(){
        return e_id;
      }
      public String getE_name(){
        return  e_name;
      }
}

import java.util.*;

public class MapText {
    public static void main(String[] args) {
        Map<String,String>map = new HashMap<>();//有HashMap实现的Map对象
        // 创建Emp对象
        Emp emp = new Emp("141","章佳天冠");
        Emp emp2 = new Emp("432","宜升冠");
        Emp emp3 = new Emp("111","潭瀚玥");
        Emp emp4 = new Emp("495","称子萱");
        Emp emp5 = new Emp("154","茆锦贤");

        //将对象添加到集合中
        map.put(emp4.getE_id(),emp4.getE_name());
        map.put(emp5.getE_id(),emp5.getE_name());
        map.put(emp.getE_id(),emp.getE_name());
        map.put(emp2.getE_id(),emp2.getE_name());
        map.put(emp3.getE_id(),emp3.getE_name());

        //获取Map集合中Key对象集合
        Set<String>set = map.keySet();
        Iterator<String> it = set.iterator();
        System.out.println("HashMap类实现的Map集合，无序：");
        while (it.hasNext()){
            String str = (String) it.next();
            String name = (String)map.get(str);
            System.out.println(str+" "+name);
        }

        TreeMap<String,String>treeMap = new TreeMap<>();//创建TreeMap集合对象
        treeMap.putAll(map); // 向集合中添加对象
        Iterator<String>iter = treeMap.keySet().iterator();
        System.out.println("TreeMap类实现的Map集合，键对象升序：");
        while (iter.hasNext()){
            String str = (String) iter.next();//获取集合中所有的Key对象
            String name = (String) treeMap.get(str); //获取集合中所有的Values对象
            System.out.println(str+" "+name);
        }
    }
}