Java集合(一)

最新推荐文章于 2023-03-08 09:44:17 发布

kewu8971

最新推荐文章于 2023-03-08 09:44:17 发布

阅读量102

点赞数

分类专栏： JavaSe 文章标签： java

本文链接：https://blog.csdn.net/kewu8971/article/details/107660301

版权

JavaSe 专栏收录该内容

33 篇文章 0 订阅

订阅专栏

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