java------集合及相关方法

java集合

数组和集合可以当作容器，可以储存多个元素，其中，数组储存元素的个数是固定的，集合就可以储存元素的个数是不固定的。数组可以储存的元素类型可以是引用类型也可以是基本数据类型，集合储存引用数据类型，如果要储存基本数据类型，那么就需要储存其包装类型。

其整体框架如下:

Collection相关知识

Collection介绍:

是单例集合的顶层接口,它表示一组对象,这些对象也称为Collection的元素
JDK 不提供此接口的任何直接实现.它提供更具体的子接口(如Set和List)实现

Collection特性:

有序性保证按插入顺序排序(List) 储存和去除元素顺序不一致(Set)
唯一性可以储存重复元素(List) 不能存储重复元素(Set)
获取元素可以通过索引获取元素(List) 不能通过索引获取元素(Set)

Collection方法:

增加元素 add
移除元素 remove removeIf
获取每个元素遍历器Iterator
清除元素 clear
包含元素 contains
判断是否为空 isEmpty
元素长度 size

方法名	说明
boolean add(E e)	添加元素
boolean remove(Object o)	从集合中移除指定的元素
boolean removeIf(Object o)	根据条件进行移除
void clear()	清空集合中的元素
boolean contains(Object o)	判断集合中是否存在指定的元素
boolean isEmpty()	判断集合是否为空
int size()	集合的长度，也就是集合中元素的个数

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class testCollection {
    public static void main(String[] args) {
        Collection<String> collection = new ArrayList<>();
        //增加元素add
        collection.add("hello");//增加元素  hello
        collection.add("world");//增加元素  world
        collection.add("JAVAee");//增加元素  JAVAee
        collection.add("java");//增加元素   java
        System.out.println(collection);//显示匀速 [hello ,world,JAVAee,java]  按照顺序输出
        //size方法
        System.out.println("长度:"+collection.size());//求其长度为4
        //remove方法
        collection.remove("JAVAee");//删除元素
        System.out.println(collection);//[hello,world,java]
        //removeIf
        collection.add("JAVAEE");
        System.out.println(collection);//[hello, world, java]
        collection.removeIf(i->i.equals("JAVAEE"));//lamada表达式  [hello, world, java, JAVAEE]
        System.out.println(collection);//[hello, world, java]
        //isEmpty方法
        System.out.println(collection.isEmpty());//false
        //遍历元素
        Iterator<String> it = collection.iterator();//迭代器遍历元素
        while(it.hasNext()){//判断当前位置是否有元素可以被取出
            String c = it.next();//获取当前位置的元素,将迭代器对象移向下一个索引位置
            System.out.print(c+"\t");
        }//hello	world	java
        System.out.println();
        for(String str:collection){//增强for循环
            System.out.print(str+"\t");
        }//hello	world	java
        System.out.println();
        collection.forEach(value->System.out.print(value+"\t"));//hello	world	java
        System.out.println();
        //contains方法
        System.out.println(collection.contains("java"));//包含元素  true
        //clear()方法
        collection.clear();
        System.out.println(collection.isEmpty());//判断是否为空   true
    }
}

注意点:

1.it.next指针到最后面不会复位

while(it.hasNext()){//判断当前位置是否有元素可以被取出
            String c = it.next();//获取当前位置的元素,将迭代器对象移向下一个索引位置
            System.out.print(c+"\t");
        }//hello	world	java
        System.out.println("it="+it);
        System.out.println("it.next()="+it.next());//报错

it=java.util.ArrayList$Itr@378bf509
Exception in thread "main" java.util.NoSuchElementException
	at java.base/java.util.ArrayList$Itr.next(ArrayList.java:970)
	at testCollection.main(testCollection.java:33)

2.迭代器遍历时，不能用集合的方法进行增加或者删除

//lamada表达式
//增加元素add
collection.add("hello");//增加元素  hello
collection.add("world");//增加元素  world
collection.add("JAVAee");//增加元素  JAVAee
collection.add("java");//增加元素   java
collection.forEach(s->System.out.print(s+"\t"));
显示结果:
hello	world	JAVAee	java

单列集合相关知识

List单列集合

有序集合，这里的有序指的是存取顺序
用户可以精确控制列表中每个元素的插入位置,用户可以通过整数索引访问元素,并搜索列表中的元素
与Set集合不同,列表通常允许重复的元素

List集合的特点

存取有序
可以重复
有索引

List增加的就是索引

方法名	描述
void add(int index,E element)	在此集合中的指定位置插入指定的元素
E remove(int index)	删除指定索引处的元素，返回被删除的元素
E set(int index,E element)	修改指定索引处的元素，返回被修改的元素
E get(int index)	返回指定索引处的元素

遍历方法:

迭代器
列表迭代器
增强for
Lambda表达式
普通for循环

import java.util.*;

public class testList {
    public static void main(String[] args) {
        List<String> list =new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        list.add("e");
        for(String str:list){
            System.out.print(str+"\t");//打印出来  a	b	c	d	e
        }
        //增加元素  add(index,element)
        //        void add(int index,E element)	在此集合中的指定位置插入指定的元素
        //原来位置上的元素往后挪一个索引.
        list.add(0,"g");//在0处的位置增加元素g
        System.out.println();
        list.forEach(value->System.out.print(value+"\t"));//g	a	b	c	d	e
        //删除元素 remove(index)
        String s = list.remove(0);
        System.out.println();
        System.out.print(s);//移除元素索引0的元素	a	b	c	d	e
        System.out.println();
        list.forEach(value->System.out.print(value+"\t"));
        //修改元素值  set
        list.set(list.size()-1,"f");//修改值
        System.out.println();
        list.forEach(value->System.out.print(value+"\t"));//a	b	c	d	f
        //查找元素  get方法
        System.out.println();
        for (int i = 0; i < list.size(); i++) {
            System.out.print(list.get(i)+"\t");//a	b	c	d	f
        }
    }
}

//创建集合并添加元素
List<String> list = new ArrayList<>();
list.add("aaa");
list.add("bbb");
list.add("ccc");

//1.迭代器
/*Iterator<String> it = list.iterator();
     while(it.hasNext()){
        String str = it.next();
        System.out.println(str);
}*/


//2.增强for
//下面的变量s，其实就是一个第三方的变量而已。
//在循环的过程中，依次表示集合中的每一个元素
/* for (String s : list) {
       System.out.println(s);
   }*/

//3.Lambda表达式
//forEach方法的底层其实就是一个循环遍历，依次得到集合中的每一个元素
//并把每一个元素传递给下面的accept方法
//accept方法的形参s，依次表示集合中的每一个元素
//list.forEach(s->System.out.println(s) );


//4.普通for循环
//size方法跟get方法还有循环结合的方式，利用索引获取到集合中的每一个元素
/*for (int i = 0; i < list.size(); i++) {
            //i:依次表示集合中的每一个索引
            String s = list.get(i);
            System.out.println(s);
        }*/

// 5.列表迭代器
//获取一个列表迭代器的对象，里面的指针默认也是指向0索引的

//额外添加了一个方法：在遍历的过程中，可以添加元素
ListIterator<String> it = list.listIterator();
while(it.hasNext()){
    String str = it.next();
    if("bbb".equals(str)){
        //qqq
        it.add("qqq");
    }
}
System.out.println(list);

注意的事项:

直接删除元素
通过索引进行删除

显示结果:

List相关集合
[1, 2, 3]
[1, 3]
[3]

LinkedList集合

方法名	说明
public void addFirst(E e)	在该列表开头插入指定的元素
public void addLast(E e)	将指定的元素追加到此列表的末尾
public E getFirst()	返回此列表中的第一个元素
public E getLast()	返回此列表中的最后一个元素
public E removeFirst()	从此列表中删除并返回第一个元素
public E removeLast()	从此列表中删除并返回最后一个元素

import java.util.LinkedList;

public class testLinkedList {
    public static void main(String[] args) {
        LinkedList<String> linkedList = new LinkedList<>();
        linkedList.add("a");
        linkedList.add("b");
        linkedList.add("c");
        linkedList.add("d");
        linkedList.add("e");
        System.out.println("集合元素:"+linkedList);//[a, b, c, d, e]
        //获取第一个元素
        String firstget = linkedList.getFirst();
        System.out.println("获取第一个元素:"+firstget);//a
        //获取最后一个元素
        String lastget = linkedList.getLast();
        System.out.println("获取最后一个元素:"+lastget);//e
        //向索引0增加元素
        linkedList.addFirst("f");
        System.out.println("插入第一个元素的集合为:"+linkedList);//[f, a, b, c, d, e]
        //增加最后一个元素
        linkedList.addLast("g");
        System.out.println("插入最后一个元素的集合为:"+linkedList);//[f, a, b, c, d, e, g]
        //删除第一个元素
        linkedList.removeFirst();
        System.out.println("删除第一个元素的集合为:"+linkedList);//[a, b, c, d, e, g]
        //删除最后一个元素
        linkedList.removeLast();
        System.out.println("删除最后一个元素的集合为:"+linkedList);//[a, b, c, d, e]
    }
}

Set单列集合

不可以存储重复元素

没有索引,不能使用普通for循环遍历

注意:Set集合可以不能储存重复元素

import java.util.*;

public class testSet {
    public static void main(String[] args) {
        Set<String> set = new TreeSet<>();
        set.add("aa");
        set.add("bb");
        set.add("cc");
        set.add("aa");
        for (String str:set){
            System.out.println(str);
        }//aa	bb	cc		
        set.forEach(value->System.out.print(value+"\t"));//aa	bb	cc
        Iterator<String> it = set.iterator();
        System.out.println();
        while(it.hasNext()){
            String s = it.next();
            System.out.print(s+"\t");//aa	bb	cc
        }
    }
}

TreeSet

不可以存储重复元素
没有索引
可以将元素按照规则进行排序
- TreeSet()：根据其元素的自然排序进行排序
- TreeSet(Comparator comparator) ：根据指定的比较器进行排序

import java.util.TreeSet;

public class testTreeSet {
    public static void main(String[] args) {
        TreeSet<Integer> treeSet = new TreeSet<>();
        treeSet.add(12);
        treeSet.add(11);
        treeSet.add(13);
        treeSet.add(10);
        treeSet.add(15);
        treeSet.add(13);
        System.out.println(treeSet);
        System.out.println();//[10, 11, 12, 13, 15]
        for(Integer it:treeSet){
            System.out.print(it+"\t");//10	11	12	13	15
        }
        System.out.println();

    }
}

比较器的方法

自然排序Comparable的使用(黑马程序案例)

案例需求
- 存储学生对象并遍历，创建TreeSet集合使用无参构造方法
- 要求：按照年龄从小到大排序，年龄相同时，按照姓名的字母顺序排序
实现步骤
1. 使用空参构造创建TreeSet集合
  - 用TreeSet集合存储自定义对象，无参构造方法使用的是自然排序对元素进行排序的
2. 自定义的Student类实现Comparable接口
  - 自然排序，就是让元素所属的类实现Comparable接口，重写compareTo(T o)方法
3. 重写接口中的compareTo方法
  - 重写方法时，一定要注意排序规则必须按照要求的主要条件和次要条件来写

public class Student implements Comparable<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;
    }
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
    @Override
    public int compareTo(Student o) {
        //按照对象的年龄进行排序
        //主要判断条件: 按照年龄从小到大排序
        int result = this.age - o.age;
        //次要判断条件: 年龄相同时，按照姓名的字母顺序排序
        result = result == 0 ? this.name.compareTo(o.getName()) : result;
        return result;
    }
}
import java.util.TreeSet;

public class MyTreeSet2 {
    public static void main(String[] args) {
        //创建集合对象
        TreeSet<Student> ts = new TreeSet<>();
        //创建学生对象
        Student s1 = new Student("zhangsan",28);
        Student s2 = new Student("lisi",27);
        Student s3 = new Student("wangwu",29);
        Student s4 = new Student("zhaoliu",28);
        Student s5 = new Student("qianqi",30);
        //把学生添加到集合
        ts.add(s1);
        ts.add(s2);
        ts.add(s3);
        ts.add(s4);
        ts.add(s5);
        //遍历集合
        for (Student student : ts) {
            System.out.println(student);
        }
    }
}
//显示结果
Student{name='lisi', age=27}
Student{name='zhangsan', age=28}
Student{name='zhaoliu', age=28}
Student{name='wangwu', age=29}
Student{name='qianqi', age=30}

比较器排序Comparator的使用

案例需求
- 存储老师对象并遍历，创建TreeSet集合使用带参构造方法
- 要求：按照年龄从小到大排序，年龄相同时，按照姓名的字母顺序排序
实现步骤
- 用TreeSet集合存储自定义对象，带参构造方法使用的是比较器排序对元素进行排序的
- 比较器排序，就是让集合构造方法接收Comparator的实现类对象，重写compare(T o1,T o2)方法
- 重写方法时，一定要注意排序规则必须按照要求的主要条件和次要条件来写

public class Teacher {
    private String name;
    private int age;

    public Teacher() {
    }

    public Teacher(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;
    }

    @Override
    public String toString() {
        return "Teacher{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
public class MyTreeSet4 {
    public static void main(String[] args) {
      	//创建集合对象
        TreeSet<Teacher> ts = new TreeSet<>(new Comparator<Teacher>() {
            @Override
            public int compare(Teacher o1, Teacher o2) {
                //o1表示现在要存入的那个元素
                //o2表示已经存入到集合中的元素
              
                //主要条件
                int result = o1.getAge() - o2.getAge();
                //次要条件
                result = result == 0 ? o1.getName().compareTo(o2.getName()) : result;
                return result;
            }
        });
		//创建老师对象
        Teacher t1 = new Teacher("zhangsan",23);
        Teacher t2 = new Teacher("lisi",22);
        Teacher t3 = new Teacher("wangwu",24);
        Teacher t4 = new Teacher("zhaoliu",24);
		//把老师添加到集合
        ts.add(t1);
        ts.add(t2);
        ts.add(t3);
        ts.add(t4);
		//遍历集合
        for (Teacher teacher : ts) {
            System.out.println(teacher);
        }
    }
}

两种比较方式小结
- 自然排序: 自定义类实现Comparable接口,重写compareTo方法,根据返回值进行排序
- 比较器排序: 创建TreeSet对象的时候传递Comparator的实现类对象,重写compare方法,根据返回值进行排序
- 在使用的时候,默认使用自然排序,当自然排序不满足现在的需求时,必须使用比较器排序
两种方式中关于返回值的规则
- 如果返回值为负数，表示当前存入的元素是较小值，存左边
- 如果返回值为0，表示当前存入的元素跟集合中元素重复了，不存
- 如果返回值为正数，表示当前存入的元素是较大值，存右边

HashSet集合概述和特点

底层数据结构是哈希表
存取无序
不可以存储重复元素
没有索引,不能使用普通for循环遍历

import java.util.*;
public class testHashSet {
    public static void main(String[] args) {
        //创建集合对象
        HashSet<String> set = new HashSet<String>();

        //添加元素
        set.add("hello");
        set.add("world");
        set.add("java");
        //不包含重复元素的集合
        set.add("world");
        System.out.println(set);//[world, java, hello]
        System.out.println();
        //遍历
        for(String s : set) {
            System.out.print(s+"\t");//world	java	hello	
        }
    }
}

哈希值【理解】

哈希值简介

是JDK根据对象的地址或者字符串或者数字算出来的int类型的数值
如何获取哈希值

Object类中的public int hashCode()：返回对象的哈希码值
哈希值的特点
- 同一个对象多次调用hashCode()方法返回的哈希值是相同的
- 默认情况下，不同对象的哈希值是不同的。而重写hashCode()方法，可以实现让不同对象的哈希值相同

Map集合

Map集合概述

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

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

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

import java.util.*;

public class testMap {
    public static void main(String[] args) {
        Map<String,String> map = new HashMap<String,String>();
        map.put("1","zhangsan");
        map.put("2","lisi");
        map.put("3","wangwu");
        map.put("4","zholiu");
        map.put("5","xianzqi");
        //输出集合对象
        System.out.println(map);//{1=zhangsan, 2=lisi, 3=wangwu, 4=zholiu, 5=xianzqi}
        //是否移除元素
        System.out.println(map.remove("1"));//移除建为1的键值对
        System.out.println(map);//{2=lisi, 3=wangwu, 4=zholiu, 5=xianzqi}
        //是否包含该元素
        System.out.println(map.containsKey("2"));//是否包含键为2的键值对
        System.out.println(map);//{2=lisi, 3=wangwu, 4=zholiu, 5=xianzqi}
        //是否包含该值
        System.out.println(map.containsValue("zhangsan"));//false
        //判断该元素是否为空
        System.out.println(map.isEmpty());//false
        //求出其长度
        System.out.println(map.size());//长度为4
        //获取值
        System.out.println(map.get("2"));//根据键为2的值为lisi
        //set方法
        Set<String> key=map.keySet();
        for(String str:key){//2    3    4    5
            System.out.print(str+"\t");
        }
        System.out.println();
        Collection<String> values=map.values();
        for(String str:values){//lisi    wangwu    zholiu    xianzqi
            System.out.print(str+"\t");
        }
        System.out.println();
        //创建集合对象
        Map<String, String> map2 = new HashMap<String, String>();

        //添加元素
        map2.put("张无忌", "赵敏");
        map2.put("郭靖", "黄蓉");
        map2.put("杨过", "小龙女");
        map2.put("杨过", "郭襄");

        //获取所有键值对对象的集合
        Set<Map.Entry<String, String>> entrySet = map2.entrySet();
        //遍历键值对对象的集合，得到每一个键值对对象
        for (Map.Entry<String, String> me : entrySet) {
            //根据键值对对象获取键和值
            String key1 = me.getKey();
            String value = me.getValue();
            System.out.println(key1 + "," + value);
        }
        /**
         * 杨过,郭襄
         * 郭靖,黄蓉
         * 张无忌,赵敏
         */
    }
}

遍历方式1：

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

public class MapDemo01 {
    public static void main(String[] args) {
        //创建集合对象
        Map<String, String> map = new HashMap<String, String>();

        //添加元素
        map.put("张无忌", "赵敏");
        map.put("郭靖", "黄蓉");
        map.put("杨过", "小龙女");

        //获取所有键的集合。用keySet()方法实现
        Set<String> keySet = map.keySet();
        System.out.println(keySet);//[杨过, 郭靖, 张无忌]
        //遍历键的集合，获取到每一个键。用增强for实现
        for (String key : keySet) {
            //根据键去找值。用get(Object key)方法实现
            String value = map.get(key);
            System.out.print(value+"\t");//小龙女 黄蓉	赵敏
//            System.out.println(key + "," + value);
        }
        /**
         * 杨过,小龙女
         * 郭靖,黄蓉
         * 张无忌,赵敏
         */
    }
}

遍历方式2：

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

public class MapDemo02 {
    public static void main(String[] args) {
        //创建集合对象
        Map<String, String> map = new HashMap<String, String>();

        //添加元素
        map.put("张无忌", "赵敏");
        map.put("郭靖", "黄蓉");
        map.put("杨过", "小龙女");

        //获取所有键值对对象的集合
        Set<Map.Entry<String, String>> entrySet = map.entrySet();
        System.out.println(entrySet);//[杨过=小龙女, 郭靖=黄蓉, 张无忌=赵敏]
        //遍历键值对对象的集合，得到每一个键值对对象
        for (Map.Entry<String, String> me : entrySet) {
            //根据键值对对象获取键和值
            String key = me.getKey();
            String value = me.getValue();
            System.out.println(key + "," + value);
        }
        /**
         * 杨过,小龙女
         * 郭靖,黄蓉
         * 张无忌,赵敏
         */
    }
}

HashMap:

HashMap底层是哈希表结构的
依赖hashCode方法和equals方法保证键的唯一
如果键要存储的是自定义对象，需要重写hashCode和equals方法

package testHashMap;

public 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;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        Student student = (Student) o;

        if (age != student.age) return false;
        return name != null ? name.equals(student.name) : student.name == null;
    }

    @Override
    public int hashCode() {
        int result = name != null ? name.hashCode() : 0;
        result = 31 * result + age;
        return result;
    }
}
package testHashMap;
import java.util.*;
public class HashMapDemo {
    public static void main(String[] args) {
        //创建HashMap集合对象
        HashMap<Student, String> hm = new HashMap<Student, String>();

        //创建学生对象
        Student s1 = new Student("林青霞", 30);
        Student s2 = new Student("张曼玉", 35);
        Student s3 = new Student("王祖贤", 33);
        Student s4 = new Student("王祖贤", 33);

        //把学生添加到集合
        hm.put(s1, "西安");
        hm.put(s2, "武汉");
        hm.put(s3, "郑州");
        hm.put(s4, "北京");

        System.out.println(hm);
        //遍历集合
        Set<Student> keySet = hm.keySet();
        System.out.println(keySet);
        for (Student key : keySet) {
            String value = hm.get(key);
            System.out.println(key.getName() + "," + key.getAge() + "," + value);
        }
    }
}
//显示结果
{testHashMap.Student@365e6fe8=北京, testHashMap.Student@2cce6296=武汉, testHashMap.Student@3161349b=西安}
[testHashMap.Student@365e6fe8, testHashMap.Student@2cce6296, testHashMap.Student@3161349b]
王祖贤,33,北京
张曼玉,35,武汉
林青霞,30,西安


package testTreeMap;

public class Student implements Comparable<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;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public int compareTo(Student o) {
        //按照年龄进行排序
        int result = o.getAge() - this.getAge();
        //次要条件，按照姓名排序。
        result = result == 0 ? o.getName().compareTo(this.getName()) : result;
        return result;
    }
}
package testTreeMap;
import java.util.*;
public class Test1 {
    public static void main(String[] args) {
        // 创建TreeMap集合对象
        TreeMap<Student,String> tm = new TreeMap<>();

        // 创建学生对象
        Student s1 = new Student("xiaohei",23);
        Student s2 = new Student("dapang",22);
        Student s3 = new Student("xiaomei",22);

        // 将学生对象添加到TreeMap集合中
        tm.put(s1,"江苏");
        tm.put(s2,"北京");
        tm.put(s3,"天津");

        // 遍历TreeMap集合,打印每个学生的信息
        tm.forEach(
                (Student key, String value)->{
                    System.out.println(key + "---" + value);
                }
        );
        //Student{name='xiaohei', age=23}---江苏
        //Student{name='xiaomei', age=22}---天津
        //Student{name='dapang', age=22}---北京
    }
}

posted @ 2024-01-13 18:25 无名之辈的ggb 阅读(7) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· java------字符串

· java------数组

· java-集合

· Collection集合&List集合&Set集合

· Java-集合（面试重点）

阅读排行：
· TypeScript + Deepseek 打造卜卦网站：技术与玄学的结合
· Manus的开源复刻OpenManus初探
· AI 智能体引爆开源社区「GitHub 热点速览」
· 三行代码完成国际化适配，妙~啊~
· .NET Core 中如何实现缓存的预热？

点博客

关于我：24年毕业，现从事Java后端开发，偶尔搞搞Android、小程序等。博客持续更新欢迎关注。