黑马程序员_JAVA笔记14——集合框架（List、HashSet、TreeSet）

最新推荐文章于 2026-03-10 00:34:55 发布
原创 最新推荐文章于 2026-03-10 00:34:55 发布 · 771 阅读 · 1 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
收录于
JAVA基础笔记

当前文章被收录于：

JAVA基础笔记
25 篇文章 1 人学习
订阅专栏 查看详情
本文详细介绍了Java集合框架的基本概念，包括数组与集合的区别、各种集合类的特点及应用场景，如ArrayList、LinkedList、HashSet、TreeSet等，并提供了丰富的示例代码。
-------  android培训、 java培训、期待与您交流！ ----------
1、为什么出现集合类，面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，就对对象进行存储，集合就是存储对象最长哟昂的一种方式。
        数组与集合类都是容器，有何不同？数组虽然也可以存储对象，但长度是固定的，集合长度是可变的。数组中可以存储基本数据类型，集合只能存储对象。数组只能存储同一种数据类型。
        集合类的特点：集合只用于存储对象，集合长度是可变的，集合可以存储不同类型的对象
2、容器
        collection接口：
                List：
                        ArrayList:底层数据结构使用的是数组结构。特点：查询速度快但增删很慢。
                                        线程不同步。数组默认长度10，当元素数超过10，就new一个新
                                        的数组，长度增长50%。将元素copy过来然后加上新元素
                        LinkedList:底层使用的是链表数据结构。特点：查询慢增删快
                        Vector:底层是数组数据结构（Vector是1.0，集合框架是1.2出现的），功能
                                        与ArrayList相同。但是线程同步。低效。数组默认长度10，当元
                                        素数超过10，就new一个新的数组，长度增长100%。将元素
                                        copy过来然后加上新元素

                Set：元素是无序的（存入和取出的顺序不一定一致），元素不可以重复。
                        Set集合功能与Collection功能一致
                        HashSet:底层数据结构是哈希表
                        TreeSet:
为什么出现这么多容器：因为每一个容器对数据的存储方式不同，这个存储方式称为：数据结构
3、示例：
/*
    add方法的参数类型时Object，以便于接收任意类型对象。
    集合中存储的都是对象的引用或地址。

Iterator的设计原理：
    把集合中取出方式定义在集合的内部，这样取出方式就可以直接访问集合内容的元素。
    那么取出方式就被定义成了内部类。
    而每一个容器的数据结构不同。
    所以取出的动作细节也不一样，但是都有共性内容：判断和取出，那么可以将其共性抽取。
    那么这些内部类都复合一个规则，该规则是Iterator接口。
    如何获取集合的取出对象，通过一个对外提供的方法iterator();

*/
import java.util.*;
class CollectionDemo
{
        public static void main(String[] args)
        {
                //创建一个集合容器，使用Collection解扣子的子类，ArrayList
                ArrayList al = new ArrayList();
                al.add("java1");        
                al.add("java2");   
                al.add("java3"); 
                al.add("java4");   

                ArrayList al2 = new ArrayList();
                al2.add("java2");        
                al2.add("java3");   
                al2.add("java6"); 
                al2.add("java7");   
                
                //
                Iterator it = al.iterator();//获取迭代器，用于去除集合中的元素。
                sop（it.next());//取出集合中下一个元素
                while(it.hasNext())//判断下面是否还有元素，返回boolean
                {
                        it.next();
                }
                for(Iterator it = al.iterator();it.hasNext();)
                {
                        sop(it.next());
                }
                //取交集
                al.retainAll(al2)//al中只会保留和al2中相同的元素，al与al2的交集
                
                //去交集
                al.removeAll(al2);//al中保留al2中所没有的元素，即去掉al中二者的交集，但是al2不变
                //获取个数
                sop("size:"+al.size());
                
                //打印集合中的对象
                sop(al);//会依次打印出集合中所有的对象
                
                //删除元素
                al.remove("java3");//删除集合中的java3元素
                al.clear();//删除集合中所有元素，清空集合。
                
                //判断元素
                sop(al.contains("java2");//al中是否包含java2，返回boolean
                sop(al.isEmpty());//al是否为空，返回boolean
        }
        public static void sop(Object obj)
        {
                System.out.println(obj):
        }
}

4、List集合共性方法：
/*
Collection
        List:元素师有序的，元素可以重复，因为该集合体系有索引。
        Set：元素是无序的，元素不可以重复。
List：
        特有方法：凡是可以操作角标的方法都是该体系特有方法
增：
        add(index,element);
        addAll(index,Collection);
删:
        remove(index);
改:
        set(index,element)
查:
        get(index);
        subList(from,to)
        listIterator();

List集合特点有的迭代器，ListIterator是Iterator的子接口。
在迭代时，不可以通过集合对象的方法操作集合中的元素，因为会发生并发修改异常：ConcurrentModificationException,所以，在迭代器时，只能用迭代器的方法操作元素，可是Iterator方法是优先的，只能对元素进行判断，取出，删除的操作。
如果想要其他的操作如添加、修改等，就需要使用其子接口，ListITerator。
该接口只能通过List集合的listIterator()方法获取。
*/

imort java.util.*;
class ListDemo
{
        public static void main(String[] args)
        {
                ArrayList al = new ArrayList();
                //添加元素
                al.add("java01");
                al.add("java02");
                al.add("java03");
                //指定位置添加元素
                al.add(1,"java09");
                //删除指定位置元素
                al.remove(2);
                //修改指定位置元素
                al.set(2,"java998");
                //获取角标处元素
                sop(al.get(1));
                //获取所有元素
                for(Iterator it = al.iterator();it.hasNext();)
                {
                        sop(it.next());
                }

                //通过indexOf获取对象的位置
                sop(al.indexOf("java02");
                List sub = al.subList(1,3);//取子列表，包含1不包含3

                //演示列表迭代器
                //在迭代过程中，准备添加或者删除元素。用Iterator；
                Iterator it = al.iterator();
                while(it.hasNext())
                {
                        Object obj = it.next();
                        if(obj.equals("java02")
                                it.add("jfava333");//出现并发异常
                                it.remove();//删除集合中对象的引用
                        sop(obj)
                }

                //用ListITerator,因为List有索引，所以能进行增删改查
                ListIterator li = al.ListIterator();
                while(li.haiNext())//判断集合中下一个元素是否存在：正向遍历
                {
                        Object obj = li.next();
                        if (obj.equals("java01"))
                                li.set("java003");
                                li.add("java3333");
                }
                while(li.haiPrevious())//判断集合中前一个元素是否存在，逆向遍历
                {
                        Object obj = li.previous();
                        if (obj.equals("java01")
                                li.set("java003");
                                li.add("java3333");
                }
                
        }
        public static void sop(Object obj)
        {
                 System.out.println(obj);
        }
        
}

Vector示例：
/*
枚举就是Vector特有的取出方式
发现枚举和迭代很像
其实枚举和迭代是一样的
因为枚举的名称以及方法的名称都过长
所以被迭代器取代了
枚举就用的少了
*/
class VectorDemo
{
        public static void main(String[] args)
        {
                Vector v = new Vector();
                v.add("java01");
                v.add("java02");
                v.add("java03");
                v.add("java04");
                
                Enumeration en = v.elements();
                while(en.hasMoreElements())
                {
                        System.out.println(en.nextElement());
                }
        }
}

5、linkedList
/*
特有方法：
addFirst();
addLast();
getFirst();
getLast();只取不删
removeFirst();取并删
removeLast();
注意当linkedList 为空时，进行上述操作，抛出异常NoSuchElementsException

1.6版本后：出现替代方法
offerFirst();//添加元素
offerLast();
peekFirst();//获取元素，但不删除，如果集合没有元素，返回null，不抛异常
peekLast();
pollFirst();//获取元素，并在链表中删除，如果集合中没有元素，返回null，而不是抛异常
pollLast();
*/
import java.util.*;
class LinkedListDemo
{
        public static void main(String[] args)
        {
                LinkedList link = new LinkedList();
                link.addFirst("java01");
                link.addFirst("java02"); 
                link.addFirst("java03"); 
                sop(link);//结果java03  java02   java01

                LinkedList link1 = new LinkedList();
                link.addLast("java01");
                link.addLast("java02"); 
                link.addLast("java03"); 
                sop(link1);//结果java01 java02  java03
                sop(link1.getFirst());//java01
                sop(link1getLast());//java03
                sop(link1.removeFirst());//先获取第一个，然后删除
                sop(link1.size());

                //删除所有元素
                while(!link1.isEmpty())
                {
                        sop(link.removeFirst());
                }
        }
        public static void sop(Object obj)
        {
                System.out.println(obj);
        }
}

堆栈：先进后出，如同一个杯子
队列：先进先出，First in First out      FIFO如同一个水管

import java.util.*;
class DuiLie
{
        private LinkedList link;
        DuiLie()
        {
                link = new LinkedList;
        }
        public void myAdd(Object obj)
        {
                link.addFirst(obj);
                //ling.addLast(obj);
        }
        public Object myGet()
        {    
                return link.removeLast();
                //return link.removeFirst();
        }
        public boolean isNull()
        {
            return link.isEmpty();
        }
}
class LinkedListTest
{
        public static void main(String[] args)
        {
                DuiLie dl = new DuiLie();
                dl.myAdd("java01");
                dl.myAdd("java02");
                dl.myAdd("java03");

                while(dl.isNull())
                {
                        System.out.println(dl.myGet());
                }
        }
}


去除ArrayList中的重复元素
class ArrayListDemo
{
        public static void main(String[] args)
        {
                ArrayList al = new ArrayList();
                al.add("java01");
                al.add("java02");
                al.add("java03");
                al.add("java04");
                al.add("java05");
                al.add("java06");
                System.out.println(singleElement(al));

                //在迭代时，循环中的next()调用一次，就要hasNext判断一次。不要hasNext一次而next多次，否则易出NoSuchElementException
                Iterater it = al.Iterator();
                while(it.hasNext())
                {
                        sop(it.next()+"       "+it.next());
                        //输出：java01....java02      java03......java04       java05......java06
                        //但是当没有al.add("java06")时，最后一次循环的it.next()取不到值，
                        //出异常
                }
        }
        public static ArrayList singleElement(ArrayList al)
        {
                /*
                原理：创建新容器，判断该容器中是否含有al中的元素，若没有则添加。（这样，不重复的元素会添加进去，而重复的元素只会添加进一次，等再次添加时新容器中已有该元素，判断为false，因此不添加，这样新容器中就是去除了重复元素的集合，将该新容器返回即可）

                */
                ArrayList all = new ArrayList();
                Iterator it = al.iterator();
                while(it.haiNext())
                {
                        Object obj = it.next();
                        if(!all.contains(obj))
                                all.add(obj);
                }
        }
}

List集合判断元素是否相同，依靠的是equals方法。contains      remove

6、频繁增删：linkedList
     涉及增删,但不频繁：linkedList   或ArrayList
    涉及增删，涉及查询：ArrayList

7、     Set：元素是无序的（存入和取出的顺序不一定一致），元素不可以重复。
                        Set集合功能与Collection功能一致
                        HashSet:底层数据结构是哈希表

HashSet是如何保证元素的唯一性？是通过元素的两个方法，hashCode()和equals()来完成。如果元素的HashCode值相同，才会判断equals是否为true，如果元素的哈希值不同，不会调用equals。另外：若两个元素的值不同，地址值相同，过程是这样的：先比较地址值，发现相同，然后比较equals，发现值不同，则，在哈希表中，该地址值下回存入两个不同的对象，即一个地址两个对象，在打印时，可打印出这两个对象。

HashSet数据结构式哈希表，线程是非同步的。保证元素唯一性的原理，判断元素的hashCode是否相同，如果相同，还会继续判断元素的equals方法，是否为true

注意：对于判断元素是否存在以及删除等操作，都依赖于元素的hashcode和equals方法
class Demo
{
        /*
        public int hashCode()
        {
                return 60;//返回值3c, 十六进制形式
        }
        */
}
class HashSetDemo
{
        public static void sop(Object obj)
        {
                System.out.println(obj);
        }
        public static void main(String[] args)
        {
                Demo d = new Demo();
                Demo d1 = new Demo();
                sop(d);//因为重写了hashCode(),所以打印的d和d1的地址值是一样的
                sop(d1);//这是因为，d.toString()时，调用hashCode(),返回d的哈希值
                            //但是我们重写后，返回的是3c，因此d  和d1打印地址值相同

                HashSet  hs = new HashSet();
                hs.add("java01");
                hs.add("java02");
                hs.add("java03");
                hs.add("java04");
                hs.add("java03");
                hs.add("java04");

                sop(hs.add("java"));//add方法返回值为boolean的，此时打印true，能存
                sop(hs.add("java"));//应为hs中已经存在java，不能继续存入，打印false
                Iterator it = hs.iterator();
                while(it.hasNext())//打印后只1234,因为HashSet中元素不重复
                        sop(it.next())
        }
}

8、TreeSet:
                可以对Set集合中的元素进行排序
                底层数据结构式二叉树
                调用的是compareTo()方法。
                保证元素 唯一性的依据： 调用的是compareTo()方法，返回值为0

    排序的第一种方式：让元素自身具备比较性，元素实现compareable接口，覆盖compareTo()方法。这种方式也称为元素的自然顺序，或默认顺序。

        
class TreeSetDemo
{
        public static void main(String[] args)
        {
                TreeSet ts = new TreeSet();    
                ts.add("fd");
                ts.add("cdf");
                ts.add("Dd");
                ts.add("b");
                Iterator it = ts.iterator();
                while(it.hasNext())
                {
                        System.out.println(it.next());
                        //结果：     Dd     b         cdf       fd 
                        //按首字母值排序，升序
                }


        }
}

/*
向TreeSet中存储自定义对象：重写compareTo方法，按我们自定义的方式返回值，先比较主要元素，若主要元素相同就比较次要元素。
*/
class TreeSetDemo
{
        public static void main(String[] args)
        {
                TreeSet ts = new TreeSet();    
                ts.add(new Student("zhangsan",19);
                ts.add(new Student("lisi",30);
                ts.add(new Student("wangwu",19);
                ts.add(new Student("zhangsan",13);

                Iterator it = ts.iterator();
                while(it.hasNext())
                {
                        System.out.println(it.next());
                     
                }
        }
}
class Student implements Comparable
{
        private String name;
        private int age;
        Student(String name,int age)
        {
                this.name = name;
                this.age = age;
        }
        public int compareTo(Object obj)
        {
                /*此时按升序排列
                if(!(obj instanceof Student))
                        throw new RunTimeException("不是学生");
                Student s = (Student)obj;
                if(this.age>s.age)
                        return 1;
                if(this.age==s.age)
                         return (this.name).compareTo(s.name);//String类本身就实现了Compareable接口，有compareTo方法
                return -1;*/

                //如果这样，那么元素是按存入的顺序排列的，存入元素时，会自动调用compareTo,返回1表示大于，返回0表示等于（此时不存入），返回-1表示小于。在这里全返回1表示后存入的对象比前一个对象大。
                return  1；
        }
        public String getName()
        {
                return name;
        }
        public int getAge()
        {
                retrun age;
        }
}


排序的第二种方式：当元素自身不具备比较性，或具备的比较性不是所需要的。这时需要让集合自身具备比较性。在集合一初始化时，就有了比较方式。定义了比较器，将比较器对象作为参数传递给TreeSet集合的构造函数

当两种排序都存在时，以比较器为主

定义一个类，实现Comparator接口，覆盖compare方法。
class Student implements Comparable
{
        private String name;
        private int age;
        Student(String name,int age)
        {
                this.name = name;
                this.age = age;
        }
        public int compareTo(Object obj)
        {
               此时按升序排列
                if(!(obj instanceof Student))
                        throw new RunTimeException("不是学生");
                Student s = (Student)obj;
                if(this.age>s.age)
                        return 1;
                if(this.age==s.age)
                         return (this.name).compareTo(s.name);//String类本身就实现了Compareable接口，有compareTo方法
                return -1;

              
        }
        public String getName()
        {
                return name;
        }
        public int getAge()
        {
                retrun age;
        }
}
class TreeSetDemo
{
        public static void main(String[] args)
        {
                TreeSet ts = new TreeSet (new MyCompare());     //表示使用指定比较器
                ts.add(new Student("zhangsan",19);
                ts.add(new Student("lisi",30);
                ts.add(new Student("wangwu",19);
                ts.add(new Student("zhangsan",13);

                Iterator it = ts.iterator();
                while(it.hasNext())
                {
                        System.out.println(it.next());
                        //结果：     Dd     b         cdf       fd 
                        //按首字母值排序，升序
                }
        }
}
class MyCompare implements Comparator//自定义比较器
{
        public int compare(Object c1,Object c2)
        {
                Student s1 = (Student)o1;
                Student s2 = (Student)o2;
                int  num = s1.getName().compareTo(s2.getName());
                if(num==0)//当name相同时，比较age
                {
                        return new Integer(s1.getAge()).compareTo(new Integer(s2.getAge());
                }
                return num;
        }
}

比较器调用过程： 就是让集合具备比较的功能，使用集合构造函数方法
创建TreeSet集合对象，此时：
         TreeSet ts = new TreeSet(new MyCompare()); 表示使用自定义比较器
       
创建类实现接口Comparator，覆盖接口的compare方法
        class MyCompare implements Comparator//自定义比较器
        {
        public int compare(Object c1,Object c2)
        {
自定义比较的方式，最后的返回值
return 正数或负数或0；一般就是1  -1  0
}
}
向TreeSet对象中添加元素，此时元素就自动的，按自定义的比较器在集合内排序存放

compareTo调用过程理解： 让集合元素具备比较性
创建TreeSet集合对象，此时：
           TreeSet ts = new TreeSet(); 表示使用compareTo()方法
创建类实现Comparable接口，覆盖compare方法。并且此类生成的对象，是准备向集合中添加的元素。 在覆盖后的compare方法中对该类的成员如name  age等进行比较，返回值1 -1 或0
向集合中添加元素，集合就会自动调用compare方法，按覆盖后的compare方法进行排序存放
标签
#集合框架 #java #面向对象
AI初识—LLM、Ollama、Llama都是些个啥？
小蜗牛的珍贵百宝箱
10-10 4555
LLM指的是大语言模型（Large Language Model），是一种基于深度学习的模型，能够理解和生成自然语言。它通过大量文本数据进行训练，具备了理解上下文、生成连贯文本和回答问题的能力。著名的LLM包括OpenAI的GPT系列和Google的BERT。在AI技术快速发展的背景下，LLM、Ollama和Llama代表了现代自然语言处理的不同方面。LLM为我们提供了强大的语言理解能力，Ollama为模型的部署和管理提供了便利，而Llama则在效率和多样性上不断推进。
RNA-Seq数据分析实战：从FastQC到STAR比对的完整流程（附避坑指南）
最新发布
weixin_29290259的博客
03-10 62
本文提供了RNA-Seq数据分析从FastQC质控到STAR比对的完整实战流程与避坑指南。详细解读了FastQC/MultiQC报告的关键指标，并重点阐述了STAR比对工具的核心参数设置、索引构建及性能优化策略，旨在帮助用户获得准确可靠的比对结果，为下游基因表达分析奠定坚实基础。
Java029—Java常用集合类概述ArrayList、LinkedList、HashSet、TreeSet、HashMap、TreeMap
weixin_45084986的博客
01-13 1159
一、集合类概述 二、Collection接口 package com.dgut.test; import java.text.SimpleDateFormat; import java.util.ArrayList; import java.util.Collection; import java.util.Date; import java.util.Iterator; public class Test001 { public static void main(String[] args
vue3：实现ECharts3D地图详细示例，echarts实现3D地图map3D，vue3如何利用echarts绘制3d地图立体城市省市地区分布，可视化数据大屏3D炫酷中国地图（复制源码，开箱即用）
✅ 精选推荐文章
06-28 3625
echarts实现中国地图记录篇之3D地图，Echarts地图之——如何让地图显示出3d感，【3d地图】vue中使用echarts geo3D，echarts实现某个市3D地图展示，vue3中使用echarts实现中国地图，3D地图图表，echarts实现3D地图——map3D，数据大屏3d地图，vue3+echarts绘制中国地图,3D地图,省、市、县，【3d地图】vue3中使用echarts geo3D，echarts实现某个市3D地图展示，ECharts3D地图(详细示例——附有具体注释)，echar
【Java学习|黑马笔记|Day16】集合进阶|Collection、ArrayList、LinkedList、泛型、数据结构、红黑树、HashSet、LinkedHashList、TreeSet
2401_87144364的博客
07-17 1067
方法二：比较器排序 创建集合时，自定义Comparator比较器对象，指定比较规则。希望这篇笔记能对大家的学习有所帮助，有啥不对的地方欢迎大佬们在评论区指正，一起交流。extend E?得益于JDK8的新技术，提供了一种更简单直接的遍历集合方法。如果想要集合中的元素可重复而且当前的增删操作明显多余查询。也可以在方法申明上定义自己的泛型 只能本方法能用。：变量的数据类型不确定时就可以定义带有泛型的类。迭代器遍历时，不能用集合的方法进行增加或删除。无序（存取顺序不一致），不重复，无索引。
黑马程序员-Java语言基础– 集合框架 第14天
Qiangoo
06-13 1459
---------------------- android培训、java培训、期待与您交流！ ---------------------- 集合框架 集合类（java.util.Collection） 为什么出现集合类？       面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，就对对象进行存储，集合就是存储对象最常用的一种方式。   数组和
黑马程序员——java复习总结——集合框架
key_fans的博客
08-13 557
------ android培训、java培训、期待与您交流！ ---------- 一、集合类   面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象操作，就对对象进行存储，集合就是存储对象最常用的一个方式。   数组虽然也可以存储对象，但是长度是固定的，集合长度是可变的。数组中可以存储基本数据类型，集合只能存储对象。而且集合可以存储不同类型的对象，数组只
day0708—Java学习 黑马程序员JAVA p125-p138 笔记自用
qq_51790440的博客
02-22 883
List、Set、Map三种集合类及常见的实现类、区别及特点 如何遍历、常用方法、底层实现 哈希表，红黑树 不重复的集合如何去重，升序排列的集合如何自定义排序
黑马程序员——第八篇-可变参数、set集合、HashSet、TreeSet
u013589850的博客
12-11 854
一、可变参数          1:从java5开始出现了可变参数，这是对java方法及数组的拓展！ 方法中可以接受的参数不再是固定个数的，而是随着具体需求传递的多少来决定。          2:定义格式：返回值类型  方法名(参数类型 ... 形式参数){         } 可变参数的特点： A、只能出现在参数列表的最后； B、位于变量类型和变量名之间，前后有无空格都可以;
黑马程序员—java基础之集合
IT梦想之旅
06-05 816
黑马程序员—java基础之集合                                                         ------- android培训、java培训、期待与您交流！ ----------   感恩，感恩，感恩！懂得感恩的人，才会是有福报的人！感谢所有发生的一切！   什么是集合:集合是一个容器. 还记得数组也是一个容器,那么他们之间有什么不
黑马程序员-java集合框架
LinsCode的专栏
05-17 615
 ---------------------- ASP.Net+Unity">http://www.itheima.com"target="blank">ASP.Net+Unity开发、.Net">http://www.itheima.com"target="blank">.Net培训、期待与您交流！ ----------------------  java中的集合框架实际上就
黑马程序员_JAVA学习日记_JAVA中API：集合框架1（Collection，List，Set及其子类和迭代器的应用）
Java程序员命运之改变
08-13 1160
黑马程序员-学习日记   黑马程序员_JAVA中集合框架1（Collection，List，Set及其子类和迭代器的应用）   ------- android培训、java培训、期待与您交流！ ----------   一：集合是用于存储对象的一个工具。 集合和数组的特点： 1.相同点：        集合和数组都一个容器。 2.集合：     1，可以存储对象，只能存储对象
黑马程序员——集合
qq_19680535的专栏
09-03 479
------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------
黑马程序员-集合框架
jyhonggang13848的专栏
10-29 433
——-android培训java培训期待与您交流!———-介绍 出现的原因：面向对象语言对事物的体现都是以对象的形式存在，为了方便对多个对象的操作，就对对象进行存储，集合就是存储对象最常用的一种方式。集合就是将若干用途、性质相同或相近的”数组”组合而成一个整体。 数组和集合的不同：数组可以存储对象，但长度是固定的；集合长度是可变的。数组中可以存储基本数据类型，集合只能存储对象。 集合的特点：集合只用
【黑马程序员】 java笔记——集合
他山之石 可以攻玉
11-15 1059
---------------------- ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ ---------------------- 集合 一.体系概述 集合类： 为什么出现集合类？          面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，就对对象进行存储，集合就是存储对象最常用的一种方式。
黑马程序员_集合框架
QingLiZhan的专栏
07-08 832
集合框架 数组和集合 数组虽然也可以存储对象，但长度是固定的；集合长度可变的。 数组中可以存储基本数据类型，集合只能存储对象。可以存储不同类型的对象。 集合框架图 java.util包 Collection ├List │├LinkedList │├ArrayList │└Vector │　 └Set    ├HashSet    └TreeSet M
黑马程序员java学习笔记之三（java集合框架类）
BBF15的专栏
03-05 658
---------------------- android培训、java培训、期待与您交流！ ----------------------          Java平台提供了一个全新的集合框架。“集合框架”主要由一组用来操作对象的接口组成。不同接口描述一组不同数据类型。   · 集合接口：6个接口（短虚线表示），表示不同集合类型，是集合框架的基础。 · 抽象类：5个抽
黑马程序员——Java集合框架
Daker_998的专栏
11-14 434
------- android培训、java培训、期待与您交流！ ---------- Java
【黑马程序员】Java集合类
whight的专栏
08-14 602
1. Java集合类也成Java容器类，是Java中实用的工具，实现了一些常用的数据结构和方法，方便开发者调用。与容器类中只能存放对象（实际上是对象的引用）。   2.Set集合     Set集合类似于一个罐子，放进去的元素是无序的。Set集合类似于Collection但Set集合不能存放相同的元素。    Set判断两个元素是否相同不是通过 == 而是 equals() 方法。  
黑马程序员——【学习笔记】集合——集合框架及Collectiony方法
oChuXinZhe的博客
10-11 561
集合框架就是集合容器因为内部的数据结构不同，而不断向上抽取的系统化产物。 1 集合框架的结构 1.1 Collection接口 Collection接口是框架的顶层接口。因为Collection接口的子类并非全部都有角标（只有List子接口有，Set子接口没有），所以只有增删查三大方法，没有改（如果要改只能删除再添加，但是不能保证序列一致，或者使用有角标的List接口），但有
黑马程序员--集合框架
sinat_29779023的博客
07-28 493
——Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ——- 注：视频来源，毕向东老师的 JAVA 基础视频。集合框架 概论： 集合框架是为表示和操作集合而规定的一种统一的标准的体系结构。任何集合框架都包含三大块内容：对外的接口、接口的实现和对集合运算的算法。接口：即表示集合的抽象数据类型。接口提供了让我们对集合中所表示的内容进行单独操作的可能。实现：也就是集合框架中
黑马程序员___13java基础 集合框架 LIST和SET集合
一木一草一枯荣
01-28 449
---------------------- ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ ---------------------- 集合框架：由很多容器构成，每个容器对数据的存储方式都有不同，这种存储方式称之为数据结构。 备注：1add方法的参数类型是object，以便于接收任意类型的对象。 2集合中存储的都是对象的引用地址。 每一个容器的
黑马程序员--集合框架的总结
liuning516的专栏
03-24 465
---------------------- android培训、java培训、期待与您交流！ ----------------------       今天复习了下集合框架部分的知识，根据平时打的一些笔记，总结了集合框架的知识。        Collection定义了集合框架的共性功能。集合中存贮的都是对象的引用（地址），而不是对象实体。 Collection List:元素
西南交通大学-铁路综合创新课程设计-计算机联锁软件
铁路综合创新课程设计算机联锁软件使用C/C++与MFC代码基本无bug，更换车站或站场图只需要修改读入的txt即可，非常简易方便适用于易家湾，坳上，霞凝，桥头驿，杨桥，丝茅冲，大托铺等位置使用方法请参考:https://yanyuchen.blog.csdn.net/article/details/135883863
Comsol仿真，对于学习涡旋光和折射很有帮助，有代码和仿真文件说明,Comsol仿真; 涡旋光学习; 折射仿真; 代码与仿真文件说明,Comsol仿真：涡旋光与折射学习助手
Comsol仿真，对于学习涡旋光和折射很有帮助，有代码和仿真文件说明,Comsol仿真; 涡旋光学习; 折射仿真; 代码与仿真文件说明,Comsol仿真：涡旋光与折射学习助手
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值