集合(List,Set)知识小结(一)

最新推荐文章于 2023-06-16 01:48:14 发布
最新推荐文章于 2023-06-16 01:48:14 发布
阅读量375 收藏
点赞数
分类专栏： java 文章标签： arraylist
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xwx617/article/details/54810240
版权

集合框架的体系结构
集合框架体系结构
注意其中只有最下面的一行是类，上面的都是接口。
一、List(列表)
List
1、ArrayList
这里写图片描述

ArrayList学习代码一:
package com.imooc.set;

import java.util.ArrayList;

public class ListDemo1 
{

    public static void main(String[] args) 
    {
        //用ArrayList存储编程语言的名称，并输出
        //名称包括Java,C,C++,Go和Swift
        ArrayList list=new ArrayList();//List list=new ArrayList();也可以

        //利用add(Object o)方法为列表添加元素,注意add方法是在末尾添加新元素
        list.add("Java");
        list.add("C");
        list.add("C++");
        list.add("Go");
        list.add("Swift");
        //利用size()方法输出列表中元素的个数
        System.out.println("列表中元素的个数为:"+list.size());

        //利用ArrayList类下的get(int index)方法获取元素,遍历输出所有的编程语言
        System.out.println("********************************");
        for(int i=0;i<list.size();i++)
        {
            System.out.print(list.get(i)+" ");
        }

        //利用ArrayList类下的remove(int index)方法移除列表中的C++
        System.out.println();
        list.remove(2);
        //另一种移除的方法是remove(Object o)，即list.remove("C++");
        System.out.print("移除C++以后的列表元素为:");
        for(int i=0;i<list.size();i++)
        {
            System.out.print(list.get(i)+" ");
        }
    }

}

ArrayList的存放方式
这里写图片描述

ArrayList学习代码二中的Notice(公告)类
package com.imooc.set;

import java.util.Date;

public class Notice  //公告类
{
    private int id;//ID
    private String title;//标题
    private String creator;//创建人
    private Date createTime;//创建时间
    public Notice()
    {

    }
    public Notice(int id,String title,String creator,Date createTime)
    {
        this.setCreateTime(createTime);
        this.setCreator(creator);
        this.setId(id);
        this.setTitle(title);
    }
    public int getId() 
    {
        return id;
    }
    public void setId(int id) 
    {
        this.id = id;
    }
    public String getTitle() 
    {
        return title;
    }
    public void setTitle(String title) 
    {
        this.title = title;
    }
    public String getCreator() 
    {
        return creator;
    }
    public void setCreator(String creator) 
    {
        this.creator = creator;
    }
    public Date getCreateTime() 
    {
        return createTime;
    }
    public void setCreateTime(Date createTime) 
    {
        this.createTime = createTime;
    }


}
ArrayList学习代码二中的Test(测试)类
package com.imooc.set;

import java.util.ArrayList;
import java.util.Date;

public class NoticeTest 
{

    public static void main(String[] args) 
    {
        //创建Notice类的对象，生成三条公告
        Notice notice1=new Notice(1, "欢迎来到慕课网", "管理员", new Date());
        Notice notice2=new Notice(2, "请同学们按时提交作业", "老师", new Date());
        Notice notice3=new Notice(3, "考勤通知", "老师", new Date());

        //将公告类对象存放在ArrayList中
        ArrayList noticeList=new ArrayList();
        noticeList.add(notice1);
        noticeList.add(notice2);
        noticeList.add(notice3);

        /*显示公告。由于ArrayList类下的get(int index)方法返回的是Object类的对象，而Object没有getTitle方法，因此在此
        需要强制转换为Notice类的对象才能调用Notice类的get/set方法,并且需要加很多括号,不仅需要将Notice和noticeList.get分别括起来，还需要将他们
        一起括起来*/
        System.out.println("公告内容:");
        for(int i=0;i<noticeList.size();i++)
        {
            System.out.println((i+1)+":"+((Notice)(noticeList.get(i))).getTitle());
        }

        //利用add的重载方法add(int index,Object o)在第一条公告后面添加一条新公告
        Notice notice4=new Notice(4,"在线编辑器可以使用了","管理员",new Date());
        noticeList.add(1,notice4);
        System.out.println("**************************");
        System.out.println("添加后的公告内容:");
        for(int i=0;i<noticeList.size();i++)
        {
            System.out.println((i+1)+":"+((Notice)(noticeList.get(i))).getTitle());
        }

        //利用方法remove(int index)或remove(Object o)删除按时完成作业的公告
        noticeList.remove(notice2);//noticeList.remove(2);
        System.out.println("**************************");
        System.out.println("删除后的公告内容:");
        for(int i=0;i<noticeList.size();i++)
        {
            System.out.println((i+1)+":"+((Notice)(noticeList.get(i))).getTitle());
        }

        //将第二条公告修改为：Java在线编辑器可以使用了
        //修改公告对象中的title的值再输出即可
        notice4.setTitle("Java在线编辑器可以使用了");
        System.out.println("**************************");
        System.out.println("修改后的公告内容:");
        for(int i=0;i<noticeList.size();i++)
        {
            System.out.println((i+1)+":"+((Notice)(noticeList.get(i))).getTitle());
        }
    }

}

二、set(集)
这里写图片描述
1、HashSet(哈希集)
这里写图片描述

Iterator(迭代器)接口及接口中的常用方法
这里写图片描述

HashSet学习代码一
package com.imooc.set;

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

public class HashSetDemo1 
{

    public static void main(String[] args) 
    {
        //将英文单词添加到HashSet中
        HashSet set=new HashSet();//Set set=new HashSet();
        //利用add(Object o)方法向集合中添加元素
        set.add("blue");
        set.add("red");
        set.add("black");
        set.add("yellow");
        set.add("white");
        /*利用迭代器Iterator接口显示集合的内容,因为HashSet是无序的,因此一切ArrayList中有index参数的方法HashSet都没有
        因此get(int index)方法也不存在与HashSet中*/
        System.out.println("集合中的元素为:");
        //通过set调用iterator方法，把结果存放到Iterator的引用it中,即将元素放在了迭代器中
        Iterator it=set.iterator();
        //遍历迭代器并输出元素,hasNext()方法判断是否存在下一个元素,next()方法输出下一个元素
        while(it.hasNext())//hasNext()方法返回的是boolean值
        {
            System.out.print(it.next()+" ");//默认调用toString方法
        }

        //在集合中插入一个新的单词,由于HashSet是无序的，因此插入的位置不确定.
        //set.add("green");

        //由于HashSet不允许存在相同元素，因此执行以下语句后输出集合内容，集合内容不会发生任何变化
        //set.add("blue");
    }

}
HashSet学习代码二之Cat类
package com.imooc.set;

public class Cat 
{
    private String name;//名字
    private int month;//年龄
    private String species;//品种

    public Cat()
    {

    }

    public Cat(String name,int month,String species)
    {
        this.setName(name);
        this.setMonth(month);
        this.setSpecies(species);
    }
    public String getName() 
    {
        return name;
    }

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

    public int getMonth() 
    {
        return month;
    }

    public void setMonth(int month) 
    {
        this.month = month;
    }

    public String getSpecies() 
    {
        return species;
    }

    public void setSpecies(String species) 
    {
        this.species = species;
    }

    @Override
    public String toString() 
    {
        return "[姓名:" + name + ", 年龄:" + month + ", 品种:" + species + "]";
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + month;
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        result = prime * result + ((species == null) ? 0 : species.hashCode());
        return result;
    }

    @Override
    public boolean equals(Object obj) 
    {
        if(this==obj)//先判断对象是否相等，对象相等就不用再比较内容了
            return true;
        if(obj instanceof Cat)//判断obj是否具有Cat类的特征
        {
            Cat cat=(Cat)obj;//如果是obj是Cat类的对象，先将obj强制转换为Cat类
            //判断两个对象的内容是否相等
            return cat.getName().equals(name)&(cat.getMonth()==month)&(cat.getSpecies()==species);
        }
        return false;
    }



}
HashSet学习代码二之CatTest(测试)类
package com.imooc.set;

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

public class CatTest 
{

    public static void main(String[] args) 
    {
        //定义宠物猫对象
        Cat huahua=new Cat("花花",12,"英国短毛猫");
        Cat fanfan=new Cat("凡凡",3,"中华田园猫");
        /*将宠物猫对象放入HashSet。注释中的Set、HashSet、Iterator后面的<Cat>表示集合中只允许存放Cat类型的对象.
         * 若不加<Cat>则无限制,这种方式称为泛型
        加了<Cat>之后，那么之后的it.next()返回的不再是Object类型的对象，而直接是Cat对象，不用再强制转换成Cat类型*/
        Set set=new HashSet();//泛型集合:Set<Cat> set=new HashSet<Cat>();
        set.add(huahua);
        set.add(fanfan);
        //显示宠物猫信息,next()方法返回的是Object类对象，因此也要强制转换成Cat类才能调用Cat下的方法
        Iterator it=set.iterator();//泛型集合的迭代:Iterator<Cat> it=set.iterator();
        while(it.hasNext())
        {
            System.out.println(it.next());//直接输出默认调用toString方法
        }

        //再添加一个与花花属性一样的猫,验证HashSet的不可重复性
        /*若依以下注释代码写，发现HashSet的不可重复性验证失败，输出结果出现了两个花花,原因是这两个花花指向的栈中的地址不相
        同，因此不被编译器认为是相同的对象，而之前的字符串由于定义方式决定了是存放在常量池中的，因此两个相同的字符串
        指向了常量池中的同一片内存，被编译器认为是一个对象。*/
        /*Cat huahua01=new Cat("花花",12,"英国短毛猫");
        set.add(huahua01);
        System.out.println("***********************");
        System.out.println("添加重复数据后的宠物猫信息:");
        it=set.iterator();
        while(it.hasNext())
        {
            System.out.println(it.next());//直接输出默认调用toString方法
        }*/

        //因此如果想让HashSet中不出现内容重复的对象，需要重写HashCode和equals判断方法,重写见Cat类，一般只重写equals方法，因为HashSet判断是否有重复对象的方法利用的就是equals方法
        //重写equals方法，让重写后的equals方法不再只判断对象是否指向同一片堆中的内存，而是还判断对象内容，重写后再执行以下代码，就不会出现两个名为花花的对象了
        Cat huahua01=new Cat("花花",12,"英国短毛猫");
        set.add(huahua01);
        System.out.println("***********************");
        System.out.println("添加重复数据后的宠物猫信息:");
        it=set.iterator();//由于上一个迭代器it已经迭代到末尾了，因此需要重新迭代
        while(it.hasNext())
        {
            System.out.println(it.next());//直接输出默认调用toString方法
        }

        //重新插入一个新宠物猫,因为HashSet是无序的，因此插入位置未知
        System.out.println("**************************");
        Cat huahua02=new Cat("花花二代",2,"英国短毛猫");
        set.add(huahua02);
        System.out.println("添加花花二代后的宠物猫信息:");
        it=set.iterator();
        while(it.hasNext())
        {
            System.out.println(it.next());//直接输出默认调用toString方法
        }

        //在集合中查找花花的信息并输出
        //第一种方法:根据对象查找,利用的方法是contains(Object o)
        System.out.println("**************************");
        System.out.println("通过对象查找花花:");
        if(set.contains(huahua))
        {
            System.out.println("花花找到了!");
            System.out.println(huahua);
        }
        else
            System.out.println("花花没找到");
        //第二种方法:利用迭代器遍历集合，根据对象属性name查找
        System.out.println("**************************");
        System.out.println("通过对象name属性查找花花:");
        boolean flag=false;
        it=set.iterator();//由于上一个迭代器it已经迭代到末尾了，因此需要重新迭代
        Cat c=null;//一定要先赋值null，不能单独写Cat c放在这里，否则程序会报错.
        while(it.hasNext())
        {
            if((((Cat)(it.next())).getName()).equals("花花"))
            {
                c=(Cat)(it.next());
                flag=true;//找到了
                break;
            }
        }
        if(flag==true)
        {
            System.out.println("花花找到了");
            System.out.println(c);
        }
        else 
            System.out.println("花花没找到!");

        //利用方法remove(Object o)删除花花二代的信息并重新输出(在用了泛型的情况下可以配合增强型for循环)
        //由于前面没有用泛型,因此将在使用了泛型集合的前提下配合增强型for循环的代码写在注释中
        /*for(Cat cat:set)
        {
            if("花花二代".equals(cat.getName()))
                set.remove(cat);
        }
        System.out.println("删除花花二代后的数据");
        for(Cat cat:set)
        {
            System.out.println(cat);
        }
        */

        //利用方法removeAll(Collection arg0)删除集合中所有宠物猫信息
        /*
         * boolean flag1=set.removeAll(set);
         * if(flag1)
         *      System.out.println("删除成功");
         * else
         *      System.out.println("删除失败");
         */
    }

}
WindFromFarEast
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
集合小结 Collection
02-28
java中各种集合详解！ 集合（集合类的对象）是用来管理其他若干对象的。它类似于C++标准模板库中的容器，不过在JAVA的集合类的对象中可以用来存放多种类型的对象。 接口和类共同构成了一个集合框架，集合的概念，一个对象可以装载多个对象，这个对象就是集合对象
python基础知识小结之集合
12-24
集合 特点：集合对象是一组无序排列的可哈希的值：集合成员可以做字典的键，与列表和元组不同，集合无法通过数字进行索引。此外，集合中的元素不能重复。  定义 set() -> new empty set object set(iterable) -> new set object s = {0} 应用：去重 >>> lst1 = [1,1,2,2,3,4,2] >>> list(set(lst1)) [1, 2, 3, 4] 常用操作 集合支持一系列标准操作，包括并集|、交集&、差集-和对称差集^ 子集< <=及超集> >= 增删，清空操作 具体见如下代码例子 >>>
Python中常见的数据类型小结
01-21
Python提供多种数据类型来存放数据项集合，主要包括序列（列表list和元组tuple），映射（如字典dict），集合（set），下面对这几种一一介绍： 一 序列 1.列表list 列表是一种有序的集合，相对于元组和字符串的不同是它其中的元素可变，可以随时添加和删除其中的元素。 （1）创建list 在命令行中测试，如下： >>> L1 = [1,2,3] >>> L1 [1, 2, 3] >>> L2 = ['abc'] >>> L2 ['abc'] >>> L3 = [a,b,c] >>> L3 ['a', 'b', 'c'] 注意，字符串的一定要加引号。 通过list对字符
Python实现去除列表中重复元素的方法小结【4种方法】
12-25
本文实例讲述了Python实现去除列表中重复元素的方法。分享给大家供大家参考，具体如下： 这里一共使用了四种方法来去除列表中的重复元素，下面是具体实现： #!usr/bin/env python #encoding:utf-8 ''' __Author__:沂水寒城 功能：去除列表中的重复元素 ''' def func1(one_list): ''''' 使用集合，个人最常用 ''' return list(set(one_list)) def func2(one_list): ''''' 使用字典的方式 ''' return {}.fromkeys(one_
java集合小结
02-02
java集合中list、set、map等集合的介绍，集合在java中应用很重要
python学习之list(set())函数
除了学习谁都不爱的博客
04-10 2万+
list(set())函数：对原列表去重并按从小到大排序 例如： a = ['f','s',3,3,4,2,'d',4,5,6,1] a = list(set(a)) print(a) [1, 2, 3, 4, 5, 6, 'd', 'f', 's'] 原理：set(a)将列表a转换为集合，集合是一个包含不重复元素的无序序列，然后再使用list将集合转换为列表 若要实现不改变原来顺序，则应再增加...
题:统计数字出现次数。 随机生成100个数字，数字范围从1到10,统计每个数字出现的次数并打印到控制台。...
weixin_34037977的博客
08-17 6915
public static void main(String[] args) { printCount(getNumList());}private static ArrayList<Integer> list;public static ArrayList<Integer> getNumList() { list = new ArrayList<In...
集 合 总 结
huochefei的博客
10-21 319
1、什么是集合？有什么用？ 数组其实就是一个集合。集合实际上就是一个容器。可以来容纳其它类型的数据。 集合为什么说在开发中使用较多? 集合是一个容器，是一个载体，可以一次容纳多个对象。在实际开发中，假设连接数据库，数据库当中有10条记录,那么假设把这10条记录查询出来，在java程序中会将10条数据封装成10个java对象，然后将10个java对象放到某一个集合当中，将集合传到前端，然后遍历集合，将一个数据一个数据展出来。 //不能放基本类型,可以存放object类型(即只能存放对象的引用)
集合的总结
weixin_53502170的博客
07-15 291
集合分类和使用
集合总结
unknownpeople的博客
01-19 262
L特点ist的三个子类的: ArrayList 底层结构是数组，底层查询快，增删慢； LinkedList 底层结构是链表型的，增删慢，查询快； vector 底层数组，线程安全的，增删慢，查询吗。 List和Map，Set的区别 一， 结构特点 list和set是存储单列数据的集合，Map是存储键和值这样的双列数据集合；list中存储的数据是由顺序，并且运行重复；Map中存储的数据是没有顺序的，...
JSTL学习
bingmeng_1102的专栏
11-30 790
<br />JSTL标签库的使用是为类弥补html表的不足，规范自定义标签的使用而诞生的。在告别modle1模式开发应用程序后，人们开始注重软件的分层设计，不希望在jsp页面中出现java逻辑代码，同时也由于自定义标签的开发难度较大和不利于技术标准化产生了自定义标签库。JSTL标签库可分为5类：<br />q        核心标签库<br />q        I18N格式化标签库<br />q        SQL标签库<br />q        XML标签库<br />q        函数标签库<
java面试题全覆盖
最新发布
weixin_45780470的博客
06-16 449
SELECT 列名 FROM 表1 JOIN 表2 ON 条件 WHERE 条件 GROUP BY 列名 HAVING 条件 ORDER BY 列名 LIMIT过滤器：在请求发送之后，处理之前对请求的一次拦截，可以更改请求状态或者参数值等。创建过滤器：实现filter接口，重写doFilter方法，最后在web.xml中配置过滤器Spring是一个开源的轻量级控制反转和面向切面编程的容器框架。轻量级是说它开发使用简单，功能强大。
集合类 Set
海阔天空的专栏
08-06 240
1 Set集合 (1)元素不重复 (2)没有带索引的方法，所以不能使用普通for循环遍历 2 HashSet (1)元素不重复 (2)没有带索引的方法，所以不能使用普通for循环遍历 (3)底层结构是哈希表 (4)不保障存储和取出的元素顺序一致 (5)在使用HashSet时，内容相同的不同对象，HashSet认为是不重复的。如果我们要实现相同内容不重复，需要在相应的类中使用Alt+Insert自动生成的方式重写equals()和hashCode()方法 3 LinkedHashSet集合 哈希表和链表实
集合知识点总结1
cedille的博客
11-20 4792
集合就是一个已经封装好的对象 集合三大接口 Collection 所有集合类的跟接口 Map 映射接口，存放键值对 Iterator 遍历集合的迭代接口 Java的集合框架是由很多接口、抽象类、具体类组成的，都位于java.util包中。除Comparable位于Java.lang包 Collection（单列集合的跟接口）(泛型）1.2JDK版本
list、set、map的区别
bingshanyijiao_fkx的专栏
12-23 595
List动态集合的接口，好处是可以动态添加元素。很方便的通过Itractor迭代器来遍历集合元素；Map是键值对形式的集合，好处是可以通过相应键找到相应的值，就好比一把钥匙开一把相应的锁；set也是一种集合，其相邻的两个元素之间的有关系机制，好处是方便的横向的搜索相邻集合元素； List 迭代访问的时候会按照你添加(add)的顺序依次显示！ 允许添加重复元素Set
Python3.x中set()集合的使用方法
jerrygaoling的博客
07-16 7877
Python中set()集合的使用方法 python中的set()是一个无序的不重复的元素集。 sets 支持 x in set, len(set),和 for x in set。 1.初始化方法： x = set() x.add('str') ...... 2.基本使用方法： x = set('class') y = set(['c','a','m']) print(x, y...
java集合系列——List集合总结（六）
阿飞云漫步
03-02 2万+
List继承了Collection，是有序的列表。 实现类有ArrayList、LinkedList、Vector、Stack等 ArrayList是基于数组实现的，是一个数组队列。可以动态的增加容量！ LinkedList是基于链表实现的，是一个双向循环列表。可以被当做堆栈使用！ Vector是基于数组实现的，是一个矢量队列，是线程安全的！ Stack是基于数组实现的，是栈
Python集合（set）类型的操作
热门推荐
农村的我的专栏
05-07 58万+
python的set和其他语言类似, 是一个无序不重复元素集, 基本功能包括关系测试和消除重复元素. 集合对象还支持union(联合), intersection(交), difference(差)和sysmmetric difference(对称差集)等数学运算. sets 支持 x in set, len(set),和 for x in set。作为一个无序的集合，sets不记录元素位置
简述集合list set map区别
03-16
list、set和map都是Java中常用的集合类型，它们的主要区别如下： 1. list是有序的集合，可以重复，可以通过索引访问元素； 2. set是无序的集合，不可以重复，不能通过索引访问元素； 3. map是一种键值对的集合，每个元素都包含一个键和一个值，键不能重复，值可以重复，可以通过键访问值。 总的来说，list适合存储有序的、可重复的元素；set适合存储无序的、不可重复的元素；map适合存储键值对，可以通过键快速查找对应的值。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值