data22 可变参数 Map集合

data22

可变参数

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

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

package Demo37;

public class Demo37 {
    public static void main(String[] args) {
        System.out.println(sum(1,2,3,4));
        System.out.println(sum(1,2));
        System.out.println(sum(10,2));
    }
   /public static int sum(int...a){//这里的a是一个数组
   // public static int sum(int b ,int...a){//一个方法有多个参数，可变参数放在最后
        int sum = 0;
        for(int i : a ){
            sum+=i;
        }
        return sum;
    }
}

可变参数的使用

Array工具中有一个静态方法

• public static List as List(T…a):返回由指定数组支持的固定大小列表
• 返回的集合不能做增删操作，可以做修改操作

List接口中有一个静态方法

• public static List of(E…elements):返回包含任意元素的不可变列表
• 返回的集合不能做增删修改操作

Set中有一个静态方法：

• public static Set of (E…elements):返回一个包含任意元素的不可变集合
• 给定元素的时候，不能给定重复元素
• 返回的集合不能做增删操作，没有修改的方法

Map集合

---

---

package Demo37;

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

public class Demo37 {
    public static void main(String[] args) {
        Map<String,String> map = new HashMap<String,String>();
        //V put (K key ,V Value)将指定的值与该映射中指定的键相关联
        map.put("1","a");
        map.put("2","b");
        map.put("3","c");
        //map.put("3","d");如果后面的键和前面的重复，则修改前面的值
        System.out.println(map);
    }
}

• Map集合概述

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

  键键映射到值的对象；不能包含重复元素，每一个键最多只能映射一个值

• Map集合的特点

键值对映射关系

一个键对应一个值

键不能重复，值可以重复

元素存取无序

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()	集合的长度，也就是集合中键值对的个数

Map集合的获取功能

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

package Demo37;

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

public class Demo37 {
    public static void main(String[] args) {
        Map<String,String> map = new HashMap<String,String>();
        map.put("1","a");
        map.put("2","b");
        map.put("3","c");
        map.put("4","d");
  //根据键获取值
        System.out.println(map.get("1"));
        //获取所有键的集合
        Set<String> keySet = map.keySet();
        for (String key : keySet){
            System.out.println(key);
        }
        //获取所有值的集合
        Collection<String> values = map.values();
        for(String value: values){
            System.out.println(value);
        }
        
    }
}

Map 集合遍历方式1

遍历思路

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

把所有的丈夫给集中起来

遍历丈夫的集合，获取到每一个丈夫

根据丈夫去找对应的妻子

步骤分析

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

遍历键的集合，获取到每一个键。用增强for实现

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

package Demo37;

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

public class Demo37 {
    public static void main(String[] args) {
        Map<String,String> map = new HashMap<String,String>();
        map.put("1","a");
        map.put("2","b");
        map.put("3","c");
        map.put("4","d");
        //获取所有键的集合KeySet方法实现
        Set<String> keySet = map.keySet();
        //遍历
        for(String key: keySet){
            //根据键找值，get(Object key)方法
            String value = map.get(key);
            System.out.println(key+","+value);
        }

    }
}

**Map集合的遍历方式2

遍历思路

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

获取所有结婚证的集合

遍历结婚证的集合，得到每一个结婚证

根据结婚证获取丈夫和妻子

步骤分析

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

Set<Map.Entry<K,V>> entrySet()：获取所有键值对对象的集合

遍历键值对对象的集合，得到每一个键值对对象

用增强for实现，得到每一个Map.Entry

根据键值对对象获取键和值

用getKey()得到键

用getValue()得到值

package Demo37;

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

public class Demo37 {
    public static void main(String[] args) {
        Map<String,String> map = new HashMap<String,String>();
        map.put("1","a");
        map.put("2","b");
        map.put("3","c");
        map.put("4","d");
     //获取所有键值对象的集合
        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);
        }

    }
}

##HashMap集合储存学生对象并遍历

• 案例需求

创建一个HashMap集合，键是学号(String)，值是学生对象(Student)。存储三个键值对元素，并遍历

思路：

1:定义学生类

2:创建HashMap集合对象

3:创建学生对象

4:把学生添加到集合

5:遍历集合

方式1：键找值

方式2：键值对对象找键和值

package Demo38;

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

    public int getAge() {
        return age;
    }

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

    public String getName() {
        return name;
    }

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

package Demo38;

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

public class Demo38 {
    public static void main(String[] args) {
        Map<String,Student>  Student= new HashMap<String,Student>();
     Student s1 =new Student("a",18);
     Student s2 =new Student("b",19);
     Student s3 =new Student("c",20);
     Student s4 =new Student("d",21);
     Student.put("001",s1);
     Student.put("002",s2);
     Student.put("003",s3);
     Student.put("004",s4);
        Set<String> keyset = Student.keySet();
        for(String key : keyset){
            Student value =Student.get(key);
            System.out.println(key+","+value.getName()+","+value.getAge());
        }
        System.out.println("------------------");
        Set<Map.Entry<String,Student>> entrySet = Student.entrySet();
        for(Map.Entry<String,Student> me : entrySet){
            String key =me.getKey();
            Student value = me.getValue();
            System.out.println(key+","+value.getName()+","+value.getAge());

        }
    }
}