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

元素唯一不能重复

底层结构是:哈希表结构 + 链表结构

元素的存与取的顺序一致