数据结构-List接口-LinkedList类-Set接口-HashSet类-Collection总结

一.数据结构:4种--<需补充>

1.堆栈结构:
     特点:LIFO(后进先出);栈的入口/出口都在顶端位置;压栈就是存元素/弹栈就是取元素;
     代表类:Stack;
     其它:main方法最后一个出去;

2.数组结构:
     特点:一片连续的空间;有索引,查找快;增删慢;
     代表类:ArrayList;
     应用场景:用于查询多的场景,如天气预报;

3.队列结构:
     特点:FIFO(先进先出);入口/出口在两侧;
     代表:Queue接口
     应用场景:12306购票网站

4.链表结构:
     特点:增删快,查询慢;
     代表:LinkedList类;Linked开头的都是链表结构.
     应用场景:比如监控;历史操作/日志;

二.List接口:(java.util)
     定义:public interface List<E> extends Collection<E>{}
         List接口属于Collection的子接口之一,Collection中的所有方法,List接口的对象都能用.
     特点:有序,带索引,允许重复,可以存放多个null值;
     常用子类:ArrayList;LinkedList;
     常用方法:
         public void add(int index,E element){}在指定位置增加元素;
         public boolean addAll(int index, Collection<? extends E> c){}在指定位置增加一组元素;
         E get(int index){}返回指定位置的元素;
         public int indexOf(Object o){}查找指定元素的位置;
         public int lastIndexOf(Object o){}从后向前查找指定元素的位置;
         public ListIterator<E> listIterator(){}为ListIterator实例化;
         public E remove(int index){}按指定的位置删除元素;
         public List<E> subList(intFromIndex, intToIndex){}取出集合中的子集合;
         public E set(int index, E element){}替换指定位置的元素;

代码演示://ListIterator

  1 /*List额外提供了一个ListIterator,在Iterator的基础上增加了三个方法
  2 1.boolean hasPrevious():返回与迭代器关联的集合是否还有上一个元素;
  3 2.Object previous():返回迭代器的上一个元素;
  4 3.void add(Object o):在指定位置插入一个元素;*/
  5
  6 import java.util.List;
  7  import java.util.ArrayList;
  8  import java.util.ListIterator;
  9  public class ListIteratorDemo{
 10      public static void main(String[] args){
 11          String[] names = {"jack","rose","tom"};
 12          List<String> list = new ArrayList<>();
 13          for(int i = 0; i < names.length; i++){
 14              list.add(names[i]);
 15          }
 16          ListIterator<String> lit = list.listIterator();
 17          //向后迭代
 18         while(lit.hasNext()){
 19              System.out.print(lit.next()+"\t");//jack    rose    tom
 20          }
 21          System.out.println("\n=====下面反向迭代==========");
 22          //向前迭代
 23         while(lit.hasPrevious()){
 24              System.out.print(lit.previous()+"\t");//tom    rose    jack
 25          }
 26      }
 27  }
 28 

三.LinkedList类:(java.util)
     定义:public class LinkedList<E> extends AbstractSequentialList<E> implements List<E>, Deque<E>, Cloneable, Serializable
         是List接口的实现类;
     特点:LinkedList中数据存储结构为链表结构,但是也允许将链表结构作为队列/双端队列/堆栈使用;
     构造方法:
         LinkedList()
         LinkedList(Collection<? extends E> c);复制集合时,可利用该构造方法直接将集合放进去即可;
     特有方法:
         public void addFirst():添加至0位置;
         public void addLast():等同于add,添加至最后;
         E getFirst():返回集合中第一个元素;
         E getLast():返回集合中最后一个元素;
         E removeFirst():删除并返回第一个元素;
         E removeLast();删除并返回最后一个元素;(由于这两个remove才会想到使用LinkedList);
         E poll():找到并删除表头;作为堆栈使用,类似于removeFirst;
         E pollFirst():删除并返回第一个元素;
         E pollLast():删除并返回最后一个元素;
         E pop():作为堆栈使用,类似于removeFirst()
         E push():作为堆栈使用,类似于addFirst()
    
     代码演示:// offer()/offerFirst()/push()/peekFirst()/peekLast()  /pop()/pollLast()
   

  1  import java.util.LinkedList;
  2
  3      public class LinkedListDemo{
  4          public static void main(String[] args){
  5              LinkedList<String> books = new LinkedList<>();
  6              //将字符串元素加入队列的尾部
  7             books.offer("java讲义");
  8              //将字符串元素加入队列的头部
  9             books.offerFirst("android 讲义");
 10              //将字符串元素加入栈的顶部
 11             books.push("java ee 讲义");
 12
 13              //以list方式(索引)遍历集合元素
 14             for(int i = 0; i < books.size(); i++){
 15                  System.out.println("遍历中:"+books.get(i));
 16              }
 17
 18              //访问不删除栈顶的元素
 19             System.out.println(books.peekFirst());//java ee 讲义---push
 20              //访问不删除队列的最后一个元素
 21             System.out.println(books.peekLast());//java讲义--offer
 22              //将栈顶的元素弹出
 23             System.out.println(books.pop());//java ee  讲义--push
 24              //下面将看到队列中第一个元素被删除
 25             System.out.println(books);//[android 讲义, java讲义]
 26              //访问并删除队列中的最后一个元素
 27             System.out.println(books.pollLast());//java讲义--offer
 28              System.out.println(books);//[android 讲义]
 29          }
 30      }

四.Set接口:(java.util)
     定义:public interface Set<E> extends Collection<E>{} 所以Collection中的大多数方法,均能使用;
     特点:无序,大多数不带索引,不允许重复,只能包含一个null值;
         set并没有对Collection接口进行扩充,只是比Collection接口的要求列加严格了,不能增加重复元素;
     常用子类:
         TreeSet:
         HashSet:
         LinkedHashSet:相对于HashSet集合来说,保证了存与取的顺序一致

五.HashSet类:(java.util)
     定义:public class HashSet<E> extends AbstractSet<E> implements Set<E>, Cloneable, Serializable
     特点:不能放重复元素,采用散列的存储方式.
         对存进去的每一个元素,都使用一个hash算法,进行运算,得出hash码值;根据hash码值决定保存元素的位置;
         注意:(农/丰)(儿/女)哈希值相等
     哈希表:
         1.简介:Hash table，也叫哈希表，是根据关键码值(Key value)而直接进行访问的数据结构。也就是说，
             它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表。
         2.初衷:hash表的初衷希望每个位置都保存一个元素,以提升查询的性能!
         3.Obect类中提供了一个HashCode方法,该方法可以得到一个对象的hash码值;
         4.常规协定:
             (1)如果根据equals(Object)方法,两个对象是相等的,那么他们的hash value必须相等.
             (2)如果根据equals(Object)方法,两个对象是不相等,那么他们的hash value也可能相等.
             (3)在Java应用程序执行期间,在对同一对象多次调用hashCode方法时,必须一致地返回相同的整数.
             (4)从某一应用程序的一次执行到同一应用程序的另一次执行，hash value无需保持一致。
     构造方法:
         HashSet()
         HashSet(Collection<? extends E> c)
     HashSet存自定义数据类型:
         如果set集合中存自定义数据类型的对象,建议重写equals方法和hashCode方法,否则,当两个对象的属性值完全相同时,会保存两个对象!与set集合规则冲突.
    
     代码重写示例:
    

  1 /*class中仅包含两个属性:private String name; private int age;hashCode()和equals()方法重写如下*/
  2          @Override
  3          public int hashCode(){
  4              final int prime = 31;
  5              int result = 1;
  6              result = prime * result + age;
  7              result = prime * result + ((name == null) ? 0 : name.hashCode());
  8              return result;
  9          }
 10
 11          @Override
 12          public boolean equals(Object obj){
 13              if (this == obj)
 14                  return true;
 15              if (obj == null)
 16                  return false;
 17             if (getClass() != obj.getClass())
 18                  return false;
 19              Person other = (Person) obj;
 20              if (age != other.age)
 21                  return false;
 22              if (name == null) {
 23                  if (other.name != null)
 24                      return false;
 25              } else if (!name.equals(other.name))
 26                  return false;
 27              return true;
 28          }

六.判断元素唯一性的规则
     1.list判断元素唯一性的规则(相关方法:remove,contains):
           仅仅依赖equals方法的结果;与是否重写hashCode方法没有任何关系;
     2.set判断元素唯一性的规则:(相关方法:add,remove,contains)
       (1)先判断两个对象的hash值是否相同;
               1.1:两个对象的hash值不相同,不再进行任何判断,直接得出结论,这两个对象不相等!
               1.2:两个对象的hash值相同,继续进行第二步比较;
       (2)判断两个对象的equals方法是否相同;
               2.1:两个对象的equals方法不相同,得出结论,这两个对象不相等!
               2.2:两个对象的equals方法相同,得出结论,这两个对象相等!

代码演示:
    

  1 import java.util.HashSet;
  2      //类A的equals()方法总是返回true,仅重写equals()
  3      class A{
  4          public boolean equals(Object o){
  5              System.out.println("=====A euqals()======");
  6              return true;
  7          }
  8      }
  9
 10      //类B的hashCode()总是返回1,仅重写hashCode()
 11      class B{
 12          public int hashCode(){
 13              System.out.println("=======B hashCode()========");
 14              return 1;
 15          }
 16      }

  1 //重写euqals()和hashCode()
  2      class C{
  3          public int hashCode(){
  4              System.out.println("=======C hashCode()========");
  5              return 2;
  6          }
  7          public boolean equals(Object o){
  8              System.out.println("=====C equals()======");
  9              return true;
 10          }
 11      }

  1  //测试
  2     public class HashSetTest{
  3          public static void main(String[] args){
  4              HashSet books = new HashSet();
  5              /*A仅重写了equals(),添加第二个A时,结果:A作为两个对象保存[A@15db9742, A@6d06d69c],并且未调用equals()方法.说明首先调用hashCode(),如果不相等,则直接认为是两个对象
  6             并提示:注: HashSetTest.java使用了未经检查或不安全的操作。*/
  7              books.add(new A());
  8              books.add(new A());
  9
 10              //B仅重写了hashCode(),添加第二个B时,结果:B作为两个对象保存[B@1, B@1],并提示:注: HashSetTest.java使用了未经检查或不安全的操作。
 11             books.add(new B());
 12              books.add(new B());
 13
 14              //C重写了euqals()和hashCode(),添加第二个C时,结果作为一个对象保存[C@2],注: HashSetTest.java使用了未经检查或不安全的操作。
 15             C c1 = new C();    //仅运行这一行,不调用hashCode()
 16              C c2 = new C();
 17              books.add(c1);
 18              books.add(c2);
 19              System.out.println(books);
 20          }
 21      }

输出:[-----------OUTPUT----------- 

=======B hashCode()========//添加B时调用一次

=======B hashCode()========//第二次添加B时调用一次

=======C hashCode()========//第一次添加C时调用一次

=======C hashCode()========//第二次添加C时调用一次

=====C equals()======//第二次添加C时调用比较

=======B hashCode()========//输出第一个B时,调用hashCode()

=======B hashCode()========//输出第二个B时,调用hashCode()

=======C hashCode()========//输出C时,调用hashCode()

[B@1, B@1, C@2, A@15db9742, A@6d06d69c]]

七.Collection总结:

Collection:
     |- List 可以存储重复元素,有序的(元素存取顺序)
         |- ArrayList
         |- LinkedList
     |- Set 不能存储重复元素,无序的(元素存取顺序)
         |- HashSet
         |- LinkedHashSet

Collection方法：

    boolean add(Object e) 把给定的对象添加到当前集合中

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

    boolean remove(Object o) 把给定的对象在当前集合中删除

    boolean contains(Object o) 判断当前集合中是否包含给定的对象

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

    Iterator iterator() 迭代器，用来遍历集合中的元素的

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

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

    Iterator :  迭代器

    Object next()返回迭代的下一个元素

    boolean hasNext()如果仍有元素可以迭代，则返回 true。

List与Set集合的区别？
     List:
         它是一个有序的集合(元素存与取的顺序相同)
         它可以存储重复的元素           
     Set:
         它是一个无序的集合(元素存与取的顺序可能不同)
         它不能存储重复的元素

List集合中的特有方法

    void add(int index, Object element) 将指定的元素，添加到该集合中的指定位置上

    Object get(int index)返回集合中指定位置的元素。

    Object remove(int index) 移除列表中指定位置的元素, 返回的是被移除的元素

    Object set(int index, Object element)用指定元素替换集合中指定位置的元素,返回值的更新前的元素

ArrayList:
     底层数据结构是数组，查询快，增删慢
     线程不安全，效率高

LinkedList:
     底层数据结构是链表，查询慢，增删快
     线程不安全，效率高

泛型：用来约束数据的数据类型

    泛型的格式：
         <数据类型>
         泛型可以使用在 类，接口，方法，变量上

    泛型的好处
         A:提高了程序的安全性
         B:将运行期遇到的问题转移到了编译期
         C:省去了类型强转的麻烦

增强for:简化数组和Collection集合的遍历
     格式：
         for(元素数据类型 变量 : 数组或者Collection集合) {
             使用变量即可，该变量就是元素
         }
     好处：简化遍历

HashSet:
     元素唯一不能重复
     底层结构是:哈希表结构
     元素的存与取的顺序不能保证一致
     如何保证元素的唯一的？重写hashCode() 与 equals()方法

LinkedHashSet:
     元素唯一不能重复
     底层结构是:哈希表结构 + 链表结构
     元素的存与取的顺序一致