Java-Java基础—（8）集合

1.集合

1.1集合和数组的区别

相同点：都是用来存放数据的容器

不同点：数组的长度是不可改变的，而集合的长度是可以改变的；数组存放基本类型数据和引用型数据，而集合存只可以放引用型数据

1.2集合的分类

集合可以分为：Collection（单列集合）、Map（多列集合）

Collection可以分为：List（可重复集合），Set（不可重复集合）

HashMap可以分为：ArrayList、LinkedList

Set可以分为：HashSet和TreeSet

Map可以分为：HashMap、TreeMap

2.Collection 集合

2.1概述

Collection集合是单例集合的顶层接口,它表示一组对象，JDK 不提供此接口的任何直接实现.它提供更具体的子接口(如Set和List)实现

Collection接口的具体实现类使用ArrayList类

2.2方法

Collection常用方法

方法名	说明
boolean add(E e)	添加元素
boolean remove(Object o)	从集合中移除指定的元素
boolean removeIf(Object o)	根据条件进行移除
void clear()	清空集合中的元素
boolean contains(Object o)	判断集合中是否存在指定的元素
boolean isEmpty()	判断集合是否为空
int size()	集合的长度，也就是集合中元素的个数

2.3遍历

1. 迭代器：集合的专用遍历方式

Iterator<E> iterator(): 返回此集合中元素的迭代器,通过集合对象的iterator()方法得到

Iterator中的常用方法：

        boolean hasNext(): 判断当前位置是否有元素可以被取出​

        E next(): 获取当前位置的元素,将迭代器对象移向下一个索引位置

        void remove()：删除迭代器对象当前指向的元素

增强for循环

2. 格式

​ for(集合/数组中元素的数据类型 变量名 : 集合/数组名) {

        ​ // 已经将当前遍历到的元素封装到变量中了,直接使用变量即可

​ }

3.List集合

3.1概述

List集合属于有序集合，可以通过索引查找数据，可以有重复的元素

3.2方法

方法名	描述
void add(int index,E element)	在此集合中的指定位置插入指定的元素
E remove(int index)	删除指定索引处的元素，返回被删除的元素
E set(int index,E element)	修改指定索引处的元素，返回被修改的元素
E get(int index)	返回指定索引处的元素

 3.3List实现集合

ArrayList集合：查询快，增删慢（详细查看基础-4）

LinkedList集合：查询慢、增删快

LinkedList集合方法：

方法名	说明
public void addFirst(E e)	在该列表开头插入指定的元素
public void addLast(E e)	将指定的元素追加到此列表的末尾
public E getFirst()	返回此列表中的第一个元素
public E getLast()	返回此列表中的最后一个元素
public E removeFirst()	从此列表中删除并返回第一个元素
public E removeLast()	从此列表中删除并返回最后一个元素

4.泛型

4.1概述

泛型：是JDK5中引入的特性，它提供了编译时类型安全检测机制；固定泛型，就将固定集合增添数据的数据类型。把运行时期的问题提前到了编译期间，而且避免了强制类型转换

如果指定多种数据类型，需要用逗号隔开

4.2泛型的定义

定义泛型类（规定了什么数据类型，当应用数据的时候就可以使用该数据类型的特用方法）

修饰符 class 类名<类型> {  }
public class ArrayList<String> {  }

定义泛型方法

修饰符 <类型> 返回值类型 方法名(类型 变量名) {  }

public class Test{
    public <T> void show(T t) {
        System.out.println(t);
    }
}

定义泛型接口

修饰符 interface 接口名<类型> {  }

public interface Test<T> {
    void show(T t);
}

4.3通配符

在泛型的位置写”？“，ArrayLise<?>表示在数据类型位置的ArrayList，它的元素可以匹配任何类型

通配符上限：<? extends 类型>表示可以匹配这个类型或者其子类的类型

通配符下线： <? super 类型>表示可以匹配这个类型或者其父类的类型

5.Set集合

5.1概述

Set集合为不可重复的元素，而且没有索引，不能通过普通for进行遍历

5.2遍历

可以通过迭代器和增强for循环进行遍历

5.3TreeSet集合

可以将元素按照规则进行排序：

        TreeSet()，根据元素的自然排序进行

        TreeSet(Comparator comparator) ，根据指定的比较器进行排序

5.4排序比较

自然排序Compatable：就是让元素所属的类实现Comparable接口，重写compareTo(T o)方法，重写是要注意排序规则必须按照要求的主要条件和次要条件来写

public int compareTo(Student o) {
        //按照对象的年龄进行排序
        //主要判断条件: 按照年龄从小到大排序
        int result = this.age - o.age;
        //次要判断条件: 年龄相同时，按照姓名的字母顺序排序
        result = result == 0 ? this.name.compareTo(o.getName()) : result;
        return result;
    }

比较器排序Comparator：让集合构造方法接收Comparator的实现类对象，重写compare(T o1,T o2)方法，重写方法时，一定要注意排序规则必须按照要求的主要条件和次要条件来写

        TreeSet<Teacher> ts = new TreeSet<>(new Comparator<Teacher>() {
            @Override
            public int compare(Teacher o1, Teacher o2) {
                //o1表示现在要存入的那个元素
                //o2表示已经存入到集合中的元素
              
                //主要条件
                int result = o1.getAge() - o2.getAge();
                //次要条件
                result = result == 0 ? o1.getName().compareTo(o2.getName()) : result;
                return result;
            }
        });

两种方法比较：

自然排序: 自定义类实现Comparable接口,重写compareTo方法,根据返回值进行排序

比较器排序: 创建TreeSet对象的时候传递Comparator的实现类对象,重写compare方法,根据返回值进行排序

在使用的时候,默认使用自然排序,当自然排序不满足现在的需求时,必须使用比较器排序

两种方式中关于返回值的规则

• 如果返回值为负数，表示当前存入的元素是较小值，存左边

• 如果返回值为0，表示当前存入的元素跟集合中元素重复了，不存

• 如果返回值为正数，表示当前存入的元素是较大值，存右边

5.5HashSet集合

HashSet集合，无序存取，不可以重复存储，没有索引，底层属于哈希表

哈希值：JDK根据对象的地址或者字符串或者数字算出来的int类型的数值，Object类中的public int hashCode()：返回对象的哈希码值，默认情况下，不同对象的哈希值是不同的。而重写hashCode()方法，可以实现让不同对象的哈希值相同。

HashSet集合存储自定义类型元素,要想实现元素的唯一,要求必须重写hashCode方法和equals方法

6.Map集合

6.1概述

Map集合：双列集合，一个键对应一个值，键不能重复，而值可以重复。

interface Map<K,V>  K：键的类型；V：值的类型

Map<String,String> map = new HashMap<String,String>();

//V put(K key, V value) 将指定的值与该映射中的指定键相关联
map.put("itheima001","林青霞");
map.put("itheima002","张曼玉");
map.put("itheima003","王祖贤");
map.put("itheima003","柳岩");

6.2方法

方法名	说明
V put(K key,V value)	添加元素
V remove(Object key)	根据键删除键值对元素
void clear()	移除所有的键值对元素
boolean containsKey(Object key)	判断集合是否包含指定的键
boolean containsValue(Object value)	判断集合是否包含指定的值
boolean isEmpty()	判断集合是否为空
int size()	集合的长度，也就是集合中键值对的个数

方法名	说明
V get(Object key)	根据键获取值
Set<K> keySet()	获取所有键的集合
Collection<V> values()	获取所有值的集合
Set<Map.Entry<K,V>> entrySet()	获取所有键值对对象的集合

 6.3遍历

//获取所有键的集合。用keySet()方法实现
Set<String> keySet = map.keySet();
//遍历键的集合，获取到每一个键。用增强for实现
for (String key : keySet) {
    //根据键去找值。用get(Object key)方法实现
    String value = map.get(key);
    System.out.println(key + "," + value);
}

//获取所有键值对对象的集合
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);
}

7.HashMap集合

HashMap底层是哈希表结构的，依赖hashCode方法和equals方法保证键的唯一，如果键要存储的是自定义对象，需要重写hashCode和equals方法

8.TreeMap集合

TreeMap底层是红黑树结构，依赖自然排序或者比较器排序,对键进行排序，如果键存储的是自定义对象,需要实现Comparable接口或者在创建TreeMap对象时候给出比较器排序规则

9.可变参数

介绍：方法的参数类型已经确定,个数不确定,我们可以使用可变参数，可变参数其实是一个数组

修饰符 返回值类型 方法名(数据类型… 变量名) {  }
public int sum(int... number){    }

10.创建不可变集合

在List、Set、Map接口中,都存在of方法,可以创建一个不可变的集合

在Map接口中,还有一个ofEntries方法可以提高代码的阅读性，首先会把键值对封装成一个Entry对象,再把这个Entry对象添加到集合当中

List<String> list = List.of("a", "b", "c", "d");
Set<String> set = Set.of("a", "b", "c", "d","a");
Map<String, String> map = Map.of("zhangsan", "江苏", "lisi", "北京", "wangwu", "天津");
Map<String, String> map = Map.ofEntries(Map.entry("zhangsan", "江苏"),Map.entry("lisi", "北京"));

11.Stream流

11.1Stream流的优点

直接阅读代码的字面意思即可完美展示无关逻辑方式的语义：获取流、过滤姓张、过滤长度为3、逐一打印，Stream流把真正的函数式编程风格引入到Java中，代码简洁

ArrayList<String> list = new ArrayList<String>();

list.add("林青霞");
list.add("张曼玉");
list.add("王祖贤");
list.add("柳岩");
list.add("张敏");
list.add("张无忌");

//Stream流来改进
list.stream().filter(s -> s.startsWith("张")).filter(s -> s.length() == 3).forEach(System.out::println);

11.2Stream流常用的方法

获取Stream流：创建一条流水线,并把数据放到流水线上准备进行操作

中间方法：流水线上的操作，一次操作完毕之后,还可以继续进行其他操作

终结方法：一个Stream流只能有一个终结方法，是流水线上的最后一个操作

11.3生成Stream流的方式

Collection：使用默认方法stream()生成流

Map：把Map转成Set集合，间接的生成流

数组：通过Arrays中的静态方法stream生成流

同种数据类型的多个数据：直接使用Stream的静态方法of(T... values)

11.4Stream流中间操作的方法

中间操作的意思是,执行完此方法之后,Stream流依然可以继续执行其他操作

方法名	说明
Stream<T> filter(Predicate predicate)	用于对流中的数据进行过滤
Stream<T> limit(long maxSize)	返回此流中的元素组成的流，截取前指定参数个数的数据
Stream<T> skip(long n)	跳过指定参数个数的数据，返回由该流的剩余元素组成的流
static <T> Stream<T> concat(Stream a, Stream b)	合并a和b两个流为一个流
Stream<T> distinct()	返回由该流的不同元素（根据Object.equals(Object) ）组成的流

 11.5Stream流终结的方法

终结操作的意思是,执行完此方法之后,Stream流将不能再执行其他操作

方法名	说明
void forEach(Consumer action)	对此流的每个元素执行操作
long count()	返回此流中的元素数

11.6Stream流收集方法

对数据使用Stream流的方式操作完毕后,可以把流中的数据收集到集合中

方法名	说明
R collect(Collector collector)	把结果收集到集合中

工具类Collectors提供了具体的收集方式

方法名	说明
public static <T> Collector toList()	把元素收集到List集合中
public static <T> Collector toSet()	把元素收集到Set集合中
public static Collector toMap(Function keyMapper,Function valueMapper)	把元素收集到Map集合中

---------------------------------------------------------------------------------------------------------------------------------

内容有部分存在书籍、课堂、网络记录，如有雷同纯属巧合