数据结构-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()+"\t");//jackrosetom
}
System.out.println("\n=====下面反向迭代==========");
//向前迭代
while(lit.hasPrevious()){
System.out.print(lit.previous()+"\t");//tomrosejack
}
}
}

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