Java集合(一)

集合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;
	}
	
}

 

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值