集合List子接口
/*
* Collection是根接口,没有提供任何直接实现的。它有一些更具体的子接口,例如:List和Set。
* 一、List:列表,接口
* 1、List系列的集合:有序的、可重复的
* 2、List系列的集合:ArrayList(动态数组)、Vector(动态数组,向量类)、
* LinkedList(双向链表、双端队列、栈..)、Stack(栈)
* 3、List的API
* List接口比Collection接口多了一堆方法:
* 下面列举的方法是比Collection接口多出来,和它一样的就不写了:
* (1)void add(int index, Object element) :在[index]位置添加一个元素,相当于插入
* boolean addAll(int index, Collection c) :在[index]位置添加多个元素
* (2) Object remove(int index) :删除指定位置的元素
* (3)Object get(int index) :获取,返回[index]位置的元素
* (4)Object set(int index, Object element) :替换[index]位置的元素为element
* (5)int indexOf(Object o) :在当前集合中查找o这个元素的下标,如果没有返回-1,如果有多个就返回找到的第一个的下标
* (6) int lastIndexOf(Object o) :在当前集合中查找o这个元素的下标,如果没有返回-1,如果有多个就返回找到的最后一个的下标
* (7)List<E> subList(int fromIndex, int toIndex) :截取一部分,[fromIndex, toIndex)
* (8)ListIterator listIterator() :获取一种迭代器
* ListIterator是Iterator的子接口,它比Iterator增加了:从后往前遍历的方法,增加了遍历的同时添加和修改。
*
* Iterator:
* (1)boolean hasNext()
* (2)Object next()
* (3)void remove()
*
* ListIterator:多出来的
* (1)boolean hasPrevious() :是否前面还有元素
* (2)Object previous() :获取前面的元素
* (3)void add(E e) :遍历的同时,添加元素
* (4)void set(E e) :遍历的同时,替换元素
* (5) int nextIndex() :返回下一个元素的索引
* (6)int previousIndex() :返回前一个元素的索引
*
*
* 说明:虽然List系列的集合都是可以通过索引/下标进行操作的,但是像LinkedList这类的集合,其实不建议使用和索引相关的方法进行操作。
* 因为它们的底层的物理结构不是数组,如果通过索引操作呢,会需要从头或尾遍历找到对应的索引,效率不高。
*/
public class TestList {
@SuppressWarnings("all")
@Test
public void test8(){
//这里左边用List多态引用的目的是为了关注List接口方法
List list = new ArrayList();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
list.add(5);
ListIterator listIterator = list.listIterator(3);//把游标指定到任意位置
while(listIterator.hasPrevious()){
Object obj = listIterator.previous();
System.out.println(obj);
}
}
@SuppressWarnings("all")
@Test
public void test7(){
//这里左边用List多态引用的目的是为了关注List接口方法
List list = new ArrayList();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
list.add(5);
// ListIterator listIterator = list.listIterator();//默认游标在开头
ListIterator listIterator = list.listIterator(list.size());//把游标指定到后面去
while(listIterator.hasPrevious()){
Object obj = listIterator.previous();
System.out.println(obj);
}
}
@SuppressWarnings("all")
@Test
public void test6(){
//这里左边用List多态引用的目的是为了关注List接口方法
List list = new ArrayList();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
list.add(5);
ListIterator listIterator = list.listIterator();
while(listIterator.hasNext()){
Object obj = listIterator.next();
System.out.println(obj);
}
System.out.println("-------------------------");
while(listIterator.hasPrevious()){
Object obj = listIterator.previous();
System.out.println(obj);
}
}
@SuppressWarnings("all")
@Test
public void test5(){
//这里左边用List多态引用的目的是为了关注List接口方法
List list = new ArrayList();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
list.set(3, 100);
System.out.println(list);
Object obj = list.get(2);
System.out.println(obj);
}
@SuppressWarnings("all")
@Test
public void test4(){
//这里左边用List多态引用的目的是为了关注List接口方法
List list = new ArrayList();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
for (Object object : list) {
System.out.println(object + ":" + object.getClass());
}
}
@SuppressWarnings("all")
@Test
public void test3(){
//这里左边用List多态引用的目的是为了关注List接口方法
List list = new ArrayList();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
/*
* 这里remove(1)它,调用的是remove(int index)这个方法
* 为什么不是调用remove(Object obj)?因为1是基本数据类型,和int最匹配
*/
// list.remove(1);//删除的是[1]的对象
list.remove(new Integer(1));//删除的是对象
System.out.println(list);
}
@SuppressWarnings("all")
@Test
public void test2(){
//这里左边用List多态引用的目的是为了关注List接口方法
List list = new ArrayList();
list.add("张三");
list.add(0, "李四");
list.remove(1);
System.out.println(list);
}
@SuppressWarnings("all")
@Test
public void test1(){
//这里左边用List多态引用的目的是为了关注List接口方法
List list = new ArrayList();
list.add("张三");
list.add(0, "李四");
System.out.println(list);
}
}
List接口的实现类们
/*
*一、 List接口的实现类们:
* 1、Vector:动态数组
* 物理结构:数组
* 2、ArrayList:动态数组
* 物理结构:数组
* 3、Stack:栈,它是Vector的子类
* 物理结构:数组
* 4、LinkedList:双向链表
* 物理结构:链表
*
* 二、Vector和ArrayList的区别?(同时也是面试题)
* Vector:最早版本的动态数组(旧版),线程安全的(有线程同步的),不够后扩容为原来的2倍,初始容量:10,
* Vector支持的遍历集合的方式有:(1)foreach(2)Iterator(3)支持旧版的Enumeration迭代器
* ArrayList:相对Vector来说新一点(新版),线程不安全的(没有线程同步的),不够后扩容为原来的1.5倍,初始容量:10,
* ArrayList支持的遍历集合的方式有:(1)foreach(2)Iterator
*
* 2倍:造成空间浪费的可能性比较大
* 1.5倍:造成扩容的次数增大
*
* Vector和ArrayList的使用时,为了比较空间浪费,和扩容次数太多,如果能够预估大概的元素个数,那么可以用
* ArrayList(int initialCapacity)和Vector(int initialCapacity)直接初始化为一定容量的数组。
*
*
* StringBuffer和StringBuilder类似
*
* 三、Stack:栈
* 先进后出(FILO)或后进先出(LIFO:Last in first out)
* Stack是Vector的子类,比Vector多了几个方法,它的后进先出的特征,就是通过调用这几个方法实现的。
* (1)Object peek() :访问当前栈顶元素,但是不拿走栈顶元素
* (2)Object pop():弹出栈顶元素
* (3)Object push(Object item) :把元素压入栈顶,等价于add(item)
* 这里为了更形象化,单独设计了一个push。
*
* 四、LinkedList:双向链表(双向链表、队列、栈、双端队列、单向链表等各种数据结构的效果)
* 内部有一个结点的类型:
* class Node{
* Object data;
* Node previous;
* Node next;
* }
*
* class LinkedList{
* Node first;//记录第一个结点的地址
* Node last;//记录最后一个结点的地址
* }
* 空链表:if(first == null && last ==null)
* 有一个结点: first == last
* 第一个结点: first.previous = null
* 最后一个结点:last.next == null
*
* LinkedList可以被当做双向链表、栈、队列、双端队列等数据结构使用。
* 如何体现双向链表?
* (1)E getFirst()
* (2)E getLast()
* (3)boolean offerFirst(E e) :添加的第一个
* (4)boolean offerLast(E e) :添加到最后一个
* (5)int indexOf(Object o) :从first开始找
* (6)int lastIndexOf(Object o) :从last开始找
* (7) E get(int index)
* 先判断index是靠前还是靠后
*
* 如何体现栈?
* E peek()
* E pop()
* void push(E e)
*
* 如何体现队列?实现了Queue接口
* 队列:先进先出(FIFO)
* 抛出异常 返回特殊值
插入 add(e) offer(e)
移除 remove() poll()
检查 element() peek()
*
* 如何体现双端队列?JDK1.6才支持,实现了Deque(double ended queue(双端队列)的缩写)
* 下表总结了上述 12 种方法:
第一个元素(头部) 最后一个元素(尾部)
抛出异常 特殊值 抛出异常 特殊值
插入 addFirst(e) offerFirst(e) addLast(e) offerLast(e)
移除 removeFirst() pollFirst() removeLast() pollLast()
检查 getFirst() peekFirst() getLast() peekLast()
*/
@SuppressWarnings("all")
public class TestListImpl {
@Test
public void test5(){
LinkedList list = new LinkedList();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
System.out.println(list.poll());
System.out.println(list.poll());
System.out.println(list.poll());
System.out.println(list.poll());
}
@Test
public void test4(){
//用ArrayList,实现后进先出的效果
ArrayList list = new ArrayList();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
System.out.println(list.remove(list.size()-1));
System.out.println(list.remove(list.size()-1));
System.out.println(list.remove(list.size()-1));
System.out.println(list.remove(list.size()-1));
}
@Test
public void test3(){
Stack s = new Stack();
s.push("1");//push比add可读性更好,功能是一样的
s.push("2");
s.push("3");
s.push("4");
System.out.println(s.pop());
System.out.println(s.pop());
System.out.println(s.pop());
System.out.println(s.pop());
}
@Test
public void test2(){
Stack s = new Stack();
s.add("1");
s.add("2");
s.add("3");
s.add("4");
System.out.println(s.pop());
System.out.println(s.pop());
System.out.println(s.pop());
System.out.println(s.pop());
// System.out.println(s.pop());//java.util.EmptyStackException
}
@Test
public void test1(){
Stack s = new Stack();
s.add("1");
s.add("2");
s.add("3");
s.add("4");
System.out.println(s.peek());//4
System.out.println(s.peek());//4
System.out.println(s.peek());//4
}
}
集合Set子接口及其实现类们
/*
* Collection是根接口,没有提供任何直接实现的。它有一些更具体的子接口,例如:List和Set。
*
* 一、Set接口
* 1、Set系列的集合的元素是不能重复的。
* 2、Set的实现类们:HashSet、TreeSet、LinkedHashSet
* Set:如果按照元素的存储顺序来说,有一些是可以保证的,有一些是不能保证的。唯有LinkedHashSet可以保证元素添加的顺序。
* 如果按照元素的大小顺序来说,有一些是可以保证的,有一些是不能保证的。唯有TreeSet可以保证元素的大小顺序。
* 其中HashSet:既不能保证添加顺序,也不能保证大小顺序。是完全无序的。
*
* List:有序的,可重复的
* 有序的:前后顺序,可能是[下标]索引顺序,也可以能是链表的next,prev的引用顺序。
* 3、Set接口没有增加方法,都是从Collection接口中继承的。
*
* 4、HashSet和LinkedHashSet
* HashSet:完全无序
* LinkedHashSet:添加顺序
* LinkedHashSet是HashSet的子类,比HashSet多维护了添加的顺序。
* 当你既想要实现集合的元素的不可重复性,又想要保证元素的添加顺序,就选择使用LinkedHashSet。否则就用List系列或HashSet。
* LinkedHashSet干的事多了,效率低了。
*
* 5、HashSet和TreeSet
* HashSet:完全无序
* TreeSet:大小顺序
* 当你需要元素不可重复,又要给元素排大小时,就用TreeSet。
*
* 要用到TreeSet,一定要用java.lang.Comparable或java.util.Comparator
*
* 6、如何保证元素不可重复的?
* 换句话说,如何判断两个元素是重复的呢?
* HashSet和LinkedHashSet:
* ①先比较hash值,如果hash值不一样,说明一定不相同,
* ②如果hash值一样,再调用equals方法比较
*
* TreeSet:
* 按照元素的大小来决定是否相同元素。
*/
@SuppressWarnings("all")
public class TestSet {
@Test
public void test12(){
//存储到TreeSet的元素不会用它的hashCode和equals
//认为大小“相等”就是相同的元素
TreeSet set = new TreeSet(new Comparator(){
@Override
public int compare(Object o1, Object o2) {
Student s1 = (Student) o1;
Student s2 = (Student) o2;
return s1.getId() - s2.getId();
}});
Student s1 = new Student(3,"张三");
Student s2 = new Student(1,"李四");
Student s3 = new Student(2,"王五");
set.add(s1);
set.add(s2);
set.add(s3);
System.out.println(set);
}
@Test
public void test11(){
//存储到HashSet的元素会用它的hashCode和equals
HashSet set = new HashSet();
Student s1 = new Student(3,"张三");
Student s2 = new Student(1,"李四");
Student s3 = new Student(2,"王五");
set.add(s1);
set.add(s2);
set.add(s3);
System.out.println(set);
System.out.println(s1.hashCode());
System.out.println(s2.hashCode());
System.out.println(s3.hashCode());
}
@Test
public void test10(){
//用匿名内部类实现了Comparator接口
TreeSet set = new TreeSet(new Comparator(){
@Override
public int compare(Object o1, Object o2) {
Student s1 = (Student) o1;
Student s2 = (Student) o2;
return s1.getId() - s2.getId();
}});
set.add(new Student(3,"张三"));
set.add(new Student(1,"李四"));
set.add(new Student(2,"王五"));
System.out.println(set);
}
@Test
public void test9(){
TreeSet set = new TreeSet();
//这里因为Object类型没有实现了java.lang.Comparable接口,所以不可以添加到TreeSet中
set.add(new Object());
}
@Test
public void test8(){
TreeSet set = new TreeSet();
//这里因为String类型实现了java.lang.Comparable接口,所以可以添加到TreeSet中
set.add("hello");
set.add("world");
set.add("java");
set.add("chailinyan");
}
//顺序:TreeSet大小顺序
@Test
public void test7(){
TreeSet set = new TreeSet();
set.add("hello");
set.add("world");
set.add("java");
set.add("chailinyan");
System.out.println(set);//[chailinyan, hello, java, world]
}
//顺序:LinkedHashSet添加顺序
@Test
public void test6(){
LinkedHashSet set = new LinkedHashSet();
set.add("hello");
set.add("world");
set.add("java");
set.add("chailinyan");
System.out.println(set);//[hello, world, java, chailinyan]
}
//顺序:HashSet无序
@Test
public void test5(){
HashSet set = new HashSet();
set.add("hello");
set.add("world");
set.add("java");
set.add("chailinyan");
System.out.println(set);//[world, java, chailinyan, hello]
}
//顺序:HashSet无序
@Test
public void test4(){
HashSet set = new HashSet();
set.add("张三");
set.add("李四");
set.add("王五");
set.add("柴林燕");
System.out.println(set);//[李四, 柴林燕, 张三, 王五]
}
//不可重复
@Test
public void test2(){
LinkedHashSet set = new LinkedHashSet();
set.add("张三");
set.add("张三");
set.add("李四");
System.out.println(set);
}
//不可重复
@Test
public void test3(){
TreeSet set = new TreeSet();
set.add("张三");
set.add("张三");
set.add("李四");
System.out.println(set);
}
//不可重复
@Test
public void test1(){
HashSet set = new HashSet();
set.add("张三");
set.add("张三");
set.add("李四");
System.out.println(set);
}
}
class Student{
private int id;
private String name;
public Student(int id, String name) {
super();
this.id = id;
this.name = name;
}
@Override
public String toString() {
return "Student [id=" + id + ", name=" + name + "]";
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public int hashCode() {
System.out.println("Student的hashCode方法");
/*final int prime = 31;
int result = 1;
result = prime * result + id;
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;*/
return 1111;
}
@Override
public boolean equals(Object obj) {
System.out.println("Student的equals方法");
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Student other = (Student) obj;
if (id != other.id)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
}