java集合框架（容器集合）

Collection集合

数组和集合的区别【理解】

相同点
都是容器,可以存储多个数据
不同点
数组的长度是不可变的,集合的长度是可变的
数组可以存基本数据类型和引用数据类型
集合只能存引用数据类型,如果要存基本数据类型,需要存对应的包装类

集合类体系结构【理解】

Collection 集合概述和使用【应用】

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

创建Collection集合的对象：
1.多态的方式
2.具体的实现类ArrayList

Collection集合常用方法

Collection集合的遍历【应用】

迭代器介绍

   1.迭代器,集合的专用遍历方式：
   2.  Iterator iterator(): 返回此集合中元素的迭代器,通过集合对象的iterator()方法得到

Iterator中的常用方法：
…boolean hasNext(): 判断当前位置是否有元素可以被取出 E next(): 获取当前位置的元素,将迭代器对象移向下一个索引位置

Collection集合的遍历：
public class IteratorDemo1 {
public static void main(String[] args) {
//创建集合对象
Collection<String> c = new ArrayList<>();
//添加元素
c.add("hello");
c.add("world");
c.add("java");
c.add("javaee");
//Iterator<E> iterator()：返回此集合中元素的迭代器，通过集合的iterator()方法得到
Iterator<String> it = c.iterator();
//用while循环改进元素的判断和获取
while (it.hasNext()) {
String s = it.next();
System.out.println(s);
}
}
}

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

	terator<String> it = list.iterator();
	while(it.hasNext()){
	String s = it.next();
	if("b".equals(s)){
	//指向谁,那么此时就删除谁.
	it.remove();
	}

增强for循环【应用】

介绍：
1.它是JDK5之后出现的,其内部原理是一个Iterator迭代器
2.实现Iterable接口的类才可以使用迭代器和增强for
3.简化数组和Collection集合的遍历

格式:
for(集合/数组中元素的数据类型 变量名 : 集合/数组名) {
// 已经将当前遍历到的元素封装到变量中了,直接使用变量即可
}

public class MyCollectonDemo1 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("a");
list.add("b");
list.add("c");
list.add("d");
list.add("e");
list.add("f");
//1,数据类型一定是集合或者数组中元素的类型
//2,str仅仅是一个变量名而已,在循环的过程中,依次表示集合或者数组中的每一个元素
//3,list就是要遍历的集合或者数组
for(String str : list){
System.out.println(str);
}
}
}

List集合

List集合的概述和特点【记忆】

List集合的概述
1.有序集合,这里的有序指的是存取顺序
2.用户可以精确控制列表中每个元素的插入位置,用户可以通过整数索引访问元素,并搜索列表中的元素
3.与Set集合不同,列表通常允许重复的元素

List集合的特点:
存取有序
可以重复
有索引

List集合的特有方法【应用】

List集合的实现类

List集合子类的特点【记忆】

ArrayList集合: 底层是数组结构实现，查询快、增删慢
LinkedList集合 :底层是链表结构实现，查询慢、增删快

LinkedList集合的特有功能【应用】

Set集合

Set集合概述和特点【应用】

不可以存储重复元素
没有索引,不能使用普通for循环遍历

Set集合的使用【应用】

存储字符串并遍历

public class MySet1 {
public static void main(String[] args) {
//创建集合对象
Set<String> set = new TreeSet<>();
//添加元素
set.add("ccc");
set.add("aaa");
set.add("aaa");
	set.add("bbb");
// for (int i = 0; i < set.size(); i++) {
// //Set集合是没有索引的，所以不能使用通过索引获取元素的方法
// }
//遍历集合
Iterator<String> it = set.iterator();
while (it.hasNext()){
String s = it.next();
System.out.println(s);
}
System.out.println("‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐");
for (String s : set) {
System.out.println(s);
}
}
}

TreeSet集合

TreeSet集合概述和特点【应用】

1.不可以存储重复元素
2.没有索引
3.可以将元素按照规则进行排序:
TreeSet()：根据其元素的自然排序进行排序
TreeSet(Comparator comparator) ：根据指定的比较器进行排序

TreeSet集合基本使用【应用】

public class TreeSetDemo01 {
public static void main(String[] args) {
//创建集合对象
TreeSet<Integer> ts = new TreeSet<Integer>();
//添加元素
ts.add(10);
ts.add(40);
ts.add(30);
ts.add(50);
ts.add(20);
ts.add(30);
//遍历集合
for(Integer i : ts) {
System.out.println(i);
}
}
}

自然排序Comparable的使用【应用】

案例需求

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

实现步骤

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

比较器排序Comparator的使用【应用】

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

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

HashSet集合

HashSet集合概述和特点【应用】

底层数据结构是哈希表
存取无序
不可以存储重复元素
没有索引,不能使用普通for循环遍历

HashSet集合的基本应用【应用】

存储字符串并遍历

// 如果总分一样,各科成绩也都一样,就按照姓名排序
result = result == 0 ? o.getName().compareTo(this.getName()) : result;
return result;
}
}
public class TreeSetDemo {
public static void main(String[] args) {
//创建TreeSet集合对象，通过比较器排序进行排序
TreeSet<Student> ts = new TreeSet<Student>();
//创建学生对象
Student s1 = new Student("jack", 98, 100, 95);
Student s2 = new Student("rose", 95, 95, 95);
Student s3 = new Student("sam", 100, 93, 98);
//把学生对象添加到集合
ts.add(s1);
ts.add(s2);
ts.add(s3);
//遍历集合
for (Student s : ts) {
System.out.println(s.getName() + "," + s.getChinese() + "," + s.getMath() + ","
+ s.getEnglish() + "," + s.getSum());
	}
}
}
public class HashSetDemo {
public static void main(String[] args) {
//创建集合对象
HashSet<String> set = new HashSet<String>();
//添加元素
set.add("hello");
set.add("world");
set.add("java");

哈希值【理解】

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

如何获取哈希值
Object类中的public int hashCode()：返回对象的哈希码值

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

哈希表结构【理解】
JDK1.8以前
数组 + 链表

DK1.8以后
节点个数少于等于8个：数组 + 链表
节点个数多于8个：数组 + 红黑树

HashSet遍历

可以用增强for循环
HashSet集合存储自定义类型元素,要想实现元素的唯一,要求必须重写hashCode方法和equals方法

Map集合

Map集合概述和特点【理解】

Map集合概述：
interface Map<K,V> K：键的类型；V：值的类型

Map集合的特点
双列集合,一个键对应一个值
键不可以重复,值可以重复

Map集合的基本使用

public class MapDemo01 {
public static void main(String[] args) {
//创建集合对象
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","柳岩");
//输出集合对象
System.out.println(map);
}
}

Map集合的基本功能【应用】（方法介绍）

Map集合的获取功能【应用】

Map集合的遍历(方式1)【应用】

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

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

步骤分析
1.获取所有键的集合。用keySet()方法实现
2.遍历键的集合，获取到每一个键。用增强for实现
3.根据键去找值。用get(Object key)方法实现

代码实现

public class MapDemo01 {
public static void main(String[] args) {
//创建集合对象
Map<String, String> map = new HashMap<String, String>();
//添加元素
map.put("张无忌", "赵敏");
map.put("郭靖", "黄蓉");
map.put("杨过", "小龙女");
//获取所有键的集合。用keySet()方法实现

Map集合的遍历(方式2)【应用】

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

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

步骤分析
1.获取所有键值对对象的集合
.Set> entrySet()：获取所有键值对对象的集合
2.遍历键值对对象的集合，得到每一个键值对对象
用增强for实现，得到每一个Map.Entry
3.根据键值对对象获取键和值
.用getKey()得到键
用getValue()得到值

代码实现

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

Collections集合工具类

• Collections类的作用

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

• Collections类常用方法
  

• 示例代码

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

  }
  }