08-java集合

来源：http://wegocoding.top/article/java-10/

集合概述

集合像是一个容器，专门用来存储任意数据类型的，且长度可变的对象。集合照其存储结构可分为单列集合Collection和双列集合Map。

• Collection（单列集合根接口）：存储一系列符合某种规则的元素。重要的两个子接口：

  • List：List集合特点是元素有序，可重复。主要实现类：ArrayList、LinkedList
  • Set：元素无序且不可重复。实现类：HashSet、TreeSet

• Map（双列集合根接口）：用于存储具有键(Key)、值(Valuel)映射关系的元素。key是唯一的，Map主要实现类为：HashMap、TreeMap.

Collection接口

List接口

ArrayList

ArrayList接口是List接口的一个实现类，最常见的一种集合。ArrayList内部封装了一个长度可变的数组对象，因其内部存储结构是数组形式，不适合做大量的增删操作。但允许通过索引访问元素，集合遍历和查找元素非常高效。

ArrayList的一些常用的特有方法：

方法	功能
void add(int index, Object elem)	将元素elem插入集合的指定索引位置
Object get(int index)	返回集合索引index处的元素
Object[] toArray()	将集合转换为数组
default void sort(Comparator<? super E> e)	根据指定的比较器规则对集合元素排序

ArrayList list = new ArrayList();
list.add("s1");
list.add("s2");
list.add("s3");
System.out.println("list：" + list);
System.out.println("list的长度：" + list.size());
System.out.println("第2个元素：" + list.get(1));

/* 集合遍历 */
// 获取Iterator对象
Iterator it = list.iterator();
while (it.hasNext()) {
    
    
    sout(it.next()); // 取出
}
...
for(Object o:list) {
    
    
    sout(o);
}
...
list.forEach(obj->sout("迭代元素："+obj));

LinkedList

为克服ArrayList集合增删效率低的局限，使用List的LinkedList实现类。其内部存储结构是一个双向循环链表。

方法	功能
void add(int index, Object elem)	将元素elem插入集合的指定索引位置
boolean offer(Object o)	将指定元素添加到集合的结尾
void push(Object o)	将指定元素添加到开头
Object pop()	移除并返回集合的第一个元素
Object peek()	获取第一个元素

LinkedList link = new LinkedList();
link.add("a");
....
link.offer("b");  // 将指定元素添加到集合的结尾
link.push("c");  //将指定元素添加到开头

Set接口

Set集合的元素无序且不重复。Set接口主要两个实现类HashSet、TreeSet。

HashSet集合

HashSet根据对象的哈希值确定元素在集合中的存储位置，具有良好的存取和查找性能。HashSet添加元素（调用add()方法）：

• 1.调用该元素的hashCode()获得对象的哈希值
• 2.根据其哈希值计算出一个存储位置
• 3.再调用元素对象的equals()方法来确保该位置没有重复元素。

注意

在存入对象时，需要重写Object类的hashCode()和equals()，以保证HashSet正常工作。

重写hashCode()、equals()

class Student {
    
    
    private String id;
    private String name;
    public Student(String id, String name) {
    
    
        this.id = id;
        this.name = name;
    }
    @Override
    public String toString() {
    
    
        return id+":"+name;
    }
    @Override
    public int hashCode() {
    
    
        return id.hashCode();
    }
    @Override
    public boolean equals(Object obj) {
    
    
        if(this==obj) return true;
        if(!(obj instanceof Student)) return false;

        Student stu = (Student) obj;
        return this.id.equals(stu.id);
    }
}
public class E3 {
    
    
    public static void main(String[] args) {
    
    
        Student s1 = new Student("1", "James");
        Student s2 = new Student("1", "James");
        Student s3 = new Student("2", "Durate");
        HashSet hs = new HashSet();
        hs.add(s1);
        hs.add(s2);
        hs.add(s3);
        System.out.println(hs);

    }
}

TreeSet集合

Set接口的另一实现类，内部采用平衡二叉树来存储元素，保证无重复元素，且可对元素进行排序。不论元素的添加顺序如何，这些元素都按一定顺序排列。相对元素排序就必须实现CompareTo()方法。Java中大部分类（Integer、Double、String等）都实现了该方法。

自定义类型实现Compareble接口

• 自然排序：要求向TreeSet集合中存储的元素所在的类必须实现Compareble接口，并重写compareTo()方法，然后该类型元素使用该方法进行比较，默认升序排序
• 定制排序：自定义一个比较器对元素进行特定的排序

/*自然排序*/
class Teacher implements Comparable {
    
    
    String name;
    int age;

    public Teacher(String name, int age) {
    
    
        this.age = age;
        this.name = name;
    }
    @Override
    public String toString() {
    
    
        return name + ":" + age;
    }

    public int compareTo(Object o) {
    
    
        Teacher t = (Teacher) o;
        // 定义比较方式，线比较年龄再比较name
        if (this.age - t.age > 0) {
    
    
            return 1;
        }
        if (this.age - t.age == 0) {
    
    
            return this.name.compareTo(t.name);
        }

        return -1;
    }
}
public class E6 {
    
    
    public static void main(String[] args) {
    
    
        TreeSet tr = new TreeSet();
        tr.add(new Teacher("Jack", 34));
        tr.add(new Teacher("Cobe", 40));
        tr.add(new Teacher("Jack", 29));
        System.out.println(tr);

    }
}

/*定制排序*/
class MyComparator implements Comparator {
    
    
    // 定义比较器实现Comparator接口

    @Override
    public int compare(Object o1, Object o2) {
    
    
        // 定制排序方式：字符串按照长度排序，不是按照字母顺序
        String s1 = (String) o1;
        String s2 = (String) o2;
        int temp = s1.length() - s2.length();
        return temp;
    }
}

public class E7 {
    
    
    public static void main(String[] args) {
    
    
        // 1. 创建集合时传入Comparator接口实现定制排序规则
        TreeSet tr = new TreeSet(new MyComparator());
        tr.add("lucy");
        tr.add("Hello");
        tr.add("Eve");
        System.out.println(tr);

        // 2. 使用Lambda表达式定制排序规则
        TreeSet tr2 = new TreeSet((obj1, obj2)->{
    
    
            String s1 = (String)obj1;
            String s2 = (String)obj2;
            return s1.length()-s2.length();
        });
        tr2.add("james");
        tr2.add("harden");
        tr2.add("Lin");
        System.out.println(tr2);
    }
}

Map集合和概述与使用

Map概述

• Interface Map<K,V> K: 键的类型；V：值的类型
• 将键映射到值的对象；不能包含重复的键；每个键可以映射到最多一个值

Map集合基本功能

Map集合的获取功能

// 遍历方式1: 获取键集合，通过键获取值
 for (String key : keyset) {
    
    
     String value = map.get(key);
     System.out.println(key + "," + value);
 }

 // 遍历方式2：获取键值对集合
 Set<Map.Entry<String, String>> entrySet = map.entrySet();
 for (Map.Entry<String, String> me : entrySet) {
    
    
     String key = me.getKey();
     String value = me.getValue();
     System.out.println(key + "," + value);

 }

Collections

Collection: 单例集合的底层接口
Collections：针对集合操作的工具类