Java的LinkedHashSet、Map接口、可变参数、集合嵌套、

1、LinkedHashSet：
（1）LinkedHashSet集合保证元素的存入和取出的顺序；

package com.oracle.demo01;

import java.util.HashSet;
import java.util.LinkedHashSet;

public class demo01 {

    public static void main(String[] args) {
        //不能存重复元素，但是LinkedHashSet是有序的。
        LinkedHashSet<String> set = new LinkedHashSet<String>();
        set.add("c");
        set.add("b");
        set.add("z");
        for(String s:set){
            System.out.println(s);
        }
    }
}

效果如下：

（2）LinkedHashSet其实是HashSet的子类；

2、Map接口：
（1）元素是成对存在，每个元素由键与值两部分组成，通过键可以找对所对应的值，键值对；
（2）Map中的集合不能包含重复的键，值可以重复；每个键只能对应一个值；
（3）遍历：迭代器：不能直接遍历map，遍历set集合
第一种方法：keyset（）；第二种方法：entrySet（）；
用增强for或者是迭代器，不能用普通for循环，因为没有下标概念；

增强for（）{}

package com.oracle.demo01;

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

public class demo02 {

    public static void main(String[] args) {
        Map<String,String> map = new HashMap<String,String>();
        map.put("1", "a");
        map.put("2","b");
        map.put("2", "z");
        map.put("3", "c");
        //移除
        map.remove("3");
        //取数据
        System.out.println(map.get("1"));
        System.out.println(map.get("2"));
        System.out.println(map.get("3"));
        //1、keySet遍历
        //先获取map中的key所对应的set集合
        Set<String> set = map.keySet();
        //然后遍历set找到每一个key值
        for(String s:set){
            String key = s;
            String value = map.get(key);
            System.out.println(key+".."+value);
        }
        //简写
        for(String s:map.keySet()){
            System.out.println(s+".."+map.get(s));
        }
        //2、entryset（）遍历
        Set<Map.Entry<String, String>>  s1 = map.entrySet();
        for(Map.Entry<String, String> e:s1){
            System.out.println(e.getKey()+"..."+e.getValue());
        }
        //简写
        for(Map.Entry<String, String> e:map.entrySet()){
            System.out.println(e.getKey()+"..."+e.getValue());
        }
    }

}

迭代器

package com.oracle.demo01;

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

public class demo03 {

    public static void main(String[] args) {
        Map<String,String> map = new HashMap<String,String>();
        map.put("邓超", "孙俪");
        map.put("李晨", "范冰冰");
        map.put("文章", "马伊琍");
        map.put("小沈阳", "沈春阳");
        //迭代器：不能直接遍历map，遍历set集合；
        //1、keyset（）
        Set<String> s1 = map.keySet();
        Iterator<String> it = s1.iterator();
        while(it.hasNext()){
            String key = it.next();
            String value = map.get(key);
            System.out.println(key+">>"+value);
        }
        //2、entrySet（）
        Set<Map.Entry<String, String>> s2 = map.entrySet();
        Iterator<Map.Entry<String, String>> it2 = s2.iterator();
        while(it2.hasNext()){
            //获取每一个"结婚证对象"
            Map.Entry<String, String> e =it2.next();
            String key = e.getKey();
            String value = e.getValue();
            System.out.println(key+".."+value);
        }
    }

}

（4）HashMap存储自定义类型键值；保证对象唯一，必须复写对象的hashCode和equals方法；

建立一个人类

package com.oracle.demo02;

public class person {
        private   String  name;
        private   Integer  age;

        public person() {
            super();
        }
        public person(String name, Integer age) {
            super();
            this.name = name;
            this.age = age;
        }
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
        public Integer getAge() {
            return age;
        }
        public void setAge(Integer age) {
            this.age = age;
        }

        public int hashCode() {
            final int prime = 31;
            int result = 1;
            result = prime * result + ((age == null) ? 0 : age.hashCode());
            result = prime * result + ((name == null) ? 0 : name.hashCode());
            return result;
        }

        public boolean equals(Object obj) {
            if (this == obj)
                return true;
            if (obj == null)
                return false;
            if (getClass() != obj.getClass())
                return false;
            person other = (person) obj;
            if (age == null) {
                if (other.age != null)
                    return false;
            } else if (!age.equals(other.age))
                return false;
            if (name == null) {
                if (other.name != null)
                    return false;
            } else if (!name.equals(other.name))
                return false;
            return true;
        }
        public String toString() {
            return "姓名为" + name + ", 年龄为" + age ;
        }

}

建立测试类

package com.oracle.demo02;

import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.Map;

public class demo01 {

    public static void main(String[] args) {        //通过方法对比看出 键不能重复

       method01();

       method02();
       method03();

    }
    public static  void method01(){
        Map<String, person> map = new HashMap<String, person>();
        map.put("java0601", new person("a",21));
        map.put("java61", new person("b",21));
        map.put("java0806", new person("a",21));
        map.put("java86", new person("b",21));
        for(String s:map.keySet()){
            System.out.println(s+"..."+map.get(s));
        }
    }
    public static  void method02(){
        Map<person,String> map = new HashMap<person,String>();
        map.put(new person("a",21),"java0601");
        map.put(new person("b",21),"java61");
        map.put(new person("a",21),"java0806");
        map.put(new person("b",21),"java86");
        for(person p:map.keySet()){
            System.out.println(p+"..."+map.get(p));
        }
    }
    public static void method03(){
        LinkedHashMap<person,String> map = new LinkedHashMap<person,String>();
        map.put(new person("a",21),"java0601");
        map.put(new person("b",22),"java61");
        map.put(new person("a",23),"java0806");
        map.put(new person("b",24),"java86");
        for(person  p:map.keySet()){
            System.out.println(p+"..."+map.get(p));
        }
    }
}

效果如下：

3、可变参数：
（1）修饰符返回值类型方法名(参数类型... 形参名){ };

package com.oracle.demo02;

public class demo02 {

    public static void main(String[] args) {
        System.out.println(add(1));
        System.out.println(add(1,1));
        System.out.println(add(1,1,1));
    }
    //想要做一个求和的方法，但是参数个数不一定，但是类型都是一定的Int
    public static  int add(int...a){
        //int[] b = a;相当于一个数组
        int sum = 0;
        for(int i = 0;i < a.length;i++){
            sum +=a[i];
        }
        return sum;
    }
}

效果如下：

（2）可变参数一定要写在参数列表的末尾位置；

（3）调用的不确定性，只能传一个可变参数；

4、集合嵌套：
用循环嵌套取值；

举个例子：

package com.oracle.demo02;

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

public class demo03 {

    public static void main(String[] args) {
        //HashMap<String, HashMap<String,String>>
        method01();

    }
    public  static  void method01(){
        HashMap<String, HashMap<String,String>>  map = new HashMap<String, HashMap<String,String>>();
        HashMap<String,String>  m1 = new  HashMap<String,String>();
        m1.put("0601", "温昭");
        m1.put("0806", "马荣");
        HashMap<String,String>  m2 = new  HashMap<String,String>();
        m2.put("0101", "张三");
        m2.put("0202", "李四");
        map.put("oracle01", m1);
        map.put("oracle02", m2);
        //第一层循环：获取学校
        Set<String> s1= map.keySet();
        for(String s2:s1){
               //学校名称
               String  schoolname = s2;
               //获取每一个班级
               HashMap<String,String> s3 = map.get(s2);
               Set<String> s4 = s3.keySet();
               for(String s5:s4){
                   //班级名称
                   String  classname =   s5;
                   //学生名称：
                   String  studentname =  s3.get(s5);
                   System.out.println(schoolname+".."+classname+".."+studentname);
               }
        }
    }
}

效果如下：

可以简写为：

//简写
        for(String s:map.keySet()){
            for(String s1:map.get(s).keySet()){
                System.out.println("学校为"+s+",班级为"+s1
                        +"姓名为"+map.get(s).get(s1));
            }
        }

原文地址：https://www.cnblogs.com/scw123/p/9777093.html

时间： 2024-11-05 18:46:34

Java的LinkedHashSet、Map接口、可变参数、集合嵌套、的相关文章

20_集合_第20天（Map、可变参数、Collections）_讲义

今日内容介绍 1.Map接口 2.模拟斗地主洗牌发牌 01Map集合概述 A:Map集合概述: 我们通过查看Map接口描述,发现Map接口下的集合与Collection接口下的集合,它们存储数据的形式不同 ? a:Collection中的集合,元素是孤立存在的(理解为单身),向集合中存储元素采用一个个元素的方式存储. ? b:Map中的集合,元素是成对存在的(理解为夫妻).每个元素由键与值两部分组成,通过键可以找对所对应的值. ? Collection中的集合称为单列集合,Map中的集合称为双列

集合【Map、可变参数、Collections】

第9天集合今日学习内容? Map集合今日学习目标? 能够说出Map集合特点? 使用Map集合添加方法保存数据? 使用"键找值"的方式遍历Map集合? 使用"键值对"的方式遍历Map集合? 能够使用HashMap存储自定义键值对的数据? 能够说出可变参数的作用? 能够使用集合工具类? 能够使用HashMap编写斗地主洗牌发牌案例第1章 Map接口概述1.1 Map集合的特点我们通过查看Map接口描述,发现Map接口下的集合与Collection接口下的集合,它们存储

11、Map、可变参数、Collections

Map接口 Map集合概述 *A:Map集合概述: 我们通过查看Map接口描述,发现Map接口下的集合与Collection接口下的集合,它们存储数据的形式不同 a:Collection中的集合,元素是孤立存在的(理解为单身),向集合中存储元素采用一个个元素的方式存储. b:Map中的集合,元素是成对存在的(理解为夫妻).每个元素由键与值两部分组成,通过键可以找对所对应的值. Collection中的集合称为单列集合,Map中的集合称为双列集合. 需要注意的是,Map中的集合不能包含重复的键,值

Java学习（Map接口）

一.概述: 我们通过查看Map接口描述,发现Map接口下的集合与Collection接口下的集合,它们存储数据的形式不同,如下图. 1. Collection中的集合,元素是孤立存在的(理解为单身),向集合中存储元素采用一个个元素的方式存储. 2. Map中的集合,元素是成对存在的(理解为夫妻).每个元素由键与值两部分组成,通过键可以找到所对应的值. 3. Collection中的集合称为单列集合,Map中的集合称为双列集合. 4. 需要注意的是,Map中的集合不能包含重复的键,值可以重复:每

Java基础学习191221（可变参数，数组，Array类,稀疏数组，继承重写多态，抽象类，接口）

Java基础学习可变参数在方法声明中,在指定参数类型后加一个省略号(...). 一个方法中只能指定一个可变参数,它必须是方法的最后一个参数.任何普通参数都必须在它之前声明. public class printMax { public static void main(String[] args) { printMax(1,5,8,78,415,15); } public static void printMax( double... numbers){ if (numbers.length

Java基础中map接口和实现类

1.Map接口常用的实现类有HashMap和TreeMap. 2.HashMap类实现的Map集合对于添加和删除映射关系效率更高.HashMap是基于哈希表的Map接口的实现,HashMap通过哈希码对其内部的映射关系进行快速查询,由HashMap类实现的Map集合对于添加或删除映射关系效率较高. 3.TreeMap中的映射关系存在一定的顺序,如果希望Map集合中的对象存在一定的顺序,该使用TreeMap类实现Map集合. HashMap类 ①此类不保证映射的顺序,特别是不保证该顺序恒久不变 ②

java中的Map接口

前言在学习Map接口之前,先来看看散列表的概念:本节主要讲讲Map接口的实现类和集合的工具类. 这里先提一下泛型编程:通常情况下用来限制集合的存储的数据类型.在定义集合时使用<引用类型>来限制集合.其中<>的类型只为引用类型. 正文散列桶 1.散列桶的概念散列桶的目的是使用空间换时间,即它是使用索引来提高效率. 散列桶把一组数据通过散列算法,将数据分散开来:存储于连续的内存空间中(数组),将散列值作为数组的下标:如果散列值有重复的,将重复的数据放置在散列桶中.散列桶是线性表.

Java学习（set接口、HashSet集合）

一.set接口概念:set接口继承自Collection接口,与List接口不同的是,set接口所储存的元素是不重复的. 二.HashSet集合概念:是set接口的实现类,由哈希表支持(实际上是一个HashMap集合).HashSet集合元素的提取顺序与存储顺序不相同. 采用哈希表数据结构存储数据,保证元素唯一性的方式依赖于:hashCode()与equals()方法. 2.1哈希表什么是哈希表? 链表与数组的组合. 哈希表底层使用的也是数组机制,数组中也存放对象,而这些对象往数组中存放时

Java面向对象_增强for可变参数与代码块

1.foreach循环 for(类型变量名称:数组或集合){ //输出操作 } 2.可变参数:根据需要自动传入任意个数的参数,就是可变参数. 语法:返回值类型方法名称(数据类型...参数名称){ } 例: 1 ublic class Practice14 { 2 3 /** 4 * @param args 5 */ 6 public static void main(String[] args) { 7 // TODO Auto-generated method stub 8 /*Strin

Java容器之Map接口

Map 接口: 1. 实现 Map 接口的类是用来存储键-值(key-value)对: 2. Map 接口的实现类有 HashMap 和 TreeMap 等: 3. Map 类中存储的键-值对,通过键来标识,所以键值不能重复. 4. Map 接口的常用方法如下: 4.1 object put(K key, V value):将指定的值与此映射中的指定键关联(可选操作); 4.2 object get(Object key):返回指定键所映射的值: 4.3 object remove(Obj