day16 17 集合Arraylist

1:List的子类(掌握)

         (1)List的子类特点

                  ArrayList:

                          底层数据结构是数组，查询快，增删慢

                          线程不安全，效率高

                  Vector:

                          底层数据结构是数组，查询快，增删慢

                          线程安全，效率低

                  LinkedList:

                          底层数据结构是链表，查询慢，增删快

                          线程不安全，效率高

         (2)ArrayList

                  A:没有特有功能需要学习

                  B:案例

                          a:ArrayList存储字符串并遍历

                          b:ArrayList存储自定义对象并遍历

         (3)Vector

                  A:有特有功能

                          a:添加

                                   public void addElement(E obj)                --      add()

                          b:获取

                                   public E elementAt(int index)         --      get()

                                   public Enumeration<E> elements()        --  iterator()

                  B:案例

                          a:Vector存储字符串并遍历

                          b:Vector存储自定义对象并遍历

         (4)LinkedList

                  A:有特有功能        

                          a:添加

                                   addFirst()

                                   addLast()

                          b:删除

                                   removeFirst()

                                   removeLast()

                          c:获取

                                   getFirst()

                                   getLast()

                  B:案例

                          a:LinkedList存储字符串并遍历

                          b:LinkedList存储自定义对象并遍历

         (5)案例：

                  A:去除集合中的多个字符串的重复元素

                          如果字符串的内容相同，即为重复元素

                  B:去除集合中的多个自定义对象的重复元素

                          如果自定义对象的成员变量值都相同，即为重复元素

                  C:用LinkedList模拟一个栈数据结构的集合类，并测试。

                          你要定义一个集合类，只不过内部可以使用LinkedList来实现。

 

2:泛型(掌握)

         (1)泛型概述

                  是一种把明确类型的工作推迟到创建对象或者调用方法的时候才去明确的特殊的类型。

         (2)格式：

                  <数据类型>

                  注意：该数据类型只能是引用类型。

         (3)好处：

                  A:把运行时期的问题提前到了编译期间

                  B:避免了强制类型转换

                  C:优化了程序设计，解决了黄色警告线问题，让程序更安全

         (4)泛型的前世今生

                  A:泛型的由来

                          Object类型作为任意类型的时候，在向下转型的时候，会隐含一个转型问题

                  B:泛型类

                  C:泛型方法

                  D:泛型接口

                  E:泛型高级通配符

                          ?

                          ? extends E

                          ? super E

         (5)我们在哪里使用呢?

                  一般是在集合中使用。

        

3:增强for循环(掌握)

         (1)是for循环的一种

         (2)格式：

                  for(元素的数据类型 变量名 : 数组或者Collection集合的对象) {

                          使用该变量即可，该变量其实就是数组或者集合中的元素。

                  }

         (3)好处：

                  简化了数组和集合的遍历

         (4)弊端

                  增强for循环的目标不能为null。建议在使用前，先判断是否为null。

       

4:静态导入(了解)

         (1)可以导入到方法级别的导入

         (2)格式：

                  import static 包名....类名.方法名;

         (3)注意事项：

                  A:方法必须是静态的

                  B:如果多个类下有同名的方法，就不好区分了，还得加上前缀。

                          所以一般我们并不使用静态导入，但是一定要能够看懂。

        

5:可变参数(掌握)

         (1)如果我们在写方法的时候，参数个数不明确，就应该定义可变参数。

         (2)格式：

                  修饰符 返回值类型 方法名(数据类型... 变量) {}

                 

                  注意：

                          A:该变量其实是一个数组名

                          B:如果一个方法有多个参数，并且有可变参数，可变参数必须在最后

         (3)Arrays工具类的一个方法

                  asList()把数组转成集合。

                  注意：这个集合的长度不能改变。

 

6:练习(掌握)

         A:集合的嵌套遍历

         B:产生10个1-20之间的随机数，要求随机数不能重复

         C:键盘录入多个数据，以0结束，并在控制台输出最大值

        

7:要掌握的代码

         集合存储元素，加入泛型，并可以使用增强for遍历。

 

1:登录注册案例(理解)

 

2:Set集合(理解)

         (1)Set集合的特点

                  无序,唯一

         (2)HashSet集合(掌握)

                  A:底层数据结构是哈希表(是一个元素为链表的数组)

                  B:哈希表底层依赖两个方法：hashCode()和equals()

                    执行顺序：

                          首先比较哈希值是否相同

                                   相同：继续执行equals()方法

                                            返回true：元素重复了，不添加

                                            返回false：直接把元素添加到集合

                                   不同：就直接把元素添加到集合

                  C:如何保证元素唯一性的呢?

                          由hashCode()和equals()保证的

                  D:开发的时候，代码非常的简单，自动生成即可。

                  E:HashSet存储字符串并遍历

                  F:HashSet存储自定义对象并遍历(对象的成员变量值相同即为同一个元素)

         (3)TreeSet集合

                  A:底层数据结构是红黑树(是一个自平衡的二叉树)

                  B:保证元素的排序方式

                          a:自然排序(元素具备比较性)

                                   让元素所属的类实现Comparable接口

                          b:比较器排序(集合具备比较性)

                                   让集合构造方法接收Comparator的实现类对象

                  C:把我们讲过的代码看一遍即可

         (4)案例：

                  A:获取无重复的随机数

                  B:键盘录入学生按照总分从高到底输出

                 

3:Collection集合总结(掌握)

         Collection

                  |--List      有序,可重复

                          |--ArrayList

                                   底层数据结构是数组，查询快，增删慢。

                                   线程不安全，效率高

                          |--Vector

                                   底层数据结构是数组，查询快，增删慢。

                                   线程安全，效率低

                          |--LinkedList

                                    底层数据结构是链表，查询慢，增删快。

                                   线程不安全，效率高

                  |--Set       无序,唯一

                          |--HashSet

                                   底层数据结构是哈希表。

                                   如何保证元素唯一性的呢?

                                            依赖两个方法：hashCode()和equals()

                                            开发中自动生成这两个方法即可

                                   |--LinkedHashSet

                                            底层数据结构是链表和哈希表

                                            由链表保证元素有序

                                            由哈希表保证元素唯一

                          |--TreeSet

                                   底层数据结构是红黑树。

                                   如何保证元素排序的呢?

                                            自然排序

                                            比较器排序

                                   如何保证元素唯一性的呢?

                                            根据比较的返回值是否是0来决定

                                           

4:针对Collection集合我们到底使用谁呢?(掌握)

         唯一吗?

                  是：Set

                          排序吗?

                                   是：TreeSet

                                   否：HashSet

                  如果你知道是Set，但是不知道是哪个Set，就用HashSet。

                         

                  否：List

                          要安全吗?

                                   是：Vector

                                   否：ArrayList或者LinkedList

                                            查询多：ArrayList

                                            增删多：LinkedList

                  如果你知道是List，但是不知道是哪个List，就用ArrayList。

        

         如果你知道是Collection集合，但是不知道使用谁，就用ArrayList。

        

         如果你知道用集合，就用ArrayList。

        

5:在集合中常见的数据结构(掌握)

         ArrayXxx:底层数据结构是数组，查询快，增删慢

         LinkedXxx:底层数据结构是链表，查询慢，增删快

         HashXxx:底层数据结构是哈希表。依赖两个方法：hashCode()和equals()

         TreeXxx:底层数据结构是二叉树。两种方式排序：自然排序和比较器排序