第十三章：集合

ArrayList集合

集合概述

是一个容器 容器中可以存放任意类型的元素

集合类的特点

没有排序的功能，可以添加重复元素，按照添加的顺序进行遍历输出

Collection接口概述

Collection为集合的父类接口

Collection接口成员方法

1：添加功能

boolean add(Object obj):添加一个元素

boolean addAll(Collection c):将一个 集合中的所有元素添加到另一个集合中 （list.addAll(list2);）

添加功能示例

ArrayList<Person> perList = new ArrayList<>();

Person p1 = new Person("张三", 21);

perList.add(p1);//第一种添加方法

perList.add(new Person("李四", 25));//第二种添加方式

2:删除功能

void clear():移除所有元素

boolean remove(Object o):移除一个元素

boolean removeAll(Collection c):移除一个集合的元素(是一个还是所有)

3:判断功能

boolean contains(Object o)：判断集合中是否包含指定的元素

boolean containsAll(Collection c)：判断集合中是否包含指定的集合元素(是一个还是所有)

boolean isEmpty()：判断集合是否为空

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

Iterator<E> iterator()

Object next():获取元素,并移动到下一个位置。

boolean hasNext():如果仍有元素可以迭代，则返回 true。

迭代器示例

Iterator<Person> it = perList.iterator();

while(it.hasNext()){//判断集合中是否还有元素

Person p = it.next();//集合中的元素

System.out.println(p);

5:长度功能

int size():元素的个数

7：把集合转换为数组

Object[] toArray()

集合转换为数组示例：

Collection c = new ArrayList();

c.add("hello"); // Object obj = "hello"; 向上转型

c.add("world");

c.add("java");

// Object[] toArray():把集合转成数组，可以实现集合的遍历

Object[] objs = c.toArray();

for (int x = 0; x < objs.length; x++) {

// System.out.println(objs[x]);

/** 上面的实现不了，原因是Object中没有length()方法

* 我们要想使用字符串的方法，就必须把元素还原成字符串

*/向下转型

String s = (String) objs[x];

System.out.println(s + "---" + s.length());

}

List接口概述

没有排序的功能，可以添加重复元素，按照添加的顺序进行遍历输出

List接口成员方法

List集合的特有功能：

1:添加功能

void add(int index,Object element):在指定位置添加元素

2:获取功能

Object get(int index):获取指定位置的元素

System.out.println("get:" + list.get(1));

3:列表迭代器

ListIterator listIterator()：List集合特有的迭代器

该迭代器继承了Iterator迭代器，所以，就可以直接使用hasNext()和next()方法

4:删除功能

Object remove(int index)：根据索引删除元素,返回被

删除的元素

list.removeAll(reList);// 刪除兩個集合中的交集（刪除相同保留不同）

*5:修改功能

Object set(int index,Object element):根据索引修改元素，返回被修饰的元素

System.out.println("set:" + list.set(1, "javaee"));

6.排序功能Collections.sort(list);自然顺序进行排序

给对象排序注意事项：

1.必须要有Collections.sort(list); 排序方法（单独使用不能给对象进行排序）

2.如果排序的为对象，那么就是给对象的属性进行排序，

3.那么当前类必须实现一个接口（比较器Comparable） 比较一个对象的属性与另外一个对象的属性

7.最大值Collections.max(list));

8最小值Collections.min(list));

特有功能：

Object previous():获取上一个元素

boolean hasPrevious():判断是否有元素

注意：ListIterator可以实现逆向遍历，但是必须先正向遍历，才能逆向遍历，

Collection与Collections的区别

Collection:集合接口

Collections:类，专门为集合提供方法

集合中泛型的注意事项：

1.如果集合没有定义泛型，添加的元素可以为任意类型，如果定义了泛型 ，

2.添加的元素类型必须和定义的泛型一致，否则报错

3泛型中不能定义基本数据类型，必须定义引用数据类型

数组和集合类的区别？

数组虽然也可以存储对象，但长度是固定的；集合长度是可变的。数组中可以存储基本数据类型，集合可以存储不同类型的元素

集合类的特点

集合只用于存储对象，集合长度是可变的，集合可以存储不同类型的对象。

ArrayList类优点

底层数据结构是数组，查询快，增删慢

线程不安全，效率高

Vector:

底层数据结构是数组，查询快，增删慢。

线程安全，效率低。

LinkedList:

底层数据结构是链表，查询慢，增删快。

线程不安全，效率高。

List有三个儿子，我们到底使用谁呢?

看需求(情况)。

要安全吗?

要：Vector(即使要安全，也不用这个了，后面有替代的)

不要：ArrayList或者LinkedList

查询多：ArrayList

增删多：LinkedList

如果你什么都不懂，就用ArrayList。

LinkedList类概述

底层数据结构是链表，查询慢，增删快

线程不安全，效率高

LinkedList类特有功能

public void addFirst(E e)及addLast(E e)

public E getFirst()及getLast()

public E removeFirst()及public E removeLast()

ArrayList集合示例：

集合中提供两种遍历的方法： 1. iterator 2 .foreach

Iterator:迭代器遍历集合

1. Iterator<Person> it = perList.iterator();

while(it.hasNext()){//判断集合中是否还有元素

Person p = it.next();//集合中的元素

System.out.println(p);

2 .foreach 遍历集合

ArrayList<Double> douList = new ArrayList<>();

douList.add(12.5);

douList.add(3.5);

douList.add(1.3);

for(double d:douList){

System.out.println(d);

没有定义泛型通过 foreach：遍历集合中的元素

Collection co = new ArrayList();//多态的体现

for(Object obj:co){

System.out.println(obj);

定义集合

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

添加集合的两种方式

ArrayList<Person> perList = new ArrayList<>();

Person p1 = new Person("张三", 21);

1. erList.add(p1);//第一种添加方法

2. perList.add(new Person("李四", 25));//第二种添加方式

Set集合

Set集合扩展了Collection接口，不允许添加重复元素。如果集合有重复的元素，add()方法会返回false，

HashSet：

HashSet类实现了Set接口，不能添加重复元素，没有排序的功能

为什么不能添加重复元素？ 因为重写了hashCode()和equals()方法

先看hashCode()值是否相同

相同:继续走equals()方法

返回true： 说明元素重复，就不添加

返回false：说明元素不重复，就添加到集合

不同：就直接把元素添加到集合

如果类没有重写这两个方法，默认使用的Object()。一般来说不同相同。

而String类重写了hashCode()和equals()方法，所以，它就可以把内容相同的字符串去掉。只留下一个。

Set与List的区别：

1、Set中的元素不能重复，List中的元素可以重复。

2、List有索引（下标）的概念，Set没有索引的概念。

3、对于Set表示的集合，通常是遍历操作，没有get()和set()方法。

:Set集合(理解)总结

(1)Set集合的特点

无序,唯一

（ 2)HashSet集合(掌握)

A:底层数据结构是哈希表(是一个元素为链表的数组)

B:哈希表底层依赖两个方法：hashCode()和equals()

执行顺序：

首先比较哈希值是否相同

相同：继续执行equals()方法

返回true：元素重复了，不添加

返回false：直接把元素添加到集合

不同：就直接把元素添加到集合

C:如何保证元素唯一性的呢?

由hashCode()和equals()保证的

TreeSet集合：能够对元素按照元素的自然顺序进行排序，或者使用Comparable进行排序，取决于构造方法

TreeSet集合的特点：排序和唯一

(3)TreeSet集合

a:自然排序(元素具备比较性)

让元素所属的类实现Comparable接口

b:比较器排序(集合具备比较性)

让集合构造方法接收Comparator的实现类对象

|--Set 无序,唯一

|--HashSet

底层数据结构是哈希表。

如何保证元素唯一性的呢?

依赖两个方法：hashCode()和equals()

|--TreeSet

底层数据结构是红黑树。

如何保证元素排序的呢?

自然排序

比较器排序

如何保证元素唯一性的呢?

根据比较的返回值是否是0来决定

4:针对Collection集合我们到底使用谁呢?(掌握)

唯一的用Set

排序用TreeSet

如果你知道是Set，但是不知道是哪个Set，就用HashSet。

List集合使用：

安全： Vector

查询多：ArrayList

增删多：LinkedList

如果你知道是List，但是不知道是哪个List，就用ArrayList。

5:在集合中常见的数据结构(掌握)

ArrayXxx:底层数据结构是数组，查询快，增删慢

LinkedXxx:底层数据结构是链表，查询慢，增删快

HashXxx:底层数据结构是哈希表。依赖两个方法：hashCode()和equals()

TreeXxx:底层数据结构是二叉树。两种方式排序：自然排序和比较器排序

HashSet 集合示例：

HashSet<String> set = new HashSet<>();//创建一个set集合

set.add("你好");

set.add("你好");

for (String s : set) {//遍历集合

System.out.println(s);

}

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

TreeSet集合示例:

自然顺序排序

TreeSet<Integer> ts = new TreeSet<>();// 创建一个set集合

ts.add(20);

for (Integer i : ts) {

System.out.println(i);

}

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

比较器排序Comparable示例

用匿名类不类实现排序

创建集合对象

TreeSet<Student> ts = new TreeSet<Student>(new Comparator<Student>() {

比较器排序(集合具备比较性)让集合的构造方法接收一个比较器接口的子类对象 Comparator

用匿名内部类实现这个比较器排序

@Override

public int compare(Student s1, Student s2) {

if (s1.getAge() < s2.getAge()) {

return -1;

} else if (s1.getAge() > s2.getAge()) {

return 1;

}

return 0;

}

});

// 创建元素

Student s1 = new Student("付爽", 38);

Student s2 = new Student("李四", 29);

Student s3 = new Student("张三", 23);

Student s4 = new Student("王五", 27);

Student s5 = new Student("离了", 22);

Student s6 = new Student("王五我", 333);

// ts.add(new Student("王浩", 123));第二种：创建和添加元素

ts.add(s1);// 添加元素

ts.add(s2);

ts.add(s3);

ts.add(s4);

ts.add(s5);

ts.add(s6);

for (Student s : ts) {

System.out.println(s.getName() + "\t" + s.getAge());

}

}

}

Map集合

map集合的特点：将键映射到值得对象，一个映射不能包含重复的键，每个键最多只能映射一个值（键是唯一，值可以重复）

Map接口成员方法

1.添加元素 Vput(K key,V value)

2.删除功能 V remove(Object key)

3.判断功能 void clear() 移除所有的键值对元素

.boolean containsKey(Object key) 判断集合是否包含指定的键

boolean containsValue(Object value)判断集合是否包含指定的值

boolean isEmpty() 判断集合是否为空

4:获取功能

Set<Map.Entry<K,V>> entrySet():???

V get(Object key):根据键获取值

Set<K> keySet():获取集合中所有键的集合

Collection<V> values():获取集合中所有值的集合

5：长度功能

* int size()：返回集合中的键值对的对数

i nt size()

map:注意事项：

Map:key必须是唯一的，因为Map是通过key-->value

* 如果键（key）重复了，那么那么最后一个key会覆盖掉之前key值相同的元素，只保留最后一个重复的key==value

Map:第一种遍历方式

* 通过map.keySet() 获取Map的键值

* map.get(key):获取Map 的value值

*/

:Map(掌握)

(1)将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射到一个值。

(2)Map和Collection的区别?

A:Map 存储的是键值对形式的元素，键唯一，值可以重复。夫妻对

B:Collection 存储的是单独出现的元素，子接口Set元素唯一，子接口List元素可重复。

(4)Map集合的遍历

A:键找值

a:获取所有键的集合

b:遍历键的集合,得到每一个键

c:根据键到集合中去找值

B:键值对对象找键和值

a:获取所有的键值对对象的集合

b:遍历键值对对象的集合，获取每一个键值对对象

c:根据键值对对象去获取键和值

map集合示例：

根据键删除键值对元素，并把值返回

System.out.println("remove:" + map.remove("黄晓波"));

判断集合是否包含指定的键

System.out.println("containsKey:" + map.containsKey("黄晓明"));

判断集合是否为空

System.out.println("isEmpty:"+map.isEmpty());

集合长度 System.out.println("size:"+map.size());

输出集合名称

System.out.println("map:" + map);

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

获取集合中所有键和值的集合示例：

根据键获取value值

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

map.put("黄晓明", "在么");

map.put("李四", "王五");

System.out.println("get:" + map.get("周杰伦"));

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

获取集合中所有key（键）的值

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

map.put("黄晓明", "在么");

map.put("李四", "王五");

Set<String> set = map.keySet();//

for (String s : set) {

System.out.println(s);

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

获取集合中的所有value值

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

map.put("黄晓明", "在么");

map.put("李四", "王五");

Collection<String> co = map.values();//

for (String ss : co) {

System.out.println(ss);

遍历map集合的2种方式：

第一种遍历方式----------------------------

HashMap<String, String> h = new HashMap<>();

h.put("杨过", "小龙女");

h.put("老顽童", "黄蓉");

Set<String> set = h.keySet();// 获取所有键

for (String s : set) {

//String value = h.get(s);// 根据键去查找value值

//System.out.println(s + value);// 获取键和值

System.out.println(s+h.get(s));获取key和value值

第二种遍历方式--------------------------------

@Test

public void test2() {

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

map.put("杨过", "小龙女");

map.put("老顽童", "黄蓉");

//映射map集合中的key以及value

Set<Map.Entry<String, String>> set = map.entrySet();

for (Entry<String, String> en : set) {

//获取map集合中的key m.getValue()中的value值

System.out.println(en.getKey() + " " + en.getValue());