Java 集合 Collection

2023.02.20 星期一

1 集合 Collection

集合大家可以理解为可变长度的数组。
数组一定开辟大小，长度不可改变。

集合是可以根据向集合中增加数据，自动实现对集合进行扩容。

1.1 集合的功能

集合与数组一样，都是用来保存相同类型的大量数据。
现在使用集合，一般都会与泛型一起使用。使用泛型来约束集合中可以保存的数据类型。

1.2 集合的分类

在Java中根据集合的实现方式分为二个大类。

1 线性集合：java.util.Collection接口
所有集合中的数据都是按自身保存到集合中。
在Collection接口下面还有二个子接口:
java.util.List 有序，可重复。
java.util.Set 无序，不可重复。

2 键值映射：java.util.Map接口
所有集合中的数据（value），在保存到集合中时，都必须创建一个关键字（key）。

在Java集合中常用的接口有三个：List，Set，Map

1.3 常用的实现类

1 ArrayList类：线性集合中，使用最多的一个类。就是一个可变长度的数组。
2 LinkedList类：链表方式实现的线性集合。
3 HashSet类：Hash散列。
4 HashMap类：Hash算法的键值映射集合。按键找值。
5 TreeSet类：是一个有序的Set接口的实现类。
6 TreeMap类：是一个有序的Map接口的实现类。

1.4 ArrayList

所有集合就是一个容器。一个保存对象的容器。
针对一个容器对象，常用操作有哪些？放和取。

1 通过构造方法来创建实例。
ArrayList strList = new ArrayList<>();

2 向容器中保存对象。
strList.add(“”);
List集合是有序可重复。必须保证对象在集合中的顺序。
默认以增加顺序为标准。

3 从容器中取对象。
String s = strlist.get(1);
List集合是有序。ArrayList是一个可变长度的数组。
集合中的每个对象，都有自己的索引。按索引取对象。

4 动态获取集合大小
int i = strlist.size();

5 对集合进行迭代
版本一：老的方式

for(int i = 0 ;i < strlist.size();i++){
    System.out.println(strlist.get(i));
}

版本二：forEach

for (String str : strlist) {
    System.out.println(str);
}

1.5 List集合的排序

本身List集合是有序的。就可以对List集合中的元素进行排序操作。

1.5.1 String类型的集合的排序

针对List集合进行排序的方法是：Collections类的静态方法sort()

Collections.sort(strlist);//排序
System.out.println(strlist);

String类型的集合，为什么能被排序？
排序的前提是 能比较大小。 String类的二个对象之间是可以进行比较的。
String类中比较大小的方法叫
public int compareTo(String anotherString)
返回值：int a.compareTo(b);
=0 a=b
>0 a>b
<0 a<b
String 类的二个对象是通过调用compareTo方法的返回值进行大小的比较的。
String类能被比较大小。这是一种能力。接口代表了一种能力。
是因为String类中实现了Comparable接口。
Comparable接口我们称为比较器接口。

1.5.2 比较器接口

比较器接口，表示了一种可以进行比较的能力。
任何类实现了比较器接口，都表示这个类具备了比较大小的能力。
在集合中进行排序的前提条件是：能比较大小。

在Java中提供了二个比较器接口：
1 Comparable接口（内置比较器接口）
学生在学校默认都是按学号进行排序。
2 Comparator接口（外置比较器接口）
学校运动会。按跑步成绩进行排序。
一次摸底考试，按成绩排序。

1.5.3 内置比较器接口-Comparable

内置：是在实体类内部编写的比较规则。

public interface Comparable<T> {
    public int compareTo(T o);
}

让Stu这个需要被比较的类，实现Comparable接口，重写compareTo方法。

public class Stu implements Comparable<Stu>{
    private Integer id;
    private String name;
    private Double score;

    @Override
    /**
     * 返回值的作用：
     * >0   说明本对象大于o
     * =0   说明本对象与o相等
     * <0   说明本对象小于o
     */
    public int compareTo(Stu o) {
        return (this.id - o.id);
    }

因为内置比较器是在实体类中编写的。所以比较的规则只能有一种。

1.5.4 外置比较器接口-Comparator

外置比较器接口是对内置比较器接口规则的扩展。

@FunctionalInterface
public interface Comparator<T> {
	int compare(T o1, T o2);
}返回值：
>0  o1 > o2
=0  
<0  o1 < o2

外置比较器接口的使用。我们找一个非实体类去实现这个接口。
第一个这个接口的实现类，都是一种外置的比较规则。

/**
 * 按学员姓名进行比较的外置比较器实现类
 */
public class StuNameComparator implements Comparator<Stu> {
    @Override
    public int compare(Stu o1, Stu o2) {
        return o1.getName().compareTo(o2.getName());
    }
}
/**
 * 按学员成绩进行比较的外置比较器
 */
public class StuScoreComparator implements Comparator<Stu> {
    @Override
    public int compare(Stu o1, Stu o2) {
        if(o1.getScore() > o2.getScore()){
            return 1;
        }else{
            return -1;
        }
    }
}

调用Collections类的静态方法sort进行排序时，指定外置比较器规则。

Collections.sort(stuList,new StuScoreComparator());
System.out.println(stuList);

//按姓名的长度进行排序
Collections.sort(stuList, new Comparator<Stu>() {

@Override
    public int compare(Stu o1, Stu o2) {
        return o1.getName().length() - o2.getName().length();
    }
});
System.out.println(stuList);

1.6 HashSet类

Set接口中的常用类。
Set接口是一个无序，不可重复。

1 使用构造方法创建集合实例

public class HashSet<E>
    extends AbstractSet<E>
    implements Set<E>, Cloneable, java.io.Serializable {
	public HashSet() {
    		map = new HashMap<>();
	}
}

2 增加集合元素的方法
public boolean add(E e) 添加时，会验证元素是否重复。

Set集合本身是不能重复的。
如何判断二个元素是不是重复？ 
调用二个方法：hashCode  和  equals 二个方法。

3 获取集合元素个数
public int size()
4 没有取值方法
Set集合无序。不保证顺序，没有索引。
以前使用迭代器。现在因为有foreach的方式，所以迭代器基本不使用了。
5 针对Set集合一般都是进行遍历操作

//foreach循环
for (String s: strSet) {
    System.out.println(s);
}


Iterator<String> iterator = strSet.iterator();
while (iterator.hasNext()){
    String s = iterator.next();
    System.out.println(s);
}

1.7 HashMap类

Map接口的常用类。Map接口是一种K-V。键值映射的集合接口。
按键取值。
1 创建实例
HashMap<String , String> hashMap = new HashMap<>();

2 使用put方法添加元素
hashMap.put(“点名员”,“闫凯”);
hashMap.put(“活动委员”,“徐萌”);
hashMap.put(“点名员”,“史志鹏”);

添加元素时，必须保证HashMap集合中的key唯一，不可重复。
重复时直接覆盖原来的值。

3 使用get方法按key取value
//按key取value
String name = hashMap.get(“点名员”);
System.out.println(name);

4 迭代/遍历

旧：使用键的集合。
使用keySet()方法，将集合中所有的key取出来，形成了一个Set集合。

Set<String> keySet = hashMap.keySet();
for (String key : keySet) {
    String value = hashMap.get(key);
    System.out.println(key+":"+value);
}

新：Entry<String,String>来表示一组Key-Value的映射。
entrySet这个集合中的第一个元素是一组 Key-Value类型 的Entry对象。
每一个Entry对象都包含的二个部分：Key 和 Value。

Set<Map.Entry<String, String>> entrySet = hashMap.entrySet();
for (Map.Entry<String, String> entry : entrySet ) {
    String key = entry.getKey();
    String value = entry.getValue();
    System.out.println(key+":"+value);
}

1.8 hashCode()方法

hashCode()方法是返回当前对象的hash值。
Hash称为散列。一种数据结构。将一个容器。按规则分成多个容器。之后可以快速从多个容器的其中一个中查找数据。

例如：一个盒子存所有英文单词的图片。使用散列的方式用26个盒子保存单词图片。
HashSet与HashMap都是以散列的方式来保存数据。
以手查找都容易多了。
HashSet还是一个不可重复的Set集合。
调用Set集合的add方法向容器中添加对象时，要不要验证是不是有重复？一定要。

怎么找？先确定散列的盒子。再比较是否相等。
先确定散列的盒子调用hashCode()方法。
再比较是否相等调用equals()方法。

1.9 LinkedList类

一个以链表方式实现的集合类。
在插入和删除操作时效率要快于ArrayList类。

public static void main(String[] args) {
    LinkedList<String> linkedList = new LinkedList();
    linkedList.add("abc");
    linkedList.addFirst("first");
    linkedList.addLast("last");

    System.out.println(linkedList);
}

1.10 Queue接口

一样也是List接口的一个子接口。
表示是队列接口。队列是一种数据结构。先进先出（FIFO）。
LinkedList类就是Queue接口的实现类。

1 boolean offer(E e)
向队列中加对象

2 E poll()
检索并删除此队列的头，如果此队列为空，则返回 null 。

3 E peek()
检索但不删除此队列的头部，如果此队列为空，则返回 null 。

public static void main(String[] args) {
    Queue<String> queue = new LinkedList<>();
    //这是一个队列 。先进先出。
    queue.offer("a");
    queue.offer("d");
    queue.offer("c");

    String peek = queue.peek();
    System.out.println(peek);

    String poll = queue.poll();
    System.out.println(poll);

    int size = queue.size();
    System.out.println(size);
}

1.11 TreeSet类

TreeSet是一个有序的Set接口的实现类。
每放一个对象到TreeSet集合中，就进行一次排序。找到正确的位置。

1 使用构造方法创建实例。TreeSet集合的构造方法，需要指定排序规则。

public TreeSet()
构造一个新的，空的树组，根据其元素的自然排序进行排序。

public TreeSet(Comparator<? super E> comparator)
构造一个新的，空的树集，根据指定的比较器进行排序。

public static void main(String[] args) {
    TreeSet<String> strSet = new TreeSet<>(new Comparator<String>() {
        @Override
        public int compare(String o1, String o2) {
            return o1.length() - o2.length();
        }
    });
    strSet.add("dd");
    strSet.add("aaa");
    strSet.add("c");

    System.out.println(strSet);
}