Java集合代码

最新推荐文章于 2022-08-15 14:21:44 发布
最新推荐文章于 2022-08-15 14:21:44 发布
阅读量332 收藏
点赞数
分类专栏： java 文章标签： java 集合 arraylist
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_47949604/article/details/115428707
版权

Java集合

1.Collections

1.1Collections接口的add方法

code：

import java.util.*;

public class AddSelftDemo {
    public static void main(String[] args) {
        //Collections中的addAll()方法演示
        //声明并实例化List类对象
        List<String> list = new ArrayList<String>();

        //添加元素
        list.add("1");
        list.add("2");
        list.add("3");
        list.add("4");
        list.add("5");
        list.add("6");

        //添加自身
        list.addAll(list);

        //输出
        System.out.println(list);
        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()) {
            System.out.print(iterator.next() + " ");
        }

        System.out.println("\n" + "换行");

        Set<String> set = new HashSet<String>();
        //添加元素
        set.add("1");
        set.add("2");
        set.add("3");
        set.add("4");
        set.add("5");
        set.add("6");

        //添加自身（然而set不能添加自身）
        set.addAll(set);

        //输出
        System.out.println(set);
        Iterator<String> iterator1 = set.iterator();
        while (iterator1.hasNext()) {
            System.out.print(iterator1.next() + " ");
        }

    }
}

输出结果：

截图1

1.2Collections接口的toArray方法

code：

import java.util.ArrayList;
import java.util.List;

public class ToArrayDemo {
    public static void main(String[] args){
        List<String> list = new ArrayList<String>();
        list.add("1");
        list.add("2");
        list.add("3");
        list.add("4");
        list.add("5");
        list.add("6");

        //无参toArray()
        Object[] str = list.toArray();
        //遍历数组
        printArr(str);
        System.out.println();

        //有参toArray()
        //参数中的数组长度较短
        String[] str01 = new String[list.size() - 1];
        String[] str02 = list.toArray(str01);
        //遍历str01 str02
        System.out.println("参数中的数组长度较短");
        printArr(str01);
        printArr(str02);
        System.out.println();

        //参数中的数组长度刚好
        System.out.println("参数中的数组长度刚好");
        str01 = new String[list.size()];
        str02 = list.toArray(str01);
        printArr(str01);
        printArr(str02);
        System.out.println();

        //有一个初始值，长度刚好,添加的"demo"忽略了
        System.out.println("有一个初始值，长度刚好");
        str01[0] = "demo";
        str02 = list.toArray(str01);
        printArr(str01);
        printArr(str02);
        System.out.println();

        //长度较长
        System.out.println("长度较长");
        str01 = new String[list.size() + 2];
        str02  = list.toArray(str01);
        printArr(str01);
        printArr(str02);
        System.out.println();

        //长度较长，有一个初始值
        System.out.println("长度较长,有一个初始值");
        str01 = new String[list.size() + 2];
        str01[list.size() + 1] = "demo";
        str02  = list.toArray(str01);
        printArr(str01);
        printArr(str02);
        System.out.println();
    }
    
    static  void printArr(Object[] str){
        //遍历数组
        System.out.println("-----数组元素如下：-----");
        for(int i = 0 ; i < str.length ; i++){
            System.out.print(str[i] + " ");
        }
        System.out.println();
    }
}

输出结果：

截图2

2.Map接口

code：

import com.sun.scenario.effect.impl.sw.sse.SSEBlend_SRC_OUTPeer;
import sun.invoke.empty.Empty;

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

public class MapMethodDemo {
    public static void main(String[] args) {
        //声明实例化100000个学生对象
        Student[] stu = new Student[100000];
        for (int i = 0; i < stu.length; i++) {
            stu[i] = new Student("2019010101" + (i + 1), "张" + (i + 1), 18, "港航2班");
        }

        //加入到Map中
        Map<String, Student> map = new HashMap<String, Student>();
        for (int i = 0; i < stu.length; i++) {
            map.put(stu[i].no, stu[i]);
        }

        //遍历
        //映射关系
        Set<Map.Entry<String, Student>> set = map.entrySet();

        //iterator()
        System.out.println("-----iterator()遍历-----");
        long start = System.currentTimeMillis();
        Iterator<Map.Entry<String, Student>> iterator = set.iterator();
        while (iterator.hasNext()) {
            Map.Entry<String, Student> entry = iterator.next();
            Student stu01 = entry.getValue();
            //System.out.println(entry.getKey() + " ");
            stu01.print();
        }
        long end = System.currentTimeMillis();

        //toArray()
        System.out.println("------toArray()遍历-----");
        long start01 = System.currentTimeMillis();
        Object[] obj = set.toArray();
        for (int i = 0; i < obj.length; i++) {
            Map.Entry<String, Student> entry = (Map.Entry<String, Student>) obj[i];
            Student stu01 = entry.getValue();
            stu01.print();
        }
        long end01 = System.currentTimeMillis();

        //查找前100名学生是否存在
        //key
        long start02 = System.currentTimeMillis();
        for (int i = 0; i < 1000; i++) {
            boolean isExist = map.containsKey(stu[i].no);
            System.out.println(stu[i].no + ((isExist) ? "存在" : "不存在 "));
        }
        long end02 = System.currentTimeMillis();
        //value
        long start03 = System.currentTimeMillis();
        for (int i = 0; i < 1000; i++) {
            boolean isExist = map.containsKey(stu[i]);
            System.out.println(stu[i].no + ((isExist) ? "存在" : "不存在 "));
        }
        long end03 = System.currentTimeMillis();

        //输出耗时
        System.out.println("iterator()遍历耗时：" + (end - start));
        System.out.println("toArray()遍历耗时：" + (end01 - start01));
        System.out.println("key查找耗时" + (end02 - start02));
        System.out.println("value查找耗时" + (end03 - start03));
    }
}

输出结果：

遍历结果
截图3
查找结果
截图4
耗时结果
截图5

3.List接口

code：

import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;

public class ListMethodDemo {
    public static void main(String[] args) {
        //List实例化
        List<String> list = new ArrayList<String>();

        //添加
        //向其中添加一个元素"1"
        list.add("1");
        traverse(list);
        //在第一个位置添加一个元素“2”
        list.add(0, "2");
        traverse(list);
        //在第二个元素添加一个元素“8”
        list.add(1, "8");
        traverse(list);
        //在第一个位置添加list
        list.addAll(0, list);
        traverse(list);


        //查找
        //indexOf()   lastdexOf()
        //查找元素2所在的位置
        System.out.println("最先出现2的位置：" + list.indexOf("2"));
        System.out.println("最后出现2的位置：" + list.lastIndexOf("2"));
        //查找元素3所在的位置
        System.out.println("最先出现3的位置：" + list.indexOf("3"));

        //listIterator()遍历
        System.out.println("listIterator()遍历：");
        ListIterator<String> listIterator = list.listIterator();
        while (listIterator.hasNext()) {
            System.out.print(listIterator.next() + " ");
        }
        System.out.println("listIterator()遍历(部分遍历)：");
        ListIterator<String> listIterator1 = list.listIterator(2);
        while (listIterator1.hasNext()) {
            System.out.print(listIterator1.next() + " ");
        }

        //删除
        System.out.println();
        String str = list.remove(1);
        System.out.println("删除的元素：" + str);
        System.out.println("删除后的list集合：");
        traverse(list);

        //截取子集合
        List<String> list01 = list.subList(2, 4); //这个区间是[ ),且右边大于或等于左边的
        System.out.println("截取的子集合：");
        traverse(list01);

        //替换
        list.set(2, "9");
        System.out.println("替换后的list集合：");
        traverse(list);

    }

    static void traverse(List<String> list) {
        //遍历
        System.out.println("-----集合元素如下：-----");
        for (int i = 0; i < list.size(); i++) {
            //集合用get方法获取，不是通过下标
            System.out.print(list.get(i) + " ");
        }
        System.out.println();
    }
}

输出结果：

添加结果：
截图6
查找结果：
截图7
迭代器遍历结果：
截图8
删除结果：
截图9
截取子集合结果：
截图10
替换结果：
截图11

4.ArrayList类

4.1clone()方法

import java.util.ArrayList;
import java.util.List;

public class CloneMethodDemo {
    public static void main(String[] args) {
        //clone  浅克隆
        ArrayList<StringBuffer> list = new ArrayList<StringBuffer>();
        StringBuffer sb = new StringBuffer("Learning,");
        list.add(sb);
        traverse(list);
        @SuppressWarnings("unchecked")
        ArrayList<StringBuffer> list01 = (ArrayList<StringBuffer>) list.clone();
        traverse(list01);

        //修改list中第一个元素的值
        sb = list.get(0);
        sb.append("ArrayList clone() method");
        //遍历
        traverse(list);
        traverse(list01);

        //add()方法  list中添加"second value"
        list.add(new StringBuffer("second value"));
        //遍历
        traverse(list);
        traverse(list01);
    }

    //集合遍历
    static void traverse(ArrayList<StringBuffer> list) {
        System.out.println("-----集合元素-----");
        for (int i = 0; i < list.size(); i++) {
            System.out.print(list.get(i) + " ");
        }
        System.out.println();
    }
}

输出结果：

截图12

4.2ensureCapacity()方法

code：

import java.util.ArrayList;

public class EnsureCapacityDemo {
    public static void main(String[] args) {
        //向集合添加100万个元素
        ArrayList<String> list = new ArrayList<String>();
        long start = System.currentTimeMillis();
        for (int i = 0; i < 1000000; i++) {
            list.add(i + " ");
        }
        long end = System.currentTimeMillis();
        System.out.println("耗时：" + (end - start));


        ArrayList<String> list01 = new ArrayList<String>();
        long start01 = System.currentTimeMillis();
        for (int i = 0; i < 1000000; i++) {
            list01.add(i + " ");
        }
        list01.ensureCapacity(1000000);
        long end01 = System.currentTimeMillis();
        System.out.println("耗时：" + (end01 - start01));
    }
}

输出结果：

截图13

4.3TrimToSize()方法

code：

import java.util.ArrayList;

public class TrimToSizeMethod {
    public static void main(String[] args) {
        //trimToSize()方法使用
        ArrayList<Integer> list = new ArrayList<Integer>();
        //list中添加3个元素
        list.add(1);
        list.add(2);
        list.add(3);
        list.trimToSize();
        for (int i = 0; i < list.size(); i++) {
            System.out.print(list.get(i) + " ");
        }
        System.out.println();
    }
}

输出结果：

截图14

5.LinkedList类

code：

import java.util.LinkedList;

public class LinkedListDemo {
    public static void main(String[] args) {
        LinkedList<String> list = new LinkedList<String>();
        //添加元素
        list.add("1");
        list.add("2");
        list.add("3");
        //遍历
        traverse(list);

        //头部  尾部
        list.addFirst("0");
        list.addLast("4");
        traverse(list);

        //输出头部元素   只是取出来，并不删除
        String first = list.element();
        System.out.println("头部元素：" + first);
        traverse(list);

        //取出头部元素和尾部元素   只是取出来，并不删除
        first = list.getFirst();
        String last = list.getLast();
        System.out.println("头部元素：" + first + "  尾部元素：" + last);
        traverse(list);

        //向尾部添加元素offer()
        list.offer("5");
        traverse(list);

        //头部  尾部元素添加  offerFirst()  offerLast()
        list.offerFirst("-1");
        list.offerLast("6");
        traverse(list);

        //pollFirst()  pollLast()  取出第一个/最后一个元素，并删除
        first = list.pollFirst();
        last = list.pollLast();
        System.out.println("头部元素：" + first + "  尾部元素：" + last);
        traverse(list);

        //pop()  栈顶  （弹出）取出并删除
        first = list.pop();
        System.out.println("栈顶元素：" + first);
        traverse(list);

        //push()   压栈  向栈顶添加一个元素
        list.push("10");
        traverse(list);

        //删除
        first = list.removeFirst();
        last = list.removeLast();
        System.out.println("删除第一个元素：" + first + "  删除的最后一个元素：" + last);
        traverse(list);

        //添加两个重复元素  2  4
        list.add(0, " 2");
        list.add(2, "4");
        traverse(list);

        //删除第一次出现的2 删除最后一次出现的4
        list.removeFirstOccurrence("2");
        list.removeLastOccurrence("4");
        traverse(list);
    }

    static void traverse(LinkedList<String> list) {
        System.out.println("-----集合元素如下：-----");
        for (int i = 0; i < list.size(); i++) {
            System.out.print(list.get(i) + " ");
        }
        System.out.println();
    }
}

输出结果：

截图15

6.Set接口

code：

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

public class SetDemo {
    public static void main(String[] args) {
        //无序 不重复
        Set<String> set = new HashSet<String>();
        String s1 = "Hello";
        String s2 = s1;    //输出结果显示，不可重复
        String s3 = "World!";
        String s4 = "你好！";
        set.add(s1);
        set.add(s2);
        set.add(s3);
        set.add(s4);
        //遍历，不能用for循环，没有get()方法
        Iterator<String> iterator = set.iterator();
        while (iterator.hasNext()) {
            System.out.print(iterator.next() + " ");
        }
    }
}

输出结果：

截图16

无条件做异梦
关注
专栏目录
java集合代码
03-05
java集合，hashmap,hashtable
Java集合 练习代码
10-21
本练习代码主要围绕Java集合框架展开，包括ArrayList、LinkedList、HashSet、HashMap等各种类型的集合以及它们的使用方法。通过这些代码示例，我们可以深入理解Java集合的各种特性和操作。 首先，我们来探讨...
Java 集合代码
weixin_45471945的博客
08-20 459
package com.neusoft.test1; import java.text.ParseException; import java.text.RuleBasedCollator; import java.util.ArrayList; import java.util.Arrays; import java.util.Collection; import java.util.HashS...
java集合类代码_java集合类
weixin_36087357的博客
02-12 163
Java集合类一、Java集合类大致可以分为Set、List、Queue和Map四种体系。1、 Set代表无序、不可重复的集合2、 List代表有序、重复的集合3、 Map代表具有映射关系的集合4、 Queue是一种队列集合的实现Java集合和数组的区别？1、 数组的长度在初始化时指定，意味着只能保存定长的数据。而集合可以保存的数量不确定的数据。同时可以保存具有映射关系的数据。2、 数...
java-集合用法代码
BODOA
04-11 671
package MyTest01; import java.util.*; public class ArrayTest02 { public static void main(String[] args) { //声明数组 String [] arr; int arr1[]; //初始...
JavaSE：集合
m0_49825096的博客
10-04 282
JavaSE：集合概述集合框架Collection的使用Collection中的常见方法迭代器接口 IteratorCollection的子接口之一：List底层源码分析ArrayListLinkedListVectorList接口中的常用方法Collection子接口之二：SetLinkedHashSet的使用TreeSet的使用 概述         为了方便对多个对象的操作，就要对对象进行存储。另一方面，使用数组存储对象方
Java集合详解代码.zip
02-16
本资料“Java集合详解代码.zip”涵盖了Java集合框架的主要组成部分，包括List、Set、Map以及Collections工具类，通过代码实现来帮助理解和掌握这些概念。 1. **List接口**：List是有序的集合，允许重复元素，支持...
JAVA基础集合代码
07-31
本文将深入探讨标题中的“JAVA基础集合代码”，主要关注List、Set、Stack、Map以及Queue这五种核心接口。 首先，我们来看List。List是一种有序的集合，允许元素有重复，并且可以保持元素的插入顺序。ArrayList和...
Java集合案例及源代码.rar
01-24
这个压缩包“Java集合案例及源代码.rar”显然是一个教学资源，包含了丰富的实例和详细的注释，旨在帮助教师进行教学准备，同时也非常适合学生用来复习和深化对Java集合的理解。 1. **Java集合接口**： - **List**...
JAVA集合详解（附完整代码）
weixin_44183721的博客
08-15 2946
Java集合，Iterable接口，Iterator接口，List接口，Set接口，Queue接口，Map接口
Java集合类源码分析汇总
weixin_34161029的博客
01-05 139
Java集合类基础：http://www.cnblogs.com/hzmark/archive/2012/12/17/CollectionBase.html ArrayList源码分析：http://www.cnblogs.com/hzmark/archive/2012/12/20/ArrayList.html ArrayList的removeRange方法分析：http://www.cnbl...
java 集合代码,java_集合类_简(示例代码)
weixin_42308943的博客
03-14 168
Collection来源于Java.util包,实用常用的数据结构,字面意思就是容器主要方法boolean add(Object o)添加对象到集合boolean remove(Object o)删除指定的对象int size()返回当前集合中元素的数量boolean contains(Object o)查找集合中是否有指定的对象boolean is...
java集合代码_java集合代码示例
weixin_36444484的博客
02-12 350
一、ListArrayList使用List时，最好初始化容量。ArrayList的默认容量为10，每次扩容增0.5倍，假如要放置100个元素，需要多次扩容。List list=new ArrayList<>(100);String数组转List，使用Arrays.asList。String[] stryArray=new String[]{"str1","str2","str3"};L...
java集合
weixin_43972621的博客
10-11 143
Java集合框架 Java将优秀的算法和数据结构都封装到了集合框架之中。 数据结构考点 数组和链表的区别 链表的操作，如反转、链表环路检测、双向链表、循环链表相关操作 队列、栈的应用 二叉树的遍历方式及其递归和非递归的实现 红黑树的旋转 算法考点 内部排序，如递归排序、交换排序（冒泡、快排）、选择排序、插入排序 外部排序，应掌握如何利用有限的内存配合海量的外部存储来处理超大的数据集 考点扩展 哪些排序是不稳定的（堆排序、快排等），稳定意味着什么 不同数据集，各种排序最好或最差的情况 如何优化算法（
Java集合源码
ShuJk的博客
05-12 436
1、HashSet 和 HashMap 总体介绍: 之所以把HashSet和HashMap放在一起讲解，是因为二者在Java里有着相同的实现，前者仅仅是对后者做了一层包装，也就是说HashSet里面有一个HashMap（适配器模式）。因此本文将重点分析HashMap。 HashMap实现了Map接口，允许放入null元素，除该类未实现同步外，其余跟Hashtable大致相同，跟TreeMap不...
java 集合代码_【05】Java入门05：Java集合
weixin_42144199的博客
02-15 185
一、对象数组1.对象数组概述①基本类型的数组：存储的元素为基本类型。int[] arr={1,2,3,4}②对象数组：存储的元素为引用类型。Student[] stus = new Student[3];二、集合类之ArrayList1.集合概述我们学习的是面向对象编程语言，而面向对象编程语言对事物的描述都是通过对象来体现的。为了方便对多个对象进行操作，我们就必须对这多个对象进行存储，而要想对多个...
Java集合框架详解
"Java集合是Java编程中非常重要的部分，涵盖了数据存储和管理的主要机制。这份教程涵盖了Java集合框架的基本概念、接口和类，包括List、Set和...理解并熟练掌握Java集合框架对于编写高效、可维护的Java代码至关重要。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值