数据结构-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

/*List额外提供了一个ListIterator,在Iterator的基础上增加了三个方法
1.boolean hasPrevious():返回与迭代器关联的集合是否还有上一个元素;
2.Object previous():返回迭代器的上一个元素;
3.void add(Object o):在指定位置插入一个元素;*/

import java.util.List;
 import java.util.ArrayList;
 import java.util.ListIterator;
 public class ListIteratorDemo{
     public static void main(String[] args){
         String[] names = {"jack","rose","tom"};
         List<String> list = new ArrayList<>();
         for(int i = 0; i < names.length; i++){
             list.add(names[i]);
         }
         ListIterator<String> lit = list.listIterator();
         //向后迭代
        while(lit.hasNext()){
             System.out.print(lit.next()+"	");//jack    rose    tom    
         }
         System.out.println("
=====下面反向迭代==========");
         //向前迭代
        while(lit.hasPrevious()){
             System.out.print(lit.previous()+"	");//tom    rose    jack
         }
     }
 }

三.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()
   

 import java.util.LinkedList;

     public class LinkedListDemo{
         public static void main(String[] args){
             LinkedList<String> books = new LinkedList<>();
             //将字符串元素加入队列的尾部
            books.offer("java讲义");
             //将字符串元素加入队列的头部
            books.offerFirst("android 讲义");
             //将字符串元素加入栈的顶部
            books.push("java ee 讲义");

             //以list方式(索引)遍历集合元素
            for(int i = 0; i < books.size(); i++){
                 System.out.println("遍历中:"+books.get(i));
             }

             //访问不删除栈顶的元素
            System.out.println(books.peekFirst());//java ee 讲义---push
             //访问不删除队列的最后一个元素
            System.out.println(books.peekLast());//java讲义--offer
             //将栈顶的元素弹出
            System.out.println(books.pop());//java ee  讲义--push
             //下面将看到队列中第一个元素被删除
            System.out.println(books);//[android 讲义, java讲义]
             //访问并删除队列中的最后一个元素
            System.out.println(books.pollLast());//java讲义--offer
             System.out.println(books);//[android 讲义]
         }
     }

四.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集合规则冲突.
    
     代码重写示例:
    

/*class中仅包含两个属性:private String name; private int age;hashCode()和equals()方法重写如下*/
         @Override
         public int hashCode(){
             final int prime = 31;
             int result = 1;
             result = prime * result + age;
             result = prime * result + ((name == null) ? 0 : name.hashCode());
             return result;
         }

         @Override
         public boolean equals(Object obj){
             if (this == obj)
                 return true;
             if (obj == null)
                 return false;
            if (getClass() != obj.getClass())
                 return false;
             Person other = (Person) obj;
             if (age != other.age)
                 return false;
             if (name == null) {
                 if (other.name != null)
                     return false;
             } else if (!name.equals(other.name))
                 return false;
             return true;
         }

六.判断元素唯一性的规则
     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方法相同,得出结论,这两个对象相等!
代码演示:
    

import java.util.HashSet;
     //类A的equals()方法总是返回true,仅重写equals()
     class A{
         public boolean equals(Object o){
             System.out.println("=====A euqals()======");
             return true;
         }
     }

     //类B的hashCode()总是返回1,仅重写hashCode()
     class B{
         public int hashCode(){
             System.out.println("=======B hashCode()========");
             return 1;
         }
     }

    
    
    

//重写euqals()和hashCode()
     class C{
         public int hashCode(){
             System.out.println("=======C hashCode()========");
             return 2;
         }
         public boolean equals(Object o){
             System.out.println("=====C equals()======");
             return true;
         }
     }

    
   

 //测试
    public class HashSetTest{
         public static void main(String[] args){
             HashSet books = new HashSet();
             /*A仅重写了equals(),添加第二个A时,结果:A作为两个对象保存[A@15db9742, A@6d06d69c],并且未调用equals()方法.说明首先调用hashCode(),如果不相等,则直接认为是两个对象
            并提示:注: HashSetTest.java使用了未经检查或不安全的操作。*/
             books.add(new A());
             books.add(new A());

             //B仅重写了hashCode(),添加第二个B时,结果:B作为两个对象保存[B@1, B@1],并提示:注: HashSetTest.java使用了未经检查或不安全的操作。
            books.add(new B());
             books.add(new B());

             //C重写了euqals()和hashCode(),添加第二个C时,结果作为一个对象保存[C@2],注: HashSetTest.java使用了未经检查或不安全的操作。
            C c1 = new C();    //仅运行这一行,不调用hashCode()
             C c2 = new C();
             books.add(c1);
             books.add(c2);
             System.out.println(books);
         }
     }

输出:[-----------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:
     元素唯一不能重复
     底层结构是:哈希表结构 + 链表结构
     元素的存与取的顺序一致