Java基础之集合(Set、Map、Collections)

1. List集合

1.1 List接口介绍

java.util.List接口继承自Collection接口,是单列集合的一个重要分支,习惯性的会将实现了List接口的对象称为List集合.在List集合中允许出现重复的元素,所有的元素是一种线性方法进行存储的,在程序中可以通过索引来访问集合中的指定元素.另外,List集合还有一个特点就是元素有序,即元素的的存入顺序和取出顺序一致
List接口的特点:

• 它是一个元素存取有序的集合
• 他是一个带有索引的集合,通过索引就可以精准的操作集合中的元素(与数组的索引类似)
• 集合中可以有重复元素,通过元素的equals方法,比较是否为重复元素

1.2List接口中常用的方法

List作为Colkection集合的子接口,不但继承了Collection接口中的全部方法,而且还增加了一些根据元素索引来操作集合的特有方法

• public void add(int index,E element):将指定的元素,添加到该集合中的指定位置上.
• public E get(int index):返回集合中指定位置的元素
• public E remove(int index):移除列表中指定位置的元素,返回的是被移除的元素
• public E set(int index,E element):用指定的元素替换集合指定位置的元素,返回值是更新前的元素

2.List的子类

2.1 ArrayList集合

java.util.ArrayList集合数据存储的结构是数组结构,元素增删慢,查找块,由于日常开发中使用最多额功能为查询数据,遍历数据,所以ArrayList是最常用的集合

2.2 LinkedList集合

java.util.LinkedList集合数据存储的结构是链表结构,方便元素添加,删除的集合

LinkedList是一个是双向链表,特有方法有:

• public void addFirst(E e):将指定元素插入到此列表的开头
• public void addLast(Ｅｅ)：将指定元素添加到此列表的结尾
• public E getFirst():返回此列表的第一个元素
• public E getLast():返回此列表的最后一个元素
• Public E removeFirst():移除并返回此列表的第一个元素
• public E removeLast():移除并返回此列表的最后一个元素
• public boolean isEmpty():判断列表是否为空

3. Set接口

java.util.Set接口和java.util.List接口一样,同样继承自Collection接口,它与Collection接口中的方法基本一致,并没有对Collection接口进行功能上的扩充,只是比Collection接口更加严格了,与List接口不同的是,Set接口的元素无序,并且会一某种规则保证存入的元素不会重复

3.1 HashSet集合

java.util.HashSet是Set接口的一个实现类,它所存储的元素是不可重复的,并且元素都是无序的(即存取顺序不一致).java.util.HashSet底层是一个java.util.HashMap支持,
HashSet是根据对象的哈希值来确定元素在集合中的存储位置,因此具有良好的存取,和查找性能,保证元素的唯一性的方式依赖与:hashCode与equals方法

3.2 HashSet集合存储数据的结构(哈希表)

在jdk1.8之前,哈希表底层采用数组+链表实现,及使用链表处理冲突,同一hash值的链表都存储在一个链表里.但是当位于一个桶中的元素较多时,通过key值依次查找的效率较低.而jdk1.8中,哈希表存储采用数组+链表+红黑树实现,当链表长度超过阈值(8)时,将链表转换为红黑树,这样大大减少了查找时间

总而言之,jdk1.8引入红黑树大程度优化了HashMap的性能,对于我们来讲保证HashMap集合元素的唯一的其实就是根据对象的hashCode和equals方法来决定的.如果我们网集合中存放自定义的dui’xian对象,那么保证器唯一性就必须重写hashCode和equals方法建立当前对象的比较方式

3.3 LinkedHashSet

我们知道HashSet保证元素唯一,可是元素存放进去是没有顺序的,在HashSet下面有一个子类java.util.LinkedHashSet,它是链表和哈希表的一个数据存储结构剋保证元素有序

public class Test {
    public static void main(String[] args) {
        LinkedHashSet<String> linked = new LinkedHashSet<>();
        linked.add("abb");
        linked.add("aaa");
        linked.add("zbc");
        linked.add("bbc");
        Iterator<String> iterator = linked.iterator();
        if (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }
}

4. Map集合

4.1 概述

现实生活中,我们经常会看到这样的一种集合:ip和主机名,身份证号与用户名,系统用户名与系统对象等,这种一一对应的关系就叫做映射,Java提供了专门的集合类用来存放这种对象关系的对象,即java.util.Map接口

• Collection中的集合,元素是孤立存在的,向集合中存储元素采用一个个元素的方式存储.
• Map中的集合,元素是成对存在的.每个元素由键与值两部分组成,通过键可以找到对应所在的值
• Collection中的集合称为单列集合,Map中的集合称为双列集合.
• Map结合不能包含重复的键,值可以重复;每个键只能对应一个值

4.2 Map常用子类

• HashMap:存储数据采用的哈希表结构,元素的存取顺序不能保证一致,由于要保证键的唯一,不重复,需要重写键的hashCode方法和equals方法
• LinkedHashMap:HashMap下面有个子类LinkedHashMap,存储数据采用哈希表结构+链表结构,通过链表结构可以保证元素的存取顺序一致,通过哈希表结构可以保证键的唯一,不重复,需要重写键的hashCode方法和equals方法

4.3 Map接口中常用的方法

Map接口中定义了很多方法:

• public V put(K key V value):把指定的键与指定值添加在Map集合中方
• public V remove(Object key):把指定的键,所对应的键值对在Map集合中删除,返回被删除元素的值
• public V get(Object key):根据指定的键,在Map集合中获取对应的值
• public Set<k> keySet():获取Map集合中所有的键,存储到Set集合中
• public Set<Map.Entry<k,y>> entrySet():获取到Map集合中所有的键值对对象的集合(Set集合)

public class Test {
    public static void main(String[] args) {
       // 创建Map对象
        HashMap<String, String> map = new HashMap<>();
        // 添加元素到集合
        map.put("黄晓明","杨颖");
        map.put("文章","马伊琍");
        map.put("邓超","孙俪");
        System.out.println(map);
        // String remove(String key)
        System.out.println(map.remove("邓超"));
        System.out.println(map);
        System.out.println(map.get("黄晓明"));
        System.out.println(map.get("邓超"));

    }
}

4.4 Map集合遍历键找值的方法

键找值方式:即通过元素中的键,获取键所对应的值

分析步骤:

• 获取Map中所有的键,由于键是唯一的,所以返回一个Set集合存储所有的键
• 遍历键的Set集合,得到每一个键
• 根据键获取键所对应的值

public class Test {
    public static void main(String[] args) {
        // 创建Map集合
        HashMap<String, String> map = new HashMap<>();
        // 添加元素到集合
        map.put("胡歌", "霍建华");
        map.put("郭德纲", "于谦");
        map.put("薛之谦", "大张伟");
        // 获取所有的键
        Set<String> keys = map.keySet();
        // 遍历键集 得到每一个键
        for (String key : keys) {
            // key就是键 获取对应值
            String value = map.get(key);
            System.out.println(key + "=" + value);
        }
    }
}

4.5 Entry键值对对象

Map中存放的是里昂中法对象,一种是key,一种是value,它们在Map中是一一对应的关系,这一对对象又称为Map中的一个Entry(项).Entry将键值对的对应关系封装成了对象,即键值对对象,这样我们在遍历Map集合时,就可以从每一个键值对(Entry)对象中中获取对应的键与值

Entry对象也同样提供了获取对应键和对应值的方法

• public K getKey():获取Entry对象中的键
• public V getValue():获取Entry对象中的值

在Map集合中也提供了获取所有Entry对象的方法:

• public Set<Map.Entry<K,V>> oentrySet():获取到Map集合中所有导入键值对对象的集合(set集合)

4.6 Map集合遍历键值对方式

键值对方式:即通过集合中每个键值对(Entry)对象,获取键值对(Entry)对象中的键与值

分析步骤:

• 获取Map集合中所有导入键值对(Entry)对象,以Set集合形式返回
• 遍历包括键值对(Entry)对象的Set集合,得到每一个键值对(Entry)对象
• 通过键值对(Entry)对象,获取Entry对象中的键与值

public class Test {
    public static void main(String[] args) {
        // 创建Map集合
        HashMap<String, String> map = new HashMap<>();
        // 添加元素到集合
        map.put("胡歌", "霍建华");
        map.put("郭德纲", "于谦");
        map.put("薛之谦", "大张伟");
        // 获取所有的entry对象
        Set<Map.Entry<String, String>> entries = map.entrySet();
        // 遍历得到每一个entry对象
        for (Map.Entry<String, String> entry : entries) {
            String key = entry.getKey();
            String value = entry.getValue();
            System.out.println(key+"="+value);
        }
    }
}

5. Collections

5.1 常用功能

java.util.Collection时集合工具类,用来对集合进行操作.

• public static <T> boolean addAll(Collection<T>c,T...elements):往集合中添加一些元素
• public static void shuffle(List<?> list):打乱集合顺序
• public static <T> void sort(List<T> list):将集合中元素按照默认规则排序
• public static <T> void sort(List<T> list,comparator<? super T>):将集合中元素按照指定规则排序

public class Test {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        // 原来的写法
        list.add(12);
        list.add(14);
        list.add(15);
        list.add(1000);
        // 采用工具类往集合中添加元素
        Collections.addAll(list,5,22,1,2,6);
        System.out.println(list);
        // 排序
        Collections.sort(list);
        System.out.println(list);
        //刷新
        Collections.shuffle(list);
        System.out.println(list);
    }
}

5.2 Comparator比较器

排序简单来说就是两个对象之间比较大小,那么在java中提供了两种比较实现的方式,一种是比较死板的采用Java.lang.Comparable接口去实现,一种是比较灵活的当我需要做排序的时候在去选择的java.util.Comparator接口完成

我们采用的public static <T> void sort(List<T> list)这个方法完成的排序,实际上要求了被排序的类型需要实现Comparable接口完成比较功能,在String类型如下:
public final class String implements java.io.Serizlizablle,Comparable<String> ,CharSquence{}

String类实现了这个接口,并完成了比较规则的定义,但这样就把这种规则而写死了,想要自己修改规则不可能,这是就需要public static <T> void sort(List<T> list,Comparator<?super T>)方法灵活的完成,这里涉及到了Comparator这个接口,位于java.util包下,排序是comparator能实现的功能之一,该接口代表的一个比较器,比较器具有可比功能比较方法为public int compare(String o1,String o2):比较两个参数的顺序

public class Test {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list,"cda","aba","sba","nba");
        Collections.sort(list);
        System.out.println(list);
        // 排序方法 按照第一个单词的降序
        list.sort(new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o2.charAt(0)-o1.charAt(0);
            }
        });
        System.out.println(list);
    }
}

5.3 Comparable和Comparator接口的区别

Comparable:强行对实现他的每个类的对象进行整体排序.这种排序被称为类的自然排序,类的comparaTo方法被称为它的自然比骄方法.只能在类中实现comparaTo()一次,不能经常修改类的代码实现自己想要的排序.实现此接口的对象列表可以通过Collections.sort()进行自动排序,对象可以用作有序映射中的键或有序集合中的元素,无需指定比较器

Comparator:强行对某个对象进行整体排序,可以将Comparator传递给sort方法,从而允许在排序顺序上实现精准控制,还可以使用Comparator来控制某写数据结构的顺序,或者为那些没有自然顺序的对象collection提供顺序