黑马程序员技术交流社区

标题: [学习交流]单列集合与多列结合的基本概念 [打印本页]

---

作者: Merle007    时间: 2018-12-12 13:04
标题: [学习交流]单列集合与多列结合的基本概念
Collection集合：
        数组长度不可变，只能存储同类型元素
        集合长度可变，只可以存储对象
List接口：
        1.有序集合
        2.允许元素重合
        3.有索引，包含带索引的方法
Set接口：
        1.无序集合
        2.不允许重复元素
        3.没有索引，不包含带索引的方法

Collection 常用功能：

        public boolean add(E e) ：
        把给定的对象添加到当前集合中

        public void clear() :
        清空集合中所有的元素

        public boolean remove(E e) :
        把给定的对象在当前集合中删除
        （集合中如果有相同的元素，只删除【第一个】）

        public boolean contains(E e) :
        判断当前集合中是否包含给定的对象

        public boolean isEmpty() :
        判断当前集合是否为空

        public int size() :
        返回集合中元素的个数

        public Object[] toArray() :
        把集合中的元素，存储到数组中

Iterator接口：
        主要用于迭代访问（即遍历） Collection 中的元素，因此 Iterator 对象也被称为迭代器

迭代：
        即Collection集合元素的通用获取方式。在取元素之前【先要判断集合中有没有元素】，
        如果有，就把这个元素取出来，继续在判断，如果还有就再取出出来。
        一直把集合中的所有元素全部取出。
        这种取出方式专业术语称为迭代。



Iterator接口的常用方法：
        public E next() :
        返回迭代的下一个元素
        （1.取出当前指针指向的元素，2.把指针向后移动一位）

        public boolean hasNext() :
        如果仍有元素可以迭代，则返回 true
        （判断是否到达集合的末尾）

iterator迭代器的使用步骤：
        1.使用集合中的方法iterator(),获取迭代器的实现类对象，使用Iterator接口接受实现类（多态）；
        2.使用Iterator接口中的方法hasNext判断是否到达了集合的末尾；
        3.使用Iterator接口中的方法next取出集合中的元素。

        已知循环次数，使用For循环
        未知循环次数，使用While循环

Iterator<E> Xxx = Collection.iterator();
iterator();方法可以获取迭代器的实现类对象，并将索引指向集合的第一个元素。

迭代器 不能在遍历过程中修改集合长度
如需添加，使用ListIterator.add/ListIterator.remove

增强for：
        也是迭代器，特别用于遍历Collectiion集合

格式：
        for(数据类型 变量名 : 集合名or数组名){
                //写操作代码
        }

泛型：
        未知数据类型时，可以使用泛型，泛型代表某一数据类型
        创建集合对象时，可以确定泛型的数据类型
       
泛型的优点：
        1.避免了类型转换异常，
        2.把运行一场提升到了编译期
        缺点：
        泛型指定类型后，只能存储同种类型
       
        不使用泛型：
                优点：不使用泛型时，默认的数据类型就是Object类型，可以存储任意类型的数据
                缺点：数据不安全，易引发异常
               
泛型的基本使用：
        泛型可以接受任意的数据类型
        创建对象的时候确定泛型的数据类型
       
含有泛型的方法：
        泛型要定义在方法的修饰符和返回值之间
格式：
        修饰符<泛型> 返回值类型 方法名（参数列表（使用泛型））{
                方法题；
        }
        含有泛型的方法，在调用方法的时候确定泛型的数据类型
        泛型与传递进去的参数类型一致

含有泛型的接口：
        ①定义接口的实现类，实现接口，并且直接指定接口的类型
        ②实现类与接口使用相同的泛型，
         相当于定义一个含有泛型的类，创建对象的时候确定泛型的类型
         
泛型通配符：
         ？：代表任意的数据类型
         不能创建对象使用
         只能作为方法的参数使用
         
泛型的限定：
        上限限定：？extends E代表使用的泛型只能是E类型的子类/本身
        下限限定：？super E 代表使用的泛型只能是E类型的父类/本身

常见数据结构：
        数据存储的常用结构有：
        栈、队列、数组、链表和红黑树
栈（stack）：
        是一种运算受限的线性表，仅允许在表的一端进行增、删操作，
        不允许在表的其他位置进行添加、查找、删除等操作。
        特征：
        1.先进【后出】（压栈、弹栈）
        2.出、入口都在栈的顶端
       
队列（queue）：
        是一种运算受限的线性表，仅允许在表的一端进行插入，而在表
        的另一端进行删除。
        特征：
        1.先进【先出】（入队、出队）
        2.队列的入口、出口各占一端
       
数组（Array）：
        是在内存中开辟一段连续的空间，并在此空间【有序地】存放
        元素。
        特征：
        1.查找元素快
        2.增删元素慢
        3.可指定索引位置删除元素
       
链表（linked list）：
        由一系列结点node（链表中每一个元素称为节点）组成，节点可以
        在运行时动态生成
        构成：
        1.一个存储数据元素的数据域
        2.两个存储节点地址的指针域
        特征：
        1.多个节点之间，通过地址进行连接
        2.查找元素慢
        3.增删元素快
       
单向链表：一条链型，不能保证元素的顺序
双向链表：两条链型，其中一条专门负责记录元素的顺序
       
红黑树（binar tree）
        二叉树：每个结点不超过2的有序树（tree）
        红黑树：本身就是一颗二叉查找树，将节点插入后，该树仍然是一
        颗二叉查找树。也就意味着，树的键值仍然是有序的。
        红黑树的约束:
        1. 节点可以是红色的或者黑色的
        2. 根节点是黑色的
        3. 叶子节点(特指空节点)是黑色的
        4. 每个红色节点的子节点都是黑色的
        5. 任何一个节点到其每一个叶子节点的所有路径上黑色节点数相同
        特征：
        速度特别快,趋近平衡树,查找叶子元素最少和最多次数不多于二倍
       
List集合：
        特征：
        1.元素存取有序
        2.有索引
        3.允许元素重复
       
List集合常用方法：
        public void add(int index, E element) :
                将指定的元素，添加到该集合中的指定位置上。
        public E get(int index) :
                返回集合中指定位置的元素。
        public E remove(int index) :
                移除列表中指定位置的元素, 返回的是被移除的元素。
        public E set(int index, E element) :
                用指定元素替换集合中指定位置的元素,返回值的更新前的元素。

ArayyList集合：
        存储的结构是数组结构。元素增删慢，查找快

LinkedList集合：
        集合数据存储的结构是【双向】链表结构。方便元素添加、删除的集合       
LinkedList集合常用方法：
        public void addFirst(E e) :
                将指定元素插入此列表的开头。
        public void addLast(E e) :
                将指定元素添加到此列表的结尾。
        public E getFirst() :
                返回此列表的第一个元素。
        public E getLast() :
                返回此列表的最后一个元素。
        public E removeFirst() :
                移除并返回此列表的第一个元素。
        public E removeLast() :
                移除并返回此列表的最后一个元素。
        public E pop() :
                从此列表所表示的堆栈处弹出一个元素。
        public void push(E e) :
                将元素推入此列表所表示的堆栈。
        public boolean isEmpty() ：
                如果列表不包含元素，则返回true
       
Set接口：
        元素无序，并且都会以某种规则保证存入的元素不重复

HashSet集合：
        特点：
        1.存储的元素是不可重复的，
        2.并且元素都是无序的。
       
HashSet存储自定义类型元素：
        给HashSet中存放自定义类型元素时，需要【重写】对象中的hashCode和
        equals方法，建立自己的比较方式，才能保证HashSet集合中的对象唯一
       
LinkedHashSet：
        HashSet保证元素唯一，但是元素存放进去是没有顺序的
        因此用到LinkedHashSet保证元素有序
       
可变参数：
        当方法的参数列表【数据类型】已经确定，但是【参数的个数】不确定，就可以
        使用可变参数
        原理：
        底层就是一个数组，根据传递参数个数的不同，会创建长度不同的数组，
        用以储存参数
        格式：
        定义方法时使用
                修饰符 返回值类型 方法名（数据类型...变量名）｛
                        方法体；
                ｝
        注意：
        1.一个方法的参数列表，只能有【一个可变参数】
        2.如果在方法书写时，这个方法拥有多参数，参数中包含可变参数，可变
        参数一定要写在参数列表的末尾位置。
       
Collections常用功能：
        Collections是【集合工具类】，用来对集合进行操作
        public static <T> boolean addAll(Collection<T> c, T... elements) :
                往集合中添加一些元素。
        public static void shuffle(List<?> list) ：
                打乱顺序 :打乱集合顺序。
        public static <T> void sort(List<T> list) :
                将集合中元素按照默认规则排序。
        public static <T> void sort(List<T> list，Comparator<? super T> ) :
                将集合中元素按照指定规则排序
       
Comparator比较器：
       
JAVA中两种比较实现的方式：
        1.java.lang.Comparable 接口实现（默认方式，死板）
        2.java.util.Comparator 接口完成（使用者设定，灵活）

Comparable排序规则：
        自己（this） -  参数 = 升序

Comparable和Comparator两个接口的区别：
        Comparable：强行对实现它的每个类的对象进行整体排序。这种排序被称
        为类的自然排序，类的compareTo方法被称为它的自然比较方法。只能在类
        中实现compareTo()一次，不能经常修改类的代码实现自己想要的排序。实
        现此接口的对象列表（和数组）可以通过Collections.sort（和Arrays.sort）
        进行自动排序，对象可以用作有序映射中的键或有序集合中的元素，无需指定
        比较器。
        Comparator：强行对某个对象进行整体排序。可以将Comparator 传递
        给sort方法（如Collections.sort或Arrays.sort），从而允许在排序顺序上
        实现精确控制。还可以使用Comparator来控制某些数据结构（如有序set或有
        序映射）的顺序，或者为那些没有自然顺序的对象collection提供排序。

---

欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/)

黑马程序员IT技术论坛 X3.2