JAVA基础学习总结，day14(List集合、set集合)

List集合：

List集合的特点：

1. List集合中的元素存取有序
2. List集合有索引
3. List集合中的元素可以重复

List集合在Collection集合的基础上额外增加的常用方法：增删查改

• public void add(int index, E element) : 将指定的元素，添加到该集合中的指定位置上。
  index:索引

          List<String> list = new ArrayList<String>();
                      // 往 尾部添加 指定元素
             list.add("图图");
             list.add("小美");
             list.add("不高兴");
                      System.out.println(list);
             // add(int index,String s) 往指定位置添加
             list.add(1,"没头脑");//插队添加

• public E get(int index) :返回集合中指定位置的元素。

  // String get(int index)  获取指定位置元素
                      跟size() 方法一起用  来 遍历的
             for(int i = 0;i<list.size();i++){
            System.out.println(list.get(i));
                }
  

• public E remove(int index) : 移除列表中指定位置的元素, 返回的是被移除的元素。

    // String remove(int index) 删除指定位置元素  返回被删除元素
             // 删除索引位置为2的元素
              System.out.println("删除索引位置为2的元素");
             System.out.println(list.remove(2));
                      System.out.println(list);

• public E set(int index, E element) :用指定元素替换集合中指定位置的元素,返回值的更新前的元素。

   // String set(int index,String s)
              // 在指定位置 进行 元素替代（改）
               // 修改指定位置元素
              list.set(0, "三毛");
              System.out.println(list);

数据结构：

栈结构：
　　先进后出，栈的入口和出口都是在栈的顶端
队列结构：
　　先进先出，队列的入口和出口在两端
数据结构：
　　查询快，增删慢
链表结构：
　　查询慢，增删快
红黑树（二叉树）：提高搜索效率
　　规律：左边小，右边大

（重要）

Collection 单列集合

List 集合常用的子集合：元素存取有序，有索引，元素可以重复

• vector 集合:存储元素的结构是数组结构
  • 数组结构，查询快，增删慢，线程安全，效率低
• ArrayList集合:存储元素的结构是数组结构
  • 数组结构，查询快，增删慢，线程不安全，效率高
• LinkedList 集合:存储元素的结构是链表结构
  • 链表结构，查询慢，增删快，线程不安全，效率高

Set集合：元素存取无序，无索引，元素不可以重复

• HashSet集合：
  • 存储元素的结构是哈希表结构，可以保证元素唯一，存取元素无序
• LinkedHashSet集合：
  • 存储元素的结构是链表+哈希表结构，由链表保证元素存取有序，由哈希表保证元素唯一
• TreeSet集合：

  • 存储元素的结构是二叉树结构，可以保证元素唯一，并且有序

    哈希表结构底层：数组+链表
    jdk8之前：数组+链表
    jdk8之前：数组+链表+红黑树

队列的实现类：LinkedList
栈的实现类：Stack

LinkedList类：

LinkedList集合独特的方法：

• public void addFirst(E e):将指定元素插入此列表的开头

     LinkedList<String> link = new LinkedList<String>();
            //添加元素addFirst方法
            link.addFirst("abc1");
            link.addFirst("abc2");
            link.addFirst("abc3");
            System.out.println(link);

• public void addLast(E e):将指定元素添加到此列表的结尾
• public E getFirst():返回此列表的第一个元素
• public E getLast():返回此列表的最后一个元素
• public E removeFirst():移除并返回此列表的第一个元素
• public E removeLast():移除并返回此列表的最后一个元素
• public E pop():从此列表所表示的堆栈处弹出一个元素//删除第一元素
• public viod push(E e):将元素推入次列表所表示的堆栈//添加元素到第一元素
• public boolean isEmpty():如果列表不包含元素，则返回true

     while (!link.isEmpty()) { //判断集合是否为空
                System.out.println(link.pop()); //弹出集合中的栈顶元素
    }    

Set 集合：继承Collection集合，并且没有定义特有的方法，
特点：

1. 存取集合中的元素无序
2. 集合中的元素没有索引
3. 集合中的元素不能重复

Set集合的子类

• HashSet:是哈希表结构，由哈希表保证集合中的元素唯一 存取无序，元素唯一，没有索引
  • LinkedHashSet:是链表+哈希表结构， 注意：存取有序，元素唯一，没有索引
    由链表保证元素存取有序，由哈希表保证元素唯一
• TreeSet:是树状结构，由二叉树保证集合中的元素唯一 存取无序，元素唯一，没有索引

HashSet集合存取元素唯一的原理：

1. 首先调用元素的hashCode()方法，计算元素的哈希值
2. 判断该哈希值对应的位置上是否有相同哈希值的元素
3. 如果该位置上没有相同哈希值的元素，就直接存储
4. 如果该位置是上有相同哈希值的元素，说明产生了哈希冲突
5. 如果产生了哈希冲突，就会调用元素的equals方法，去和该位置上的所有元进行比较，如果比较完之后，没有返回true就存储，如果其中有一个返回true，就不存储

HashSet存储自定义类型元素：
　　我们在比较2个对象的时候，往往认为2个对象的所有属性的值如果是一模一样的，就认为这是2个相同的对象，所以HashSet想要存储自定义类型的元素，就必须重写hashCode()方法和equals()方法

结论：
　　HashSet集合如果想要存储自定义类的对象，那么就必须重写hashCode和equals方法
　　
原因：
　　Object类种的hashCode方法是根据地址值来计算哈希值，并且Obiect类中

TreeSet 集合：存取无序，元素唯一，没有索引，对元素进行排序
　　构造方法：
　　　　　　public TreeSet();//通过空参构造方法创建出来的TreeSet集合会对元素进行默认排序

按照默认规则进行排序

• TreeSet (comparator <? super E> comparator)构造一个新的，空的树集，根据指定的比较器进行排序。

如果TreeSet集合中的元素想要进行默认规则排序，那么该元素所属的类必须实现Comparablie接口中的compareTo()方法，在compareTo()方法指定排序规则

TreeSet存储自定义类型的元素：

• compareTo(T o) 返回0，只有一个元素
• compareTo(T o) 返回正数，怎么存储，就怎么取
• compareTo(T o) 返回负数，倒叙存取

根据自定义规则排序：使用外部比较器（Comparator）

• TreeSet(Comparator<? super E> comparator) 构造一个新的，空的树集，根据指定的比较器进行排序

Comparator： 比较器接口：灵活规则
　　成员方法
int compare（T o1,T o2）比较其两个参数的顺序
　　　前减后 升序
　　　后减前 降序

Comparablie：比较器：默认规则

可变参数
　格式：
　　　修饰符 返回值类型 方法名（参数类型…形参名）｛｝
　等价于
　　　修饰符 返回值类型 方法名(参数类型[] 形参名){ }

在JDK1.5之后，如果我们定义一个方法需要接受多个参数，并且对个参数类型一致，那么就可以使用可变参数

同样是代表数组，但是在调用这个带有可变参数的方法时，不用创建数组（这就是简单之处），直接将数组中的元素作为实际参数进行传递，其实编译成的class文件，将这些元素封装到一个数组中，在进行传递，这些动作都在编译.class文件时，自动完成了。

注意事项：
　　如果在方法书写时，这个方法拥有多参数，参数中包含可变参数，可变参数一定要写在参数列表的末尾位置

Collections 类(工具类)：

• public static boolean addAll(Collection c, T… elements) :往集合中添加一些元素。

         //采用工具类 完成 往集合中添加元素
              Collections.addAll(list, 5, 222, 1，2);
            System.out.println(list);//[5, 222, 1, 2]
  

• public static void shuffle(List<?> list) 打乱顺序 :打乱集合顺序。
• public static void sort(List list) :将集合中元素按照默认规则排序。

默认规则：写死的规则 在Comparablie接口中的compareTo()方法中写死的规则
如果想要使用Collections中的sort(Listlist)方法对集合进行排序，那么该集合中的元素所属的类

必须实现Comparablie接口中的compareTo()方法，并且在该方法中指定默认规则

              //排序方法
             Collections.sort(list);
            System.out.println(list);//[1, 2, 5, 222]

• public static void sort(List list，Comparator<? super T> ) :将集合中元素按照指定规则排

按照指定的比较规则进行排序 在Comparator接口中的compare方法中指定比较规则

• 前减后 升序
• 后减前 降序