初学java 想知道java map集合循环存入数据

Posted 2023-04-12

假如我有2个类型 一个a 一个b。a是100以内基数，如1，3，5，7，9直到100. b是2,4,6,8,10直到100.
如何循环存入map集合相对应。map的key是a, values是b.
最后返回的集合是<1,2>,<3,4>,<5,6>。最好有代码示范

可以分开，我帮你写一个，发不出来

public class Test 


public static void main(String[] args) 
List<HashMap<String, String>> list = new ArrayList<HashMap<String, String>>();
int a = 1;
int b = 2;

String key = "";
String value = "";
for (int i = 0; i < 50; i++) 
HashMap<String, String> map = new HashMap<String, String>();
key = (a + i * 2) + "";
value = (b + i * 2) + "";
map.put(key, value);
list.add(map);


for (int i = 0; i < list.size(); i++) 
System.out.println(list.get(i));

运行结果：

1=2
3=4
5=6
7=8
9=10
11=12
13=14
15=16
17=18
19=20
21=22
23=24
25=26
27=28
29=30
31=32
33=34
35=36
37=38
39=40
41=42
43=44
45=46
47=48
49=50
51=52
53=54
55=56
57=58
59=60
61=62
63=64
65=66
67=68
69=70
71=72
73=74
75=76
77=78
79=80
81=82
83=84
85=86
87=88
89=90
91=92
93=94
95=96
97=98
99=100

追问

汗。。怎么发不出来

追答

太长了吗？

public class Test 


public static void main(String[] args) 
List<HashMap<String, String>> list = new ArrayList<HashMap<String, String>>();
int a = 1;
int b = 2;

String key = "";
String value = "";
for (int i = 0; i < 50; i++) 
HashMap<String, String> map = new HashMap<String, String>();
key = (a + i * 2) + "";
value = (b + i * 2) + "";
map.put(key, value);
list.add(map);


for (int i = 0; i < list.size(); i++) 
System.out.println(list.get(i));

 运行结果 ：

1=23=45=67=89=1011=1213=1415=1617=1819=2021=2223=2425=2627=2829=3031=3233=3435=3637=3839=4041=4243=4445=4647=4849=5051=5253=5455=5657=5859=6061=6263=6465=6667=6869=7071=7273=7475=7677=7879=8081=8283=8485=8687=8889=9091=9293=9495=9697=9899=100

参考技术A int a=1;
int b=2;
Map<String,Object> map = new HashMap<String,Object>();
String key = "";
int value = 0;
for(int i=0;i<50;i++)
    key = (a+i*2).toString();
    value = b+i*2;
    map.add(key,value);

大概就是这样吧。

追问

帮你改了下 map不是add是put
还有那个key不能,toString()
结果出来是1=2, 3=4, 5=6, 7=8, 9=10, 11=12, 13=14, 15=16。。。。99=100
但我想要的是1=2 3=4 5=6。。。99=100可以分开吗
不要一个大的map集合
谢谢你了 等下没好答案分给你

参考技术B 其实你对应的代码挺好的，挺有顺序，也就是说a某个位置的数，正好对应同样位置的b，a和b尽量是数组或者字符串自己截取成数组也可以（主要是为了方便循环），所以可以试试下面的：
Map<String,String> map = new HashMap<String,String>();
for(int i=0;i<a.length;i++)
map.put(a[i]+"",b[i]+"");

Java学习笔记32（集合框架六：Map接口）

Map接口与Collection不同：

Collection中的集合元素是孤立的，可理解为单身，是一个一个存进去的，称为单列集合

Map中的集合元素是成对存在的，可理解为夫妻，是一对一对存进去的，称为双列集合

Map中存入的是：键值对，键不可以重复，值可以重复

 

Map接口中的常用集合：

1.HashMap：哈希表的存储结构，但是无法保证存取顺序

2.LinkedHashMap：存储数据采用的是哈希表和链表，可以有顺序

 

Map接口的常用方法：

示例：

package demo;

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

public class MapDemo {
    public static void main(String[] args) {
        function1();
        function2();
        function3();
    }

    public static void function1() {
        // 将键值对存储到集合中
        Map<String, Integer> map = new HashMap<String, Integer>();
        map.put("a", 1);
        map.put("b", 2);
        map.put("c", 3);
        map.put("c", 4);
        System.out.println(map);
        // {b=2, c=4, a=1}
        // =连接键值对，存入重复键，则会覆盖
    }

    public static void function2() {
        //通过键获取值
        Map<Integer, String> map = new HashMap<Integer, String>();
        map.put(1, "a");
        map.put(2, "b");
        map.put(3, "c");
        String value = map.get(1);
        System.out.println(value);//a
        //有则返回值，不存在返回null
    }
    public static void function3(){
        //移除集合中的键值对
        Map<Integer, String> map = new HashMap<Integer, String>();
        map.put(1, "a");
        map.put(2, "b");
        map.put(3, "c");
        map.remove(3);
        System.out.println(map);
        //{1=a, 2=b}
    }
}

 

Map接口的遍历：

第一种方式：

package demo;

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

public class MapDemo {
    public static void main(String[] args) {
        function1();
        function2();
    }

    public static void function1() {
        Map<String, Integer> map = new HashMap<String, Integer>();
        map.put("a", 1);
        map.put("b", 2);
        map.put("c", 3);
        map.put("d", 4);
        Set<String> set = map.keySet();
        Iterator<String> it = set.iterator();
        while (it.hasNext()) {
            String key = it.next();
            Integer value = map.get(key);
            System.out.println(key + "<==>" + value);
        }
    }

    public static void function2() {
        Map<String, Integer> map = new HashMap<String, Integer>();
        map.put("a", 1);
        map.put("b", 2);
        map.put("c", 3);
        map.put("d", 4);
        for (String key : map.keySet()) {
            Integer value = map.get(key);
            System.out.println(key + "<==>" + value);
        }
    }
}
// 遍历输出的无序

 

第二种方式（根据映射关系）：

package demo;

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

public class MapDemo {
    public static void main(String[] args) {
        Map<Integer, String> map = new HashMap<Integer, String>();
        map.put(1, "a");
        map.put(2, "b");
        map.put(3, "c");
        Set<Entry<Integer, String>> set = map.entrySet();
        Iterator<Entry<Integer, String>> it = set.iterator();
        while (it.hasNext()) {
            Entry<Integer, String> entry = it.next();
            Integer key = entry.getKey();
            String value = entry.getValue();
            System.out.println(key + "<==>" + value);
        }
    }
}

 

存储自定义对象：

 

package demo;

public class Person {
    private String name;
    private int 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;
    }

    public Person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }

    public Person() {
        super();
        // TODO Auto-generated constructor stub
    }

    @Override
    public String toString() {
        return "Person [name=" + name + ", age=" + age + "]";
    }

    @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;
        Person other = (Person) 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;
    }

}

package demo;

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

//存储自定义类型
public class HashMapDemo {
    public static void main(String[] args) {
        function1();
        function2();
    }

    public static void function1() {
        // 自定义类型作为值出现
        HashMap<String, Person> map = new HashMap<String, Person>();
        map.put("a", new Person("1", 20));
        map.put("b", new Person("2", 20));
        map.put("c", new Person("3", 20));
        // 利用两种遍历
        for (String key : map.keySet()) {
            Person value = map.get(key);
            System.out.println(key + "<==>" + value);
        }
        for (Entry<String, Person> entry : map.entrySet()) {
            String key = entry.getKey();
            Person value = entry.getValue();
            System.out.println(key + "<==>" + value);
        }
    }

    public static void function2() {
        // 自定义类型作为键出现
        // 保证键的唯一性，需要重写hashcode和equals方法
        HashMap<Person, String> map = new HashMap<Person, String>();
        map.put(new Person("a", 20), "a");
        map.put(new Person("b", 20), "a");
        map.put(new Person("c", 20), "a");
        map.put(new Person("c", 20), "a");
        // 两种遍历
        for (Person key : map.keySet()) {
            String value = map.get(key);
            System.out.println(key + "<==>" + value);
        }
        for (Entry<Person, String> entry : map.entrySet()) {
            System.out.println(entry.getKey() + "<==>" + entry.getValue());
        }
    }

}

 

LinkedHashMap集合：

package demo;

import java.util.LinkedHashMap;

public class LinkedHashMapDemo {
    public static void main(String[] args) {
        LinkedHashMap<String, String> link = new LinkedHashMap<String, String>();
        link.put("1", "a");
        link.put("2", "a");
        link.put("3", "a");
        link.put("4", "a");
        System.out.println(link);
        //{1=a, 2=a, 3=a, 4=a}
        //存取顺序一致
    }
}

 

set接口下还有一个hashtable集合，但是过时了，现在由hashmap取代

不过，要注意一个问题：

HashMap允许存储null值，HashTable不允许存储null值，两种都不允许存储null键