文档章节

Java基础进阶_day08_(Map集合,可变参数)

S
 Sunmos
发布于 2017/05/13 00:19
字数 2184
阅读 3
收藏 0
点赞 0
评论 0

Java基础进阶_day08_(Map集合,可变参数)

1. Map集合

Map集合:将键映射到值的对象.Map集合是双列集合的顶层接口.

# Map集合特点:
* A:一个映射不能包含重复的键(相当于是Collection集合的Set集合);
* B:每个键最多只能映射到一个值;
* C:值可以重复(相当于是Collection集合的List集合).

Map集合与Collection集合的区别:

# Map集合存储的元素是成对出现的,其中键是唯一的,值是可以重复的;
# Collection集合存储的元素是单独出现的,其子接口List集合存储的是元素是可重复的,子接口Set集合存储的元素是唯一的.

集合中的数据结构:

# Map集合的底层数据结构是针对键有效的,对值无效;
# Collection集合的底层数据结构是针对存储的元素有效.

Map集合功能概述:

添加功能:

V put(K key,V value):将指定的键映射到值,返回被替换的值;

获取功能:

Set<Map.Entry<K,V>> entrySet():获取集合键值对的集合;
V get(Object key):获取指定键对应的值,没有则返回null;
Set<K> keySet():返回该集合的键集合;
Collection<V> values():返回该集合的值的集合;

删除功能:

void clear():删除集合中所有的键值对;
V remove(Object key):删除指定键对应的值,并将删除的值返回(key不返回),没有返回null;

判断功能:

boolean containsKey(Object key):判断集合中是否包含指定键;
boolean containsValue(Object value):判断集合中是否包含指定的值;
boolean isEmpty():判断集合是否为空;

长度功能:

int size():返回集合中键值对的对数.

Map集合的遍历方式:

# 方式1:通过keySet()方法获取Map的键的Set集合,通过遍历key的集合(get()方法)获取key对应的value值.
# 方式2:先获取Map集合的键值对对象的集合,通过遍历获取的集合获取每一个键值对对象,获取键值对对象的键和值.

案例:

public class MyMapDemo {
    public static void main(String[] args) {
        //创建集合对象
        Map<Integer, String> m = new HashMap<Integer, String>();
        // V put(K key,V value)
        System.out.println(m.put(1, "郭靖"));
        m.put(2, "黄蓉");
        System.out.println(m);
        // V get(Object key)
        System.out.println(m.get(1));
        System.out.println(m.get(2));
        // Set<K> keySet():
        Set<Integer> keySet = m.keySet();
        for (Integer integer : keySet) {
            System.out.println(integer);
        }
        // Collection<V> values()
        Collection<String> values = m.values();
        for (String string : values) {
            System.out.println(string);
        }
        // void clear()
        // m.clear();
        // System.out.println(m);
        // V remove(Object key)
        System.out.println(m.remove(1));
        System.out.println(m.remove(3));
        // boolean containsKey(Object key)
        System.out.println(m);
        System.out.println(m.containsKey(1));
        // boolean containsValue(Object value)
        System.out.println(m.containsValue("郭靖"));
        // boolean isEmpty()
        System.out.println(m.isEmpty());
        // int size()
        System.out.println(m.size());
        // 遍历集合,方式1
        Map<String, String> map = new HashMap<String, String>();
        map.put("郭靖", "黄蓉");
        map.put("杨康", "穆念慈");
        map.put("周伯通", "瑛姑");
        Set<String> set = map.keySet();
        for (String string : set) {
            System.out.println(string+"..."+map.get(string));
        }
        // 遍历集合,方式1
        Set<Map.Entry<String, String>> entrySet = map.entrySet();
        for (Map.Entry<String, String> entry : entrySet) {
            System.out.println(entry.getKey()+"..."+entry.getValue());
        }
    }
}

1.1 HashMap集合

HashMap集合:是基于哈希表的Map集合接口的实现类,其有个子类LinkedHashMap[键值对有序(存取顺序)].

# (键)底层数据结构是哈希表.
# 特点:键值对集合,键唯一,键值对无序(存储顺序),值可以重复.
* 哈希表保证了键的唯一性.
* 任何非null对象都可以用作键或值.

注意事项:

# 由于HashMap集合键的底层数据结构是哈希表,如果键的内容是自定义类,则需要该类重写hashCode和equals方法,否则无法保证键的唯一性.
# HashMap与~~Hashtable~~集合:
 * HashMap集合:线程不安全,效率高,键和值可以为null;
 * Hashtable集合:线程安全,效率低,键和值不允许为null.

案例:

public class MyMap_HashMapDemo {
    public static void main(String[] args) {
        HashMap<Student, String> hm = new HashMap<Student, String>();
        hm.put(new Student("郭靖", 23), "12");
        hm.put(new Student("黄蓉", 23), "13");
        hm.put(new Student("洪七公", 40), "14");
        hm.put(new Student("郭靖", 23), "15");
        Set<Student> keySet = hm.keySet();
        for (Student student : keySet) {
            String s = hm.get(student);
            System.out.println(student.getName()+"..."+student.getAge()+"..."+s);
        }
    }
}
class Student {
    private String name;
    private int age;
    public Student() {}
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    // 重写hashCode和equals方法
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + age;
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        return result;
    }
    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Student other = (Student) obj;
        if (age != other.age)
            return false;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        return true;
    }
}

1.2 LinkedHashMap集合

LinkedHashMap集合:Map接口的哈希表和链接列表实现,具有可预知的迭代顺序(存储和取出顺序一致),是LinkedHashMap集合是HashMap集合类的子类.

# 底层数据结构是哈希表和链表.
* 特点:键唯一,值可重复,有序(存取顺序一致).
* 哈希表保证了键的唯一性,链表保证了键值对的存取顺序一致.

案例:

public class MyMap_HasMap_LinkedHashMapDemo {
    public static void main(String[] args) {
        LinkedHashMap<String, String> hm = new LinkedHashMap<String, String>();
        hm.put("123", "java");
        hm.put("1234", "android");
        hm.put("123", "javaEE");
        hm.put("1235", "java");
        Set<String> keySet = hm.keySet();
        for (String string : keySet) {
            System.out.println(string+"..."+hm.get(string));
        }
    }
}

1.3 TreeMap集合

TreeMap集合:是实现了Map集合接口的子类.

# 底层数据结构是红黑树(自平衡的二叉树).
# 特点:键唯一,值可重复,无序(元素存取顺序).
* 键的红黑树数据结构保证了键的唯一性和排序.

构造方法:

public TreeMap():该构造方法的键是自然排序;
public TreeMap(Comparator<? super K> comparator):该构造方法创建的对象的键是按照比较器comparator进行排序.

注意事项:

# 键自然排序:无参构造
 * 当键是自定义对象时,需要该对象所属的类实现Comparable接口,并实现其中的compareTo方法,在该方法中定义排序规则.
# 键比较器排序:有参数构造
 * 当键是自定义对象时,在创建集合对象时,使用实现Comparator接口的匿名内部类,并实现其中的compare方法,在方法中定义排序规则.

案例:

public class MyMap_TreeMapDemo {
    public static void main(String[] args) {
        // 创建集合对象
        TreeMap<Student, String> tm = new TreeMap<Student, String>(new Comparator<Student>() {
            // 重写方法,定义排序规则
            @Override
            public int compare(Student s1, Student s2) {
                // 主要条件,年龄
                int num = s2.getAge() - s1.getAge();
                // 次要条件,姓名
                int num2 = num==0?s1.getName().compareTo(s2.getName()):num;
                return num2;
            }
        });
        tm.put(new Student("郭靖", 23), "12");
        tm.put(new Student("黄蓉", 23), "13");
        tm.put(new Student("洪七公", 40), "14");
        tm.put(new Student("郭靖", 23), "15");
        Set<Student> keySet = tm.keySet();
        for (Student student : keySet) {
            String s = tm.get(student);
            System.out.println(student.getName()+"..."+student.getAge()+"..."+s);
        }

        // 练习
        // 统计一个字符串中各个字符出现的次数
        test01();
    }

    /* * 统计一个字符串中各个字符出现的次数 */
    public static void test01() {
        // 定义存储字符的集合
        TreeMap<Character, Integer> tm = new TreeMap<Character, Integer>();
        // 定义键盘录入对象
        Scanner sc = new Scanner(System.in);
        // 定义接收键盘录入的字符串
        System.out.println("请输入一个字符串:");
        String s = sc.nextLine();
        // 将字符串转换为字符数组
        char[] chs = s.toCharArray();

        // 遍历字符数组,统计各个字符出现的次数
        for (int i = 0; i < chs.length; i++) {
            if(tm.containsKey(chs[i])) {
                int num = tm.get(chs[i]);
                num++;
                tm.put(chs[i], num);
            }else {
                tm.put(chs[i], 1);
            }
        }

        // 定义字符串缓冲区对象
        StringBuilder sb = new StringBuilder();
        Set<Character> ketSet = tm.keySet();
        for (Character character : ketSet) {
            sb.append("\""+character+"\"").append("(").append(tm.get(character)).append(")");
        }
        // 输出结果
        System.out.println(sb.toString());

    }
}
// 自定义类
class Person {
    private String name;
    private int age;
    public Person() {}
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}

2. 可变参数

可变参数:定义方法时不确定参数的个数.

使用格式:

修饰符  返回值类型  方法名 (数据类型...  变量名) {}

注意事项:

# 方法的变量名其实是一个数组;
# 如果一个方法有可变参数并且有多个参数,则可变参数必须是最后一个参数.

Arrays工具类:

public static <T> List<T> asList(T... a):将数组转换为集合.
注意事项:该方法转换成的集合本质还是数组,长度不变,所以不支持改变数组长度的操作(增删),修改可以.

案例:

public class MyArgsDemo {
    public static void main(String[] args) {
        // 调用可变参数方法
        System.out.println(sum(1,2,3));
        System.out.println(sum(1,2));
        System.out.println(sum(1,2,3,4));
        // 多个参数的可变参数,可变参数必须最后一个参数
        System.out.println(sum1(2.4,1,2,3));

        // 将数组转换为集合
        String[] s = {"java","python","android"};
        List<String> asList = Arrays.asList(s);
        // 可变参数
        // List<String> asList = Arrays.asList("java","python","android");
        // List<String> asList = Arrays.asList("java","python");
        for (String string : asList) {
            System.out.println(string);
        }
        // asList.add("java"); // java.lang.UnsupportedOperationException
        // asList.remove(0); // UnsupportedOperationException
        asList.set(0, "java");
    }

    // 定义可变参数
    public static int sum(int... num) {
        int sum = 0;
        // 使用增强for循环遍历数组
        for (int i : num) {
            sum += i;
        }
        return sum;
    }
    // 定义可变参数
    public static int sum1(double num1, int... num2) {
        int sum = 0;
        // 使用增强for循环遍历数组
        for (int i : num2) {
            sum += i;
        }
        System.out.println(num1);
        return sum;
    }
}

本文转载自:http://blog.csdn.net/l631106040120/article/details/69055840

共有 人打赏支持
S
粉丝 0
博文 34
码字总数 0
作品 0
成都
kotlin学习笔记-异常好玩的list集合总结

不积跬步无以至千里,不积小流无以成江海 先看看Kotlin中for循环的遍历 kotlin和Java中的集合工具类 Java中集合及其工具类 Kotlin中Java中集合及其工具类 List MutableList Set MutableSet Ma...

codeGoogle
今天
0
0
Scala笔记整理(二):Scala数据结构—数组、map与tuple

[TOC] 数组 定长数组 如果你需要一个长度不变的数组,可以用Scala中的Array。例如: 在JVM中,Scala的Array以Java数组方式实现。示例中的数组在JVM中的类型为java.lang.String[]。Int、Doubl...

xpleaf
04/18
0
0
Java高级部分笔记-------Java5.0的新特性

静态导入 1.1 JDK 1.5 增加的静态导入语法用于导入类的某个静态属性或方法。使用静态导入可以简化程序对类静态属性和方法的调用。 1.2 语法:Import static 包名.类名.静态属性|静态方法|* ...

查封炉台
2014/04/21
0
0
Java中使用Jedis操作Redis

使用Java操作Redis需要jedis-2.1.0.jar,下载地址:http://files.cnblogs.com/liuling/jedis-2.1.0.jar.zip 如果需要使用Redis连接池的话,还需commons-pool-1.5.4.jar,下载地址:http://fil...

脸大的都是胖纸
2015/03/25
0
0
自己动手写AbstractMap

根据前辈的建议,最近在关注Java 的HashMap细节。 HashMap派生自AbstractMap,根据JDK的API描述,今天动手写了一个AbstractMap实现。 AbstractMap实现了Map<K, V>接口,Map<K,V>包含了一个内...

精神病的羽毛球
2014/03/31
0
0
Scala学习笔记(3)-数组集合元组

1.带类型的参数化数组 val greetStrings= new ArrayString 其中Array[String]变量greetStrings的类型,3为实例初始化参数。 Scala里的数组是通过把索引放在圆括号里面访问的,而不是像Java那...

山海经
2013/08/25
0
0
从java程序员到CTO的成长路线图

很多新人不知道从事java开发,具体的发展路径是怎么样的,甚至很多人都不能区分程序猿和攻城师的区别。包括不少小白,从事java开发都半年,甚至1年了,对职业发展还没有清晰的认证。这非常不...

6pker
2013/10/24
0
2
随机模拟 java 数据插件 - Jmockdata

Jmockdata ![License](http://www.apache.o

寻觅一只耳朵
2017/01/05
0
20
【java8】java新特性(二)——lambda表达式

一,前言 在上一篇博客中,小编向大家抛转引玉,简单说明了[ Java8 ](http://blog.csdn.net/kisscatforever/article/details/79572194 ),其实Java 8在2014年3月18日,就发布了。可以说程序...

kisscatforever
03/20
0
0
Scala笔记整理(一):scala基本知识

[TOC] Scala简介 Scala是一门多范式(multi-paradigm)的编程语言,设计初衷是要集成面向对象编程和函数式编程的各种特性。 Scala运行在Java虚拟机上,并兼容现有的Java程序。 Scala源代码被...

xpleaf
04/18
0
0

没有更多内容

加载失败,请刷新页面

加载更多

下一页

sklearn学习笔记之简单线性回归

简单线性回归 线性回归是数据挖掘中的基础算法之一,从某种意义上来说,在学习函数的时候已经开始接触线性回归了,只不过那时候并没有涉及到误差项。线性回归的思想其实就是解一组方程,得到...

wangxuwei
6分钟前
0
0
feign之动态interceptor(二)

背景 上文提到了按照不同的feignClient可以根据多个不同的key来进行多个不同的bean的配置 那么我们如何完成多个interceptor的配置呢? 分析 我们刚提到多个配置的玄机就在FeignClientProper...

Mr_Qi
8分钟前
1
0
Linux Kernel 4.16 系列停止维护,用户应升级至 4.17

知名 Linux 内核维护人员兼开发人员 Greg Kroah-Hartman 近日在发布 4.16.18 版本的同时,宣布这是 4.16 系列的最后一个维护版本,强烈建议用户立即升级至 4.17 系列。 Linux 4.16 于 2018 年...

问题终结者
32分钟前
0
0
Apache配置时.htaccess失效不起作用的原因分析

.htaccess 失效的原因 1. 重写规则有问题,检查自己的重写规则 2.Apache配置问题,配置中没有配置启用 rewrite a2enmod rewrite 3.网站配置文件没有启用配置需要配置 000-default.conf <Dire...

TU-DESGIN
52分钟前
1
0
两个求最大公约数C/C++算法实现

#include<stdio.h> #include<time.h> #include <iostream>using namespace std;//求最大公约数 LCD(Largest Common Division)//短除法 //m=8251, n=6105; int LCD_ShortDiv(int m, ......

失落的艺术
58分钟前
1
0
QueryPerformanceCounter

windows的Sleep函数,睡眠线程指定毫秒数,可以用来做毫秒延时。 对于微秒延时,没有一个现成的函数,但是可以通过 QueryPerformanceFrequency QueryPerformanceCounter 来间接实现。原理就是...

开飞色
今天
1
0
log4j2使用AsyncRoot不显示行号问题处理

<AsyncRoot level="info" includeLocation="true"> <AppenderRef ref="File"/></AsyncRoot><!--1.异步logger,还需要在pom.xml中添加disruptor的依赖。2.includeLocation结合异......

小翔
今天
3
0
安卓手机上 K 歌,声音延迟怎么解决?

这篇文章可以为你提供一个解决录音和播放同步问题的思路,而且解决了声音从手机传输到耳机上有延时的问题。 初识音频 在开始之前,我先简单介绍一下音频相关的基础知识,方便下文理解。 我们...

编辑部的故事
今天
2
0
使用token实现在有效期内APP自动登录功能

使用token实现在有效期内APP自动登录功能 http://sevennight.cc/2016/07/19/auto_login_impl.html

风云海滩
今天
3
0
Spring Boot集成RabbitMQ发送接收JSON

默认情况下RabbitMQ发送的消息是转换为字节码,这里介绍一下如何发送JSON数据。 ObjectMapper 最简单发送JSON数据的方式是把对象使用ObjectMapper等JSON工具类把对象转换为JSON格式,然后发送...

小致dad
今天
3
0

没有更多内容

加载失败,请刷新页面

加载更多

下一页

返回顶部
顶部