JAVA集合小妙招

最新推荐文章于 2025-07-30 09:18:55 发布

小吕努力变强

最新推荐文章于 2025-07-30 09:18:55 发布

阅读量107

点赞数

CC 4.0 BY-SA版权

分类专栏：入门 java 文章标签： java 集合 hashmap map arraylist

本文链接：https://blog.youkuaiyun.com/qq_48033003/article/details/115584401

java 同时被 2 个专栏收录

69 篇文章

订阅专栏

入门

44 篇文章

订阅专栏

1.集合概述

1.Java的集合就像是一个容器，专门用于储存java对象，这些对象可以是任意的数据类型，并且长度可变。
2.集合按照存储结构可以分为两大类，即单列集合（Collection）和双列集合（Map）
	1.Collection：单列集合的根接口，用于存储一系列符合某种规则的元素，
	他有两个重要的子接口，分别是List和Set，其中List集合的特点是元素有序、
	可重复；Set集合的特点是元素无序并且不可重复。List接口的主要实现类是ArrayList和LinkedList；Set接口的主要实现类有HashSet和TreeSet。
	2.Map：双列集合的根接口，用于存储具有键（key）、值（value）映射关系的元素。
	Map接口的主要实现类有HashMap和TreeMap。
3.结构大致如下

集合结构图

2.Collection接口

List接口
	特点：有序可重复。
	1.Arraylist代码：

package com.hkd.collectionAndMap;


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

/**
 * ArrayList例子
 */
public class Test1 {
    public static void main(String[] args) {
        //创建一个ArrayList对象
        ArrayList arrayList=new ArrayList();
        //向ArrayList对象添加几条数据
        arrayList.add("xiaoming");
        arrayList.add("zhangsan");
        arrayList.add("lisi");

        //遍历输出
        //1.for循环输出
        for (int i = 0; i < arrayList.size(); i++) {
            System.out.println(arrayList.get(i));
        }
        //2.增强for循环输出
        for (Object o : arrayList) {
            System.out.println(o);
        }
        //3.迭代器遍历
        Iterator iterator1=arrayList.iterator();
        while (iterator1.hasNext()){
            System.out.println(iterator1.next());
        }
        //3.ForEach输出
        arrayList.forEach(str->System.out.println(str));

        //获得arrayList的某个地址下的元素
        System.out.println(arrayList.get(1));

        //移除arrayList的某个地址下的元素
        arrayList.remove(2);

        //获得该元素在arrayList集合中首次出现的地址
        System.out.println(arrayList.indexOf("xiaoming"));

        //获得该元素在arrayList集合中最后出现的地址
        System.out.println(arrayList.lastIndexOf("xiaoming"));

        //将集合对象转换为数组
        Object [] arr=new Object[arrayList.size()];
        arr=arrayList.toArray();

        //循环遍历删除
        //1.for删除
        for (int i = 0; i < arrayList.size(); i++) {
            arrayList.remove(i);
        }
        //2.迭代器删除
        Iterator iterator= arrayList.iterator();
        while (iterator.hasNext()){
            if (iterator.next().equals("xiaoming")){
                iterator.remove();
            }
        }
    }
}

2.LinkedList代码

package com.hkd.collectionAndMap;

import java.util.Iterator;
import java.util.LinkedList;

/**
 * LinkedList集合例子
 */
public class Test2 {
    public static void main(String[] args) {
        //创建一个LinkedList集合
        LinkedList link=new LinkedList();
        //添加元素
        link.add("xiaoming");
        link.add("xiaohong");
        //输出集合元素
        System.out.println("输出集合为"+link);

        //向集合尾部添加元素
        link.offer("offer");
        //输出集合
        System.out.println("向尾部添加元素之后输出集合为"+link);
        //向集合头部添加元素
        link.push("push");
        //输出集合
        System.out.println("向集合尾部添加元素之后输出集合为"+link);

        //获取元素第一个元素
        System.out.println("集合的第一个元素是"+link.peek());


        //删除集合的第一个元素,并返回第一个元素
        System.out.println("删除第一个元素"+link.removeFirst());
        System.out.println("删除集合的第一个元素之后的集合是"+link);

        //删除集合的最后一个元素,并返回最后一个元素
        System.out.println("删除最后一个元素"+link.removeLast());
        System.out.println("删除集合的最后一个元素之后的集合是"+link);

        //遍历集合
        //方法一 for循环遍历
        System.out.println("for循环遍历输出如下");
        for (int i = 0; i < link.size(); i++) {
            System.out.println(link.get(i));
        }
        //方法二 增强for循环遍历
        System.out.println("增强for循环遍历如下");
        for (Object o : link) {
            System.out.println(o);
        }
        //方法三 迭代器遍历
        Iterator iterator= link.iterator();
        System.out.println("迭代器遍历如下");
        while (iterator.hasNext()){
           System.out.println(iterator.next());
        }
        
        //方法四 ForEach遍历
        System.out.println("ForEach遍历如下");
        link.forEach(str->System.out.println(str));

    }
}

set接口
	特点：无序不可重复
	1.HashSet集合代码

package com.hkd.collectionAndMap;

import java.util.HashSet;

/**
 * HashSet例子
 */
public class Test3 {
    public static void main(String[] args) {

        //创建一个User类型的HashSet对象
        HashSet<User> hashSet=new HashSet<>();

        //向hashSet对象中添加元素
        hashSet.add(new User(1,"小明"));
        hashSet.add(new User(2,"小红"));
        hashSet.add(new User(3,"小刚"));

        //输出集合
        System.out.println("输出集合如下"+hashSet);
        //向集合添加一个id相同的元素
        hashSet.add(new User(1,"小丽"));
        //再次输出集合 
        /**
         * 由于在User实体类中重写了equals方法
         * 所以这个相同id的这个User对象添加不进去
         */
        System.out.println("添加一个相同id的元素之后的集合如下"+hashSet);
        
        //输出方法参考上面的Arraylist
    }

}

package com.hkd.collectionAndMap;

import java.util.Objects;

public class User {
    private int id;
    private String name;

    public User(int id, String name) {
        this.id = id;
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    //重写equals方法
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        User user = (User) o;
        //如果要添加的元素的id与之前的id重复，返回true 即是添加添加不进去
        return id == user.id ;
    }

    //重写hashCode方法
    @Override
    public int hashCode() {
        return Objects.hash(id);
    }

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

TreeSet集合
	特点：按照一种特殊的排序方式，不可重复
	代码如下

package com.hkd.collectionAndMap;

import java.util.TreeSet;

/**
 * TreeSet集合例子
 */
public class Test4 {
    public static void main(String[] args) {
        //创建一个存储Student对象的TreeSet对象
        TreeSet<Student> treeSet=new TreeSet<>();
        //向集合中添加几个Student对象
        treeSet.add(new Student("小明",18));
        treeSet.add(new Student("小红",16));
        treeSet.add(new Student("小刚",20));
        //输出集合（按照年龄升序进行排序）
        System.out.println(treeSet);

        //向tree集合添加一个相同name的Student对象
        treeSet.add(new Student("小明",17));
        //再次输出集合
        System.out.println(treeSet);
        
        

    }
}

package com.hkd.collectionAndMap;

/**
 * Student实体类
 * 继承
 */
public class Student implements Comparable {
    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 Student(String name, int age) {
        this.name = name;
        this.age = age;
    }


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

    @Override
    public int compareTo(Object o) {

        Student s=(Student) o;
        //定义比较方法，先比较年龄age，在比较名称name
        if (this.age-s.age>0){
            return 1;
        }
        if (this.age-s.age==0){
            return this.name.compareTo(s.name);
        }
        return -1;
    }
}

3.Map接口

HashMap
	特点：增删改查效率都很高，键不能重复，元素无序
	代码

package com.hkd.collectionAndMap;

import com.sun.org.apache.xalan.internal.xsltc.dom.StripWhitespaceFilter;

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

/**
 * HashMap例子
 */
public class Test5 {
    public static void main(String[] args) {
        //创建一个存放Integer类型的id为key
        //Customer类型为value的双列HashMap集合对象
        HashMap<Integer,Customer> hashMap=new HashMap<>();

        //向hashMap集合存入几个数据
        hashMap.put(1,new Customer("小明","177"));
        hashMap.put(2,new Customer("小李","169"));
        hashMap.put(3,new Customer("小红","178"));

        //输出集合
        System.out.println(hashMap);
        //再向集合存进去一个相同id的数据
        hashMap.put(1,new Customer("xiaoming","177"));
        //输出集合
        /**
         * 发现相同id的数据被后添加的数据覆盖
         */
        System.out.println(hashMap);


        //遍历输出
        //方法一 forEach遍历
        hashMap.forEach((key,value)->System.out.println("key是"+key+"value是"+value));
        //方法二 迭代器遍历
        /**
         * 先通过hashMap对象的keySet方法获得键的set集合
         * 然后通过迭代器遍历set集合，获得每一个key键，
         * 再通过hashMap对象的get(key)方法获得每个对应的value值
         */
        Set keySet= hashMap.keySet();
        Iterator iterator= keySet.iterator();
        while (iterator.hasNext()){
           Object key=iterator.next();
           Object value=hashMap.get(key);
           System.out.println("key是"+key+"value是"+value);
        }

        //方法三 entrySet迭代器遍历

        /**
         * 通过hashMap对象的entrySet方法获得一个Set集合对象
         * 这个集合对象封装的是Map.Entry类型的
         * 而这个Entry类型是将hashMap对象的单个键和值封装在这个里面
         * 最后遍历的时候通过Entry.getKey和Entry.getValue
         */
        Set  entrySet=  hashMap.entrySet();
        Iterator iterator1=entrySet.iterator();
        while (iterator.hasNext()){
            Map.Entry<Integer,Customer> entry= (Map.Entry<Integer, Customer>) iterator1.next();

            System.out.println("key是"+entry.getKey());
            System.out.println("value是"+entry.getValue());
        }

    }
}

package com.hkd.collectionAndMap;

import java.util.Objects;

/**
 * Customer实体类
 * 用于被HashMap集合储存
 */
public class Customer {
    private String name;
    private String number;

    public Customer(String name, String number) {
        this.name = name;
        this.number = number;
    }

    public String getName() {
        return name;
    }

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

    public String getNumber() {
        return number;
    }

    public void setNumber(String number) {
        this.number = number;
    }

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

2.TreeMap
特点：通过特殊的排序方式，键不可重复
代码

package com.hkd.collectionAndMap;

import java.util.TreeMap;

/**
 * TreeMap例子
 */
public class Test6 {
    public static void main(String[] args) {

        //创建一个TreeMap对象
        TreeMap<Integer,Teacher> treeMap=new TreeMap<>();

        //向treeMap对象中添加几条数据
        treeMap.put(1,new Teacher("小明",30));
        treeMap.put(3,new Teacher("xiaohong",30));
        treeMap.put(2,new Teacher("xiaozhao",21));


        //输出集合
        System.out.println(treeMap);
    }
}

package com.hkd.collectionAndMap;

/**
 * Teacher实体类
 */
public class Teacher{
    private String name;
    private Integer 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 Teacher(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

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

}