集合进阶

1. Collection

1.1集合知识回顾

集合类的特点:提供一种存储空间可变的存储模型，存储的数据容量可以随时发生改变

1.2集合类体系结构

• 矩形为接口

• 圆角矩形为实现类

1.3 Collection集合概述和使用

Collection集合概述

• 是单例集合的顶层接口，它表示一组对象，这些对象也称为Collection的元素
• JDK不提供此接口的任何直接实现，它提供更具体的子接口(如Set和List)实现

创建Collection集合的对象

• 多态的方式
• 具体的实现类ArrayList

import java.util.ArrayList;
import java.util.Collection;

public class demo {
    public static void main(String[] args) {
        //创建Collection集合对象
        Collection<String> c = new ArrayList<String>();

        //添加元素:boolean add(E e)
        c.add("hello");
        c.add("java");

        //输出集合对象
        System.out.println(c);
    }
}

1.4 Collection集合常用方法

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

1.5 Collection集合的遍历

lterator:迭代器，集合的专用遍历方式

• lterator<E> iterator():返回此集合中元素的迭代器，通过集合的iterator()方法得到

• 迭代器是通过集合的iterator()方法得到的，所以我们说它是依赖于集合而存在的

lterator中的常用方法

• E next():返回迭代中的下一个元素
• boolean hasNext():如果迭代具有更多元素，则返回true

Iterator<String> it = c.iterator();
        System.out.println(it.next());//hello
        System.out.println(it.next());//java
//        System.out.println(it.next());//异常NoSuchElementException

while (it.hasNext()) {
    System.out.println(it.next());
}

2. List

2.1 List集合概述和特点

List集合概述

• 有序集合(也称为序列)，用户可以精确控制列表中每个元素的插入位置。用户可以通过整数索引访问元素，并搜索列表中的元素
• 与Set集合不同，列表通常允许重复的元素

List集合特点

• 有序:存储和取出的元素顺序一致
• 可重复:存储的元素可以重复

2.2 List集合特有方法

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

2.3 并发修改异常

并发修改异常ConcurrentModificationException

• 产生原因
  迭代器遍历的过程中，通过集合对象修改了集合中元素的长度，造成了迭代器获取元素中判断预期修改值和实际修改值不一致
• 解决方案
  用for循环遍历，然后用集合对象做对应的操作即可

2.4 Listlterator

Listlterator：列表迭代器

• 通过List集合的listlterator)方法得到，所以说它是List集合特有的迭代器

• 用于允许程序员沿任一方向遍历列表的列表迭代器，在迭代期间修改列表，并获取列表中迭代器的当前位置

Listlterator中的常用方法

• E next():返回迭代中的下一个元素
• boolean hasNext():如果迭代具有更多元素，则返回true
• E previous():返回列表中的上一个元素
• boolean hasPrevious():如果此列表迭代器在相反方向遍历列表时具有更多元素，则返回true
• void add(E e):将指定的元素插入列表

2.5 增强for循环

增强for：简化数组和Collection集合的遍历

• 实现lterable接口的类允许其对象成为增强型for语句的目标
• 它是JDK5之后出现的，其内部原理是一个lterator迭代器

增强for的格式

• 格式:

for(元素数据类型变量名:数组或者Collection集合) {
    //在此处使用变量即可，该变量就是元素
}

• 范例:

int[] arr = {1,2,3,4,5};
for(int i:arr) {
	System.out.println(i);
}

2.6 数据结构

数据结构是计算机存储、组织数据的方式。是指相互之间存在一种或多种特定关系的数据元素的集合

2.7 常见数据结构之栈

• 数据进入栈模型的过程称为:压/进栈
• 数据离开栈模型的过程称为:弹/出栈
• 栈是一种数据先进后出的模型

2.8 常见数据结构之队列

• 数据从后端进入队列模型的过程称为:入队列
• 数据从前端离开队列模型的过程称为:出队列
• 队列是一种数据先进先出的模型

2.9 常见数据结构之数组

• 查询数据通过索引定位，查询任意数据耗时相同，查询速度快
• 删除数据时，要将原始数据删除，同时后面每个数据前移，删除效率低
• 添加数据时，添加位置后的每个数据后移，再添加元素，添加效率极低

数组是一种查询快，增删慢的模型

2.10 常见数据结构之链表

• 链表是一种增删快的模型(对比数组)

• 链表是一种查询慢的模型(对比数组)

2.11 List集合子类特点

List集合常用子类：ArrayList,LinkedList

• ArrayList:底层数据结构是数组，查询快，增删慢
• LinkedList:底层数据结构是链表，查询慢，增删快

2.12 LinkedList集合的特有功能

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

3. Set

3.1 Set集合概述和特点

set是一个接口，不能直接示例化

3.2 哈希值

哈希值：是JDK根据对象的地址或者字符串或者数字算出来的int类型的数值

• Object类中有一个方法可以获取对象的哈希值

  publicint hashCode():返回对象的哈希码值

• 对象的哈希值特点

  • 同一个对象多次调用hashCode(方法返回的哈希值是相同的
  • 默认情况下，不同对象的哈希值是不同的。而重写hashCode()方法，可以实现让不同对象的哈希值相同

3.3 HashSet集合概述和特点HashSet集合特点

• 底层数据结构是哈希表
• 对集合的迭代顺序不作任何保证，也就是说不保证存储和取出的元素顺序一致
• 没有带索引的方法，所以不能使用普通for循环遍历（但可以使用迭代器增强for循环）
• 由于是Set集合，所以是不包含重复元素的集合

public class demo {
    public static void main(String[] args) {
        //创建HashSet集合对象
        HashSet<String> hs = new HashSet<>();
        //添加集合元素
        hs.add("hello");
        hs.add("world");
        hs.add("java");
        
        hs.add("world");
        //增强for循环遍历集合元素
        for (String s : hs) {
            System.out.println(s);
        }
    }
}

输出：

world
java
hello

3.4 HashSet集合保证元素唯─性源码分析

HashSet集合添加一个元素的过程:

HashSet集合存储元素:

• 要保证元素唯一性，需要重写hashCode()和equals()（自动生成即可）

3.5常见数据结构之哈希表

哈希表

• JDK8之前，底层采用数组+链表实现，可以说是一个元素为链表的数组
• JDK8以后，在长度比较长的时候，底层实现了优化

3.6 LinkedHashSet集合概述和特点

LinkedHashSet集合特点

• 哈希表和链表实现的Set接口，具有可预测的迭代次序

• 由链表保证元素有序，也就是说元素的存储和取出顺序是一致的

• 由哈希表保证元素唯一，也就是说没有重复的元素

3.7 TreeSet集合概述和特点

TreeSet集合特点

• 元素有序，这里的顺序不是搭存储和取出的顺序，而是按照一定的规则进行排序，具体排序方式取决于构造方法
  • TreeSet():根据其元素的自然排序进行排序
  • TreeSet(Comparator comparator):根据指定的比较器进行排序
• 没有带索引的方法，所以不能使用普通for循环遍历
• 由于是Set集合，所以不包含重复元素的集合

public class demo {
    public static void main(String[] args) {
        //创建TreeSet集合对象
        TreeSet<Integer> ts = new TreeSet<>();
        //添加集合元素
        ts.add(1);
        ts.add(3);
        ts.add(2);

        ts.add(3);
        //遍历集合元素
        for (int s : ts) {
            System.out.println(s);
        }
    }
}

3.8 自然排序Comparable的使用

存储学生对象并遍历，创建TreeSet集合使用无参构造方法
要求:按照年龄从小到大排序，年龄相同时，按照姓名的字母顺序排序

//Student类
package com.demo;

import java.util.Objects;

public class Student implements Comparable<Student> {
    String name;
    int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Student() {
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

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

    public void setAge(int age) {
        this.age = age;
    }
    //重写compareTo()方法，自定义排序
    @Override
    public int compareTo(Student s) {
        int num = this.age - s.age;
        int num2 = num == 0 ? this.name.compareTo(s.name) : num;
        return num2;
    }
}

//测试类
package com.demo;

import java.util.TreeSet;


public class demo {
    public static void main(String[] args) {
        //创建TreeSet集合对象
        TreeSet<Student> ts = new TreeSet<>();
        //创建Student元素
        Student s1 = new Student("zhangsan", 20);
        Student s2 = new Student("lisi", 19);
        Student s3 = new Student("wangwu", 20);

        Student s4 = new Student("zhangsan", 20);

        //添加集合元素
        ts.add(s1);
        ts.add(s2);
        ts.add(s3);

        ts.add(s4);
        //遍历集合元素
        for (Student s : ts) {
            System.out.println(s.getName()+":"+s.getAge());
        }
    }
}

输出：

lisi:19
wangwu:20
zhangsan:20

进程已结束,退出代码0

结论

• 用TreeSet集合存储自定义对象，无参构造方法使用的是自然排序对元素进行排序的
• 自然排序，就是让元素所属的类实现Comparable接口，重写compareTo(T o)方法
• 重写方法时，一定要注意排序规则必须按照要求的主要条件和次要条件来写

3.9 比较器排序Comparator的使用

存储学生对象并遍历，创建TreeSet集合使用带参构造方法
要求:按照年龄从小到大排序，年龄相同时，按照姓名的字母顺序排序

//Student类
package com.demo;

import java.util.Objects;

public class Student {
    String name;
    int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Student() {
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

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

    public void setAge(int age) {
        this.age = age;
    }
}

//Student测试类
package com.demo;

import java.util.Comparator;
import java.util.TreeSet;


public class demo {
    public static void main(String[] args) {
        //创建TreeSet集合对象，使用匿名内部类定义排序方法
        TreeSet<Student> ts = new TreeSet<Student>(new Comparator<Student>() {
            @Override
            public int compare(Student s1, Student s2) {
                int num = s1.getAge() - s2.getAge();
                int num2 = num == 0 ? s1.getName().compareTo(s2.getName()) : num;
                return num2;
            }
        });
        //创建Student元素
        Student s1 = new Student("zhangsan", 20);
        Student s2 = new Student("lisi", 19);
        Student s3 = new Student("wangwu", 20);

        Student s4 = new Student("zhangsan", 20);

        //添加集合元素
        ts.add(s1);
        ts.add(s2);
        ts.add(s3);

        ts.add(s4);
        //遍历集合元素
        for (Student s : ts) {
            System.out.println(s.getName()+":"+s.getAge());
        }
    }
}

输出：

lisi:19
wangwu:20
zhangsan:20

进程已结束,退出代码0

结论

• 用TreeSet集合存储自定义对象，带参构造方法使用的是比较器排序对元素进行排序的
• 比较器排序，就是让集合构造方法接收Comparator的实现类对象，重写compare(T o1,T o2)方法
• 重写方法时，一定要注意排序规则必须按照要求的主要条件和次要条件来写

4. 泛型

4.1 泛型概述

泛型:是JDK5中引入的特性，它提供了编译时类型安全检测机制，该机制允许在编译时检测到非法的类型

它的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数

一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。那么参数化类型怎么理解呢?

顾名思义，就是将类型由原来的具体的类型参数化，然后在使用/调用时传入具体的类型

这种参数类型可以用在类、方法和接口中，分别被称为泛型类、泛型方法、泛型接口

• 泛型定义格式:
  • <类型>:指定一种类型的格式。这里的类型可以看成是形参
  • <类型1,类型2…>∶指定多种类型的格式，多种类型之间用逗号隔开。
  • 这里的类型可以看成是形参将来具体调用时候给定的类型可以看成是实参，并且实参的类型只能是引用数据类型
• 泛型的好处:
  • 把运行时期的问题提前到了编译期间避免了强制类型转换

4.2 泛型类

泛型类的定义格式:

格式:修饰符 class 类名<类型>{}

范例: public class Generic<T> { }
此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型（T代表类型、E代表元素、K代表键、V代表值）

4.3 泛型方法

泛型方法的定义格式:
格式:修饰符 <类型> 返回值类型 方法名(类型 变量名){ }

范例: public <T> void show(T t) { }

4.4 泛型接口

泛型接口的定义格式:

• 格式:修饰符 interface 接口名 <类型>{ }
• 范例: public interface Generic<T> { }

4.5类型通配符

为了表示各种泛型List的父类，可以使用类型通配符

• 类型通配符:<?>
• List<?>:表示元素类型未知的List，它的元素可以匹配任何的类型
• 这种带通配符的List仅表示它是各种泛型List的父类，并不能把元素添加到其中

如果说我们不希望List<?>是任何泛型List的父类，只希望它代表某类泛型List的父类，可以使用类型通配符的上限

• 类型通配符上限:<? extends类型>
• List<? extends Number>:它表示的类型是Number或者其子类型

除了可以指定类型通配符的上限，我们也可以指定类型通配符的下限

• 类型通配符下限:<? super类型>
• List<? super Number>:它表示的类型是Number或者其父类型

4.6可变参数

可变参数又称参数个数可变，用作方法的形参出现，那么方法参数个数就是可变的了

• 格式:修饰符 返回值 类型方法名(数据类型...变量名) {}
• 范例: public static int sum(int...a) {}

可变参数注意事项

• 这里的变量其实是一个数组
• 如果一个方法有多个参数，包含可变参数，可变参数要放在最后

4.7 可变参数的使用

Arrays工具类中有一个静态方法:

• public static <T> List<T> asList(T.. a):返回由指定数组支持的固定大小的列表

• 返回的集合不能做增删操作，可以做修改操作

List接口中有一个静态方法:

• public static <E> List<E> of(E... elements):返回包含任意数量元素的不可变列表

• 返回的集合不能做增删改操作

Set接口中有一个静态方法:

• public static <E> Set<E> of(E... elements):返回一个包含任意数量元素的不可变集合

• 在给元素的时候，不能给重复的元素

• 返回的集合不能做增删操作，没有修改的方法

5. Map

5.1 Map集合概述和使用

Map集合概述

• Interface Map<K,V> K:键的类型;V:值的类型
• 将键映射到值的对象;不能包含重复的键;每个键可以映射到最多一个值（当一个键被赋值第二次时，会替换掉原来的值）
• 举例:学生的学号和姓名
  beijin001 林青霞
  beijin002 张曼玉
  beijin003 王祖贤
• 创建Map集合的对象
  • 多态的方式
  • 具体的实现类HashMap

5.2 Map集合的基本功能

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

5.3 Map集合的获取功能

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

5.4 Map集合的遍历(方式1)

我们刚才存储的元素都是成对出现的，所以我们把Map看成是一个夫妻对的集合

遍历思路:

• 把所有的丈夫给集中起来
• 遍历丈夫的集合，获取到每一个丈夫根据丈夫去找对应的妻子

转换为Map集合中的操作:

• 获取所有键的集合。用keyset()方法实现

• 遍历键的集合，获取到海一个键。

• 用增强for实现根据键去找值。用get(Object key)方法实现

5.5 Map集合的遍历(方式2)

我们刚才存储的元素都是成对出现的，所以我们把Map看成是一个夫妻对的集合

遍历思路:

• 获取所有结婚证的集合
• 遍历结婚证的集合，得到每一个结婚证根据结婚证获取丈夫和妻子

转换为Map集合中的操作:

• 获取所有键值对对象的集合
  • Set<Map.Entry<K,V> > entrySet():获取所有键值对对象的集合
• 遍历键值对对象的集合，得到每一个键值对对象
  • 用增强for实现，得到每一个Map.Entry
• 根据键值对对象获取键和值
  • 用getKey()得到键
  • 用getValue()得到值

import java.util.HashMap;
import java.util.Map;
import java.util.Set;


public class demo {
    public static void main(String[] args) {
        //创建集合对象
        Map<String, String> map = new HashMap<String, String>();
        //添加集合元素
        map.put("1", "1");
        map.put("2", "2");
        map.put("3", "3");
        //获取所有键值对对象的集合
        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);
        }
    }
}

6. Collections

6.1 Collections概述和使用

Collections类的概述

• 是针对集合操作的工具类

Collections类的常用方法

• public static <T extends Comparable<? super T>> void sort(List<T> list):将指定的列表按升序排序
• public static void reverse(List<?> list):反转指定列表中元素的顺序
• public static void shuffle(List<?> list):使用默认的随机源随机排列指定的列表

最后

以上就是简单斑马为你收集整理的我的Java学习笔记（五）----集合进阶集合进阶的全部内容，希望文章能够帮你解决我的Java学习笔记（五）----集合进阶集合进阶所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。