神出鬼没的Enderman

什么是集合

集合，集合是java中提供的一种容器，可以用来存储多个数据。

集合和数组的区别

• 数组的长度是固定的。集合的长度是可变的
• 集合中存储的元素必须是引用类型数据

Map集合概述

• Collection中的集合，元素是孤立存在的，向集合中存储元素采用一个个元素的方式存储
• Map中的集合，元素是成对存在的。每个元素由键与值两部分组成，通过键可以找对所对应的值
• Map中的集合不能包含重复的键，值可以重复；每个键只能对应一个值

集合Map

• Collection接口中的方法
• 是集合中所有实现类必须拥有的方法
• 方法的执行,都是实现的重写

put()方法 Map接口方法

• V put(K,V) K 作为键的对象, V作为值的对象
• 存储的是重复的键,将原有的值,覆盖
• 返回值一般情况下返回null
• 存储重复键的时候,返回被覆盖之前的值

//创建集合对象,HashMap,存储对象,键是字符串,值是整数
Map<String, Integer> map = new HashMap<String, Integer>();
map.put("a", 1);
map.put("b", 2);
map.put("c", 3);

System.out.println(map);

get()方法 Map接口方法

• V get(K) 通过键对象,获取值对象 如果集合中没有这个键,返回null

//创建集合对象,作为键的对象整数,值的对象存储字符串
Map<Integer,String> map = new HashMap<Integer, String>();
map.put(1, "a");
map.put(2, "b");
map.put(3, "c");
System.out.println(map);

String value = map.get(4);
System.out.println(value);

remove()方法 Map接口方法

• V remove(K) 移除集合中的键值对,返回被移除之前的值

Map<Integer,String> map = new HashMap<Integer, String>();
map.put(1, "a");
map.put(2, "b");
map.put(3, "c");
System.out.println(map);

String value = map.remove(33);
System.out.println(value);
System.out.println(map);

LinkedHashMap

• LinkedHashMap继承HashMap 保证迭代的顺序

LinkedHashMap<String, String> link = new LinkedHashMap<String, String>();
link.put("1", "a");
link.put("13", "a");
link.put("15", "a");
link.put("17", "a");
System.out.println(link);

Map集合遍历

• Map集合不能直接使用迭代器和增强for，但可以通过其他方式使用迭代器和增强for来达到遍历的目的

keySet()方法 Map接口方法

• 调用map集合的方法keySet,所有的键存储到Set集合中
• 遍历Set集合,获取出Set集合中的所有元素 (Map中的键)
• 调用map集合方法get,通过键获取到值

Map<String,Integer> map = new HashMap<String,Integer>();
map.put("a", 11);
map.put("b", 12);
map.put("c", 13);
map.put("d", 14);

//1. 调用map集合的方法keySet,所有的键存储到Set集合中
Set<String> set = map.keySet();
//2. 遍历Set集合,获取出Set集合中的所有元素 (Map中的键)
Iterator<String> it = set.iterator();
while(it.hasNext()){
    //it.next返回是Set集合元素,也就是Map中的键
    //3. 调用map集合方法get,通过键获取到值
    String key = it.next();
    Integer value = map.get(key);
    System.out.println(key+"...."+value);
}

// 增强for部分
for(String key : map.keySet()){
    Integer value = map.get(key);
    System.out.println(key+"...."+value);
}

entrySet()方法 Map内部接口Entry方法

在Map类设计时，提供了一个嵌套接口：Entry。Entry将键值对的对应关系封装成了对象，在遍历Map集合时，就可以从每一个键值对（Entry）对象中获取对应的键与对应的值。

• getKey()方法：获取Entry对象中的键

• getValue()方法：获取Entry对象中的值

• entrySet()方法：用于返回Map集合中所有的键值对(Entry)对象，以Set集合形式返回

• 调用map集合方法entrySet()将集合中的映射关系对象,存储到Set集合Set<Entry <K,V> >

• 迭代Set集合，获取出的Set集合的元素,是映射关系对象

• 通过映射关系对象方法 getKet, getValue获取键值对

// 创建内部类对象 外部类.内部类 = new
Map<Integer,String> map = new HashMap<Integer, String>();
map.put(1, "abc");
map.put(2, "bcd");
map.put(3, "cde");
// while
// 调用map集合方法entrySet()将集合中的映射关系对象,存储到Set集合
Set<Map.Entry <Integer,String> >  set = map.entrySet();
// 迭代Set集合
Iterator<Map.Entry <Integer,String> > it = set.iterator();
while(it.hasNext()){
    // 获取出的Set集合的元素,是映射关系对象
    // it.next 获取的是什么对象,也是Map.Entry对象
    Map.Entry<Integer, String> entry = it.next();
    // 通过映射关系对象方法 getKet, getValue获取键值对
    Integer key = entry.getKey();
    String value = entry.getValue();
    System.out.println(key+"...."+value);
}

// 增强for
// Map集合不能直接使用迭代器或者增强for进行遍历。但是转成Set之后就可以使用了
for(Map.Entry<Integer, String> entry : map.entrySet()){
    System.out.println(entry.getKey()+"..."+entry.getValue());
}

静态导入

• 如果本类中有和静态导入的同名方法会优先使用本类的
• 如果还想使用静态导入的,依然需要类名来调用

import static java.lang.System.out;
import static java.util.Arrays.sort;

public class StaticImportDemo {
    public static void main(String[] args) {
        out.println("hello");

        int[] arr = {1,4,2};
        sort(arr);
    }
}

方法的可变参数

• 方法参数数据类型确定,参数的个数任意
• 可变参数本质就是一个数组
• 可变参数语法: 数据类型...变量名
• 一个方法中,可变参数只能有一个
• 可变参数,必须写在参数列表的最后一位

public static void main(String[] args) {
    //调用一个带有可变参数的方法,传递参数,可以任意
    int sum = getSum(5,34,3,56,7,8,0);
    System.out.println(sum);
}

public static int getSum(int...a){
    int sum = 0 ;
    for(int i : a){
        sum = sum + i;
    }
    return sum;
}

Collections工具类

• 此类仅由静态方法组合或返回集合。 它包含对集合进行操作的多态算法，“包装器”，返回由指定集合支持的新集合，以及其他一些可能的和最终的。

Collections.sort()静态方法

• 对于List集合,进行升序排列

//创建List集合
List<String> list = new ArrayList<String>();
list.add("ewrew");
list.add("qwesd");
list.add("Qwesd");
list.add("bv");
list.add("wer");
System.out.println(list);
//调用集合工具类的方法sort
Collections.sort(list);
System.out.println(list);

Collections.binarySearch静态方法

• 对List集合进行二分搜索,方法参数,传递List集合,传递被查找的元素

List<Integer> list = new ArrayList<Integer>();
list.add(1);
list.add(5);
list.add(8);
list.add(10);
list.add(15);
list.add(20);
//调用工具类静态方法binarySearch
int index = Collections.binarySearch(list, 16);
System.out.println(index);

Collections.shuffle方法

• 对List集合中的元素,进行随机排列

List<Integer> list = new ArrayList<Integer>();
list.add(1);
list.add(5);
list.add(9);
list.add(11);
list.add(8);
list.add(10);
list.add(15);
list.add(20);   
System.out.println(list);

//调用工具类方法shuffle对集合随机排列
Collections.shuffle(list);
System.out.println(list);

集合的嵌套

定义嵌套的集合

//定义基础班集合
HashMap<String, String> values1 = new HashMap<String, String>();
//定义就业班集合
HashMap<String, String> values2 = new HashMap<String, String>();
//向班级集合中,存储学生信息
values1.put("key1", "value1");
values1.put("key2", "value2");

values2.put("key1", "value1");
values2.put("key2", "value2");
//定义传智播客集合容器,键是班级名字,值是两个班级容器
HashMap<String, HashMap<String,String>> array = new HashMap<String, HashMap<String,String>>();
array.put("keys1", values1);
array.put("keys2", values2);

嵌套集合keySet遍历

//调用array集合方法keySet将键存储到Set集合
Set<String> classNameSet = array.keySet();
//迭代Set集合
Iterator<String> classNameIt = classNameSet.iterator();
while(classNameIt.hasNext()){
  //classNameIt.next获取出来的是Set集合元素,array集合的键
  String classNameKey = classNameIt.next();
  //array集合的方法get获取值,值是一个HashMap集合
  HashMap<String,String> classMap = array.get(classNameKey);
  //调用classMap集合方法keySet,键存储到Set集合
  Set<String> studentNum = classMap.keySet();
  Iterator<String> studentIt = studentNum.iterator();

   while(studentIt.hasNext()){
    //studentIt.next获取出来的是classMap的键,学号
    String numKey = studentIt.next();
    //调用classMap集合中的get方法获取值
    String nameValue = classMap.get(numKey);
    System.out.println(classNameKey+".."+numKey+".."+nameValue);
  }
}

System.out.println("==================================");
for(String className: array.keySet()){
   HashMap<String, String> hashMap = array.get(className); 
   for(String numKey : hashMap.keySet()){
     String nameValue = hashMap.get(numKey);
     System.out.println(className+".."+numKey+".."+nameValue);
   }
}

嵌套集合entrySet遍历

//调用array集合方法entrySet方法,将array集合的键值对关系对象,存储到Set集合
Set<Map.Entry<String, HashMap<String,String>>> classNameSet = array.entrySet();
//迭代器迭代Set集合
Iterator<Map.Entry<String, HashMap<String,String>>> classNameIt = classNameSet.iterator();
while(classNameIt.hasNext()){
  //classNameIt.next方法,取出的是array集合的键值对关系对象
  Map.Entry<String, HashMap<String,String>> classNameEntry =  classNameIt.next();
  //classNameEntry方法 getKey,getValue
  String classNameKey = classNameEntry.getKey();
  //获取值,值是一个Map集合
  HashMap<String,String> classMap = classNameEntry.getValue();
  //调用班级集合classMap方法entrySet,键值对关系对象存储Set集合
  Set<Map.Entry<String, String>> studentSet = classMap.entrySet();
  //迭代Set集合
  Iterator<Map.Entry<String, String>> studentIt = studentSet.iterator();
  while(studentIt.hasNext()){
    //studentIt方法next获取出的是班级集合的键值对关系对象
    Map.Entry<String, String> studentEntry = studentIt.next();
    //studentEntry方法 getKey getValue
    String numKey = studentEntry.getKey();
    String nameValue = studentEntry.getValue();
    System.out.println(classNameKey+".."+numKey+".."+nameValue);
  }
}
 System.out.println("==================================");

for (Map.Entry<String, HashMap<String, String>> me : array.entrySet()) {
  String classNameKey = me.getKey();
  HashMap<String, String> numNameMapValue = me.getValue();
  for (Map.Entry<String, String> nameMapEntry : numNameMapValue.entrySet()) {
    String numKey = nameMapEntry.getKey();
    String nameValue = nameMapEntry.getValue();
    System.out.println(classNameKey + ".." + numKey + ".." + nameValue);
  }
}