java集合-- 所有

最新推荐文章于 2024-08-25 17:20:52 发布
最新推荐文章于 2024-08-25 17:20:52 发布
阅读量129 收藏
点赞数
分类专栏： java集合 文章标签： java 集合 collection map
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43619461/article/details/121074679
版权

java 集合类

在这里插入图片描述

ArrayList集合的常规操作

  •              ArrayList长度可变,会随数组元素的增加分配更大的内存,

  •              因此可以把ArrayList看做是一个可变长的数组

  •              由于ArrayList的底层是数组,所以在 增加所删除指定位置元素时会创建新的数组

  •              所以效率会比较低,所以不适合做大量的增删操作

package cn.usts.edu.arrayList;

import java.lang.reflect.Array;
import java.util.ArrayList;

/**
 * @author ：fly
 * @description: ArrayList集合的常规操作
 *                  ArrayList长度可变,会随数组元素的增加分配更大的内存,
 *                  因此可以把ArrayList看做是一个可变长的数组
 *                  由于ArrayList的底层是数组,所以在 增加所删除指定位置元素时会创建新的数组
 *                  所以效率会比较低,所以不适合做大量的增删操作
 *
 * @date ：2021/11/1 9:40
 */
public class ArrayListDemo {
    public static void main(String[] args) {
        ArrayList al = new ArrayList();
        boolean student1 = al.add("student1");
        boolean student2 = al.add("student2");
        al.add("student3");

        System.out.println(student1);
        System.out.println(student2);

        System.out.println("集合的长度:"+al.size());
        System.out.println("第二个元素是:"+al.get(2));
        System.out.println("第最后一个元素是:"+al.get(al.size()-1));
    }
}

在这里插入图片描述

LinkedList 的基本操作

  • ArrayList的查询很快,但是在增删的时候效率就慢了,于是出现了LinkedList
  • 链表中每个元素都用引用方式记住前一个和后一个元素,这样在增删的时候效率就会大大提高
package cn.usts.edu.linkedList;

import java.util.LinkedList;

/**
 * @author ：fly
 * @description: LinkedList 的基本操作
 *                  ArrayList的查询很快,但是在增删的时候效率就慢了,于是出现了LinkedList
 *                  链表中每个元素都用引用方式记住前一个和后一个元素,这样在增删的时候效率就会大大提高
 *
 * @date ：2021/11/1 10:00
 */
public class LinkedListDemo {
    public static void main(String[] args) {
        LinkedList ll = new LinkedList();

        // 添加
        ll.add("stu1");
        ll.add("stu2");
        ll.add("stu3");
        ll.add("stu4");

        System.out.println(ll);

        ll.offer("stu99");// 集合尾部追加
        System.out.println(ll);

        ll.push("stu00");// 集合头部追加
        System.out.println(ll);

        // 获取
        Object peek = ll.peek();// 获取集合第一个元素
        System.out.println(peek);

        // 删除

        System.out.println("删除了"+ll.removeFirst());// 删除第一个元素
        System.out.println(ll);
        System.out.println("删除了"+ll.removeLast());// 删除最后一个元素
        System.out.println(ll);
        System.out.println("删除了"+ll.remove(2));// 删除index=2的元素
        System.out.println(ll);
    }
}

在这里插入图片描述

Iterator的使用方法

  • Iterator是java集合框架中的一员,
  • 主要用于迭代访问(即遍历)Collection中的元素,
  • 因此Iterator对象也被称为迭代器.
package cn.usts.edu.iterator;

import com.sun.deploy.security.BadCertificateDialog;

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

/**
 * @author ：fly
 * @description: Iterator的使用方法
 *                  Iterator是java集合框架中的一员,
 *                  主要用于迭代访问(即遍历)Collection中的元素,
 *                  因此Iterator对象也被称为迭代器.
 *
 * @date ：2021/11/1 10:16
 */
public class IteratorDemo {
    public static void main(String[] args) {
        ArrayList al = new ArrayList();

        al.add("stu1");
        al.add("stu2");
        al.add("stu3");
        al.add("stu4");
        al.add("stu5");

        Iterator iterator = al.iterator();// 获取迭代器对象

        // hasNext()判断集合中是否存在下一个对象
        while (iterator.hasNext()){
            System.out.println(iterator.next());// next()取出对象
        }

    }
}

在这里插入图片描述

ForEach(增强for循环)遍历集合

ForEach的出现就是为了解决Iterator写起来太繁琐的问题

package cn.usts.edu.iterator;

import java.util.ArrayList;

/**
 * @author ：fly
 * @description: ForEach(增强for循环)遍历集合
 *                  ForEach的出现就是为了解决Iterator写起来太繁琐的问题
 * @date ：2021/11/1 10:32
 */
public class ForEachDemo {

    public static void main(String[] args) {
        ArrayList al = new ArrayList();

        al.add("stu1");
        al.add("stu2");
        al.add("stu3");
        al.add("stu4");
        al.add("stu5");

        for (Object o : al) {
            System.out.println(o);// 打印元素
        }
    }
}

在这里插入图片描述

迭代器注意点

package cn.usts.edu.iterator;

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

/**
 * @author ：fly
 * @description: ForEach(增强for循环)遍历集合
 *                  ForEach的出现就是为了解决Iterator写起来太繁琐的问题
 * @date ：2021/11/1 10:32
 */
public class ForEachDemo {

    public static void main(String[] args) {
        ArrayList al = new ArrayList();

        al.add("stu1");
        al.add("stu2");
        al.add("stu3");
        al.add("stu4");
        al.add("stu5");

        for (Object o : al) {
            System.out.println(o);// 打印元素
            if (o.equals("stu2")){
                al.remove(o);

                break;// 如果不加上的话,迭代器会报错,就是把这个元素删除掉了,迭代器下一个元素找不到了,用break跳出循环
                /*
                Exception in thread "main" java.util.ConcurrentModificationException
                at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:911)
                at java.util.ArrayList$Itr.next(ArrayList.java:861)
                at cn.usts.edu.iterator.ForEachDemo.main(ForEachDemo.java:22)

                * */
                
                
            }
        }
        System.out.println(al);
        
        // 方法二
        Iterator iterator = al.iterator();
        while (iterator.hasNext()){
            if (iterator.next().equals("stu2")){
                iterator.remove();
            }
        }
        System.out.println(al);
    }
}

JDK8新加的forEach遍历集合

package cn.usts.edu.iterator;

import java.util.ArrayList;

/**
 * @author ：fly
 * @description: JDK8新加的forEach遍历集合
 * @date ：2021/11/1 10:58
 */
public class ForEachJdk8Demo {
    public static void main(String[] args) {
        ArrayList al = new ArrayList();

        al.add("stu1");
        al.add("stu2");
        al.add("stu3");
        al.add("stu4");
        al.add("stu5");

        al.forEach(obj-> System.out.println("迭代集合元素"+obj));
    }
}

在这里插入图片描述

Iterator实现的遍历结果

@Test
    public void iteratorMethod(){
        ArrayList al = new ArrayList();

        al.add("stu1");
        al.add("stu2");
        al.add("stu3");
        al.add("stu4");
        al.add("stu5");

        Iterator iterator = al.iterator();
        iterator.forEachRemaining(obj-> System.out.println("遍历出来的元素"+obj));
    }

在这里插入图片描述

HashSet

package cn.usts.edu.hashSet;

import java.util.HashSet;

/**
 * @author ：fly
 * @description: HashSet的常规操作
 * @date ：2021/11/1 17:17
 */
public class HashSetDemo {
    public static void main(String[] args) {
        HashSet hs = new HashSet();
        hs.add("hello1");
        hs.add("hello2");

        hs.add("hello3"); // 添加重复元素
        hs.add("hello3");
        hs.add("hello3");

        hs.add("hello4");

        hs.forEach(obj-> System.out.println(obj));// 遍历
    }
}

在这里插入图片描述

HashSet自定义obj类型,存储到haset中去重.

package cn.usts.edu.hashSet;

import org.junit.Test;

import java.util.HashSet;

/**
 * @author ：fly
 * @description: HashSet的常规操作
*                自己创建的对象要重写hashCode()和equals()方法 
 *
 * @date ：2021/11/1 17:17
 */
public class HashSetDemo {
    public static void main(String[] args) {
        HashSet hs = new HashSet();
        hs.add("hello1");
        hs.add("hello2");

        hs.add("hello3"); // 添加重复元素
        hs.add("hello3");
        hs.add("hello3");

        hs.add("hello4");

        hs.forEach(obj-> System.out.println(obj));// 遍历
    }



    // 重写hashCode方法,针对自定义存储对象
    @Test
    public void test02(){
        Student stu1 = new Student(1,"Jack");
        Student stu2 = new Student(1,"Jack");

        HashSet set = new HashSet();
        set.add(stu1);
        set.add(stu2);
        set.forEach(obj-> System.out.println(obj));
        //System.out.println(set);



    }
}

// pojo
class Student{
    private int id;
    private String name;

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

    public Student() {
    }

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

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

    @Override
    public int hashCode() {
        return name.hashCode();//返回name的hash值
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj){//比较地址值,是否是同一个对象
            return true;
        }
        if (!(obj instanceof Student)){// 不是学生的子类
            return false;
        }
        Student student = (Student) obj;// 是学生的子类,且不是本身
        boolean equals = this.name.equals(student.name);// 判断当前类的名字是否和传进来的name一致
        return equals;
    }
}

在这里插入图片描述

TreeSet的使用

package cn.usts.edu.hashSet;

import java.util.TreeSet;

/**
 * @author ：fly
 * @description: TreeSet常规操作
 *               TreeSet的出现解决了HashSet无法排序的问题,
 * @date ：2021/11/1 17:50
 */
public class TreeSetDemo {

    public static void main(String[] args) {
        TreeSet ts = new TreeSet();
        ts.add(1);
        ts.add(82);
        ts.add(33);
        ts.add(74);
        ts.add(5);
        ts.add(16);
        ts.add(26);
        ts.add(36);
        ts.add(22);
        System.out.println(ts);

        System.out.println("第一个是:"+ts.first());
        System.out.println("最后一个是:"+ts.last());

        System.out.println("集合中小于或等于26的最大的一个元素是:"+ts.floor(26));
        System.out.println("集合中大于30的最小的一个元素是:"+ts.floor(30));// 没有返回null

        System.out.println("删除第一个"+ts.pollFirst());// 删除第一个
        System.out.println("删除最后一个"+ts.pollLast());// 删除最后一个
        System.out.println(ts);

    }
}

在这里插入图片描述

HashMap的常用操作和遍历

遍历:

  • 遍历值
    - 增强for / 迭代器
  • 遍历value
    - 增强for / 迭代器
  • 遍历entrySet
    - 转换MapEntry对象
    - 增强for / 迭代器
package cn.usts.edu.map.hashMap;

import java.util.*;

/**
 * @author ：fly
 * @description: HashMap 的基本操作
 *               hashMap是  Key:Value的形式
 *               put()添加
 *               get()获取
 *               size()大小
 *               isEmpty()判空
 *               clear()清空
 *               remove()删除
 *               constainsKey()查找键是否存在
 *
 *               键不可以重复,key可以为空,value可以重复
 *               key相同会覆盖
 *               多数情况是String类型的key,value  Object类型都可以
 *
 *
 * @date ：2021/11/2 17:23
 */

//@SuppressWarnings("all")
public class HashMapDemo {
    public static void main(String[] args) {
        Map map = new HashMap();
        map.put("小红","95");
        map.put("小名","85");
        map.put("小名","85");// 重复不添加
        map.put("tom","75");
        map.put("lucy",79);
        map.put("小军",null);
        map.put("小网",null);
        map.put(null,null);
        map.put(null,"小华");//替换掉上面的null
        System.out.println(map);

        System.out.println("tom的value="+map.get("tom"));
        System.out.println("lucy的value="+map.get("lucy"));

        Set keySet = map.keySet();// 获取到所有键的集合
        System.out.println(keySet);

        System.out.println("小网是否存在:"+map.containsKey("小网"));
        System.out.println("小王是否存在:"+map.containsKey("小王"));

        System.out.println("是否包含(int)79:"+map.containsValue(79));
        System.out.println("是否包含79:"+map.containsValue("79"));

        Collection values = map.values();
        System.out.println("所有的值="+values);

        System.out.println("------------遍历1-------------");

        // 方法1通过for循环和get遍历
        for (Object key : keySet) {
            System.out.println(key + ":" + map.get(key));
        }

        System.out.println("------------遍历2-------------");
        // 方法2 迭代器
        Iterator iterator = keySet.iterator();
        while (iterator.hasNext()){
            String item =(String) iterator.next();// 遍历key
            System.out.println(item+":"+map.get(item));
        }

        // 方法3  获取所有values 遍历
        System.out.println("------------遍历3-------------");
        Collection value = map.values();
        for (Object val : value) {
            System.out.println(val);
        }

        // 方法4  通过获取值迭代器遍历
        System.out.println("------------遍历4-------------");
        Iterator iterValue = value.iterator();
        while (iterValue.hasNext()){
            System.out.println(iterValue.next());
        }
        // 方法5 entrySet获取k-v
        System.out.println("------------遍历5-------------");
        Set entrySet = map.entrySet();
        for (Object o : entrySet) {
            Map.Entry entry = (Map.Entry) o;
            System.out.println(entry.getKey()+ ":" + entry.getValue());
        }

        // 方法6   entrySet用迭代器 遍历
        System.out.println("------------遍历6-------------");
        Iterator entryIterator = entrySet.iterator();
        while (entryIterator.hasNext()){
            Object next = entryIterator.next();
            Map.Entry keyValue = (Map.Entry) next;
            System.out.println(keyValue.getKey()+":"+keyValue.getValue());
        }

    }
}

在这里插入图片描述

TreeSet排序

Comparator()

package cn.usts.edu.collection.set.treeSet;


import java.util.Comparator;
import java.util.TreeSet;

/**
 * @author ：fly
 * @description:  TreeSet 可以排序,但是要重写compare方法
 * @date ：2021/11/3 15:19
 */
public class TreeSetDemo {
    public static void main(String[] args) {
        TreeSet treeSet = new TreeSet(new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {

                System.out.println(((String) o1).compareTo((String) o2));
                // compareTo返回比较结果int,然后传入TreeMap中
                // TreeMap中的put方法会调用重写compare方法,比较大小,大的放右节点,小的放左节点.
                // return ((String) o1).compareTo((String) o2);// 字符串的compareTo方法比较
                return ((String) o2).length() - ((String) o1).length();// 长度比较
            }
        });
        treeSet.add("a");
        treeSet.add("swallow");
        treeSet.add("tree");
        treeSet.add("hello");
        treeSet.add("hello1");
        System.out.println(treeSet);// 直接 输出并不会排序,需要重写compare()
    }
}

在这里插入图片描述

大毛z
关注
专栏目录
java集合知识大全
03-02
java 集合 List arrayList vector map set
java集合-EnumMap的使用
06-14
EnumMap是Java中的一种特殊映射实现，它要求键必须来自枚举类型，并且对于每个可能的键值，都有预定义的条目。
Java基础之集合
weixin_30294709的博客
12-30 420
最近看泛型的时候，刚好看到集合相关的，所以想把一些常用集合类型的思路理清一下。 参考文章： http://android.blog.51cto.com/268543/400557/ http://www.cnblogs.com/xwdreamer/archive/2012/05/30/2526822.html http://blog.csdn.net/softwave/...
集合、Collection
最新发布
qq_64004825的博客
08-25 846
1.集合的长度是可变的2.集合中的存储的数据可以是不同类型的 ，如果加上泛型的话就是会有限制3.集合中只能存储引用数据类型4.集合框架是在java.util包下的。
java集合大全
L1834230951的博客
08-06 659
集合多种类
Java各个集合（Collection）的特性和用途
程柯梦想
03-13 2075
这篇文章总结了所有的Java集合（Collection）。主要介绍各个集合的特性和用途，以及在不同的集合类型之间转换的方式。 Arrays Array是Java特有的数组。在你知道所要处理数据元素个数的情况下非常好用。java.util.Arrays 包含了许多处理数据的实用方法： Arrays.asList：可以从 Array 转换成 List。可以作为其他集合类型构造器的参数
Java集合大全
weixin_45032957的博客
09-14 118
集合的迭代器 目前Java里有三个迭代器：Iterator Iterable ListIterator。 首先看Iterator接口： public interface Iterator { boolean hasNext(); E next(); void remove(); } 提供的API接口含义如下： hasNext()：判断集合中是否还有下一个对象。 next()：返回集合中的下一个对象，并将访问指针移动一位。 remove()：删除集合中调用next()方法返回的对象。 在JDK早期版本里，
java集合-PriorityQueue的使用
06-14
PriorityQueue是Java中的一个优先级队列，它可以根据元素的优先级对元素进行排序，并且允许高效地获取和删除最高优先级的元素。
java集合-Properties的使用
06-14
Properties是Java中用于管理配置文件的类，它继承自Hashtable类，可以存储键值对，并提供了读写配置文件的功能。
java集合-Hashtable的使用
06-14
Hashtable是Java中的一种散列表实现，它可以存储键值对，并根据键的哈希值来快速查找和访问值。
java集合-LinkedHashMap的使用
06-14
LinkedHashMap是Java中的一种特殊类型的HashMap，它保留了插入顺序，即按照元素插入的先后顺序进行排序
java集合使用大全
07-28
详细介绍java中各个集合的使用方法，对java开发者非常有用
Java 集合（超全）
eggzxy的博客
02-02 547
集合框架分析 Java集合包含存储单值的Collection实现类（单列集合，有时直接说“集合”）和存储键值对的Map实现类（双列集合，映射）。 Collection类实现了Collection或其子接口，Map类同理。 AbstractCollection是抽象类，提供了Collection接口的一些实现，以最大限度地减少实现此接口所需的工作量。集合框架内其他抽象类作用类似。 Interface Collection Collection接口继承了Iterable接口，还规定了以下方法： 方法
JAVA-集合大全
风雨桥的博客
04-09 177
前言 本篇主要介绍Java常用集合，以及各自特点和使用场景，不结合源码讲解，下期将根据源码分析一些经典集合的实现。 Collection集合接口以及常用实现类 Iterable接口：(java.lang.iterable) 是java集合的顶级接口之一，Collection 接口继承Iterable，Collection的所有子类都实现了Iterable接口 Collection接口：所有单列集合的最顶层的接口，定义了所有单列集合的共享方法。Collection派生了三个子接口：List、Set
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值