集合

最新推荐文章于 2022-10-06 20:55:25 发布

阿毛阿

最新推荐文章于 2022-10-06 20:55:25 发布

阅读量141

点赞数

分类专栏： JavaSE

JavaSE 专栏收录该内容

32 篇文章 1 订阅

订阅专栏

一、Collection接口

1、添加

boolean add(E e)

boolean addAll(Collection<? extends E> c)

2、删除

void clear()

boolean remove(E e)

boolean removeAll(Collection<?> c)

3、获取长度

int size()

4、判断

boolean isEmpty()

boolean contains(E e)

boolean containsAll(Collection<?> c)

5、将集合转成数组

toArray()

toArray([])

6、取出集合元素

Iterator<E> iterator() 获取集合中元素有迭代功能的迭代器对象

迭代：取出元素的一种方式

迭代器：具备着迭代功能的对象，不需要new，直接通过iterator()方法获取即可

Iterator<E>接口

boolean hasNext() 若仍有元素可以迭代，则返回true

E next() 返回迭代的下一个元素

void remove() 从迭代器指向的collection中移除迭代器返回的最后一个元素

Collection coll = new Vector();
		for(Iterator it = coll.iterator();it.hasNext();) {
			System.out.println(it.next());
		}

二、List接口

1、List：有序(存入和取出的顺序一致)，有索引，允许重复元素。

2、List中特有的方法：围绕索引定义的。

唯一支持“增删改查”的集合体系：

void add(int index,E element)

E remove(int index) 返回以前在指定位置的元素

E get(int index)

int get(int index)

int indexOf(E element) 若不包含则返回-1

！！！增加、删除集合元素后，集合长度会发生变化(下标改变)

List集合特有的取出方式(利用下标进行遍历)

List list = new ArrayList();
		for(int i=0;i<list.size();i++) {
			System.out.println(list.get(i));
		}

！！！迭代器与集合这两个对象同时对各自元素进行操作时，会导致迭代的不确定性。

解决方法：使用迭代器的方法操作元素

3、ListIterator():List集合特有的迭代器，可以实现在迭代过程中的增删改查

void add(E e)

E previous() 返回集合中的前一个元素

boolean hasNext()

boolean hasPrevious()

void set(E e) 用指定元素替换next()或previous()返回的最后一个元素

4、List集合的具体子类：根据数据存储的方式不同分类

Vector:数组，长度可变(不断new新数组，并将原数组元素复制到新数组)。线程同步。

ArrayList:数组，长度可变。增删慢，查询快(数组空间连续)。线程不同步。

LinkedList:链表结构。增删快，查询慢(链表结构)。线程不同步。

5、从ArrayList中去除重复元素

法一：双重循环

                for(int i=0;i<list.size()-1;i++) {
			for(int j=i;j<list.size();j++) {
				if(list.get(i).equals(list.get(j))) {
					break;
				}			
			}
			System.out.println(list.get(i));
		}

法二：往新容器放入唯一元素

                List temp = new ArrayList();
		for(int i=0;i<list.size();i++) {
			Object o = list.get(i);
			if(!temp.contains(o)) {
				temp.add(o);
			}
		}
		for(int i=0;i<temp.size();i++) {
			System.out.println(temp.get(i));
		}

6、从ArrayList中去除重复的自定义元素：修改自定义元素的equals方法

7、LinkedList

特殊方法： xxxFirst() xxxLast()

addFirst(E e) 后加入的元素放在集合头部

addLast(E e)

getFirst(E e)

getLast(E e)

遍历方法：

                LinkedList link = new LinkedList();
		while(!link.isEmpty()) {
			System.out.println(link.removeFirst());
		}

8、LinkedList实现队列结构：

       class Queue<E> {
		private LinkedList<E> link;
		
		public Queue() {
			link = new LinkedList<E>();
		}
		
		public void add(E element) {
			link.add(element);
		}
		
		public E get() {
			E element = link.removeLast();
			return element;
		}
		
		public boolean isNull() {
			if(link.isEmpty()) {
				return true;
			}else {
				return false;
			}
		}
	}

三、Set接口

1、Set:不允许重复元素，和collection相同，取出方式只有迭代器一种。

2、HashSet:不保证存入和取出顺序，哈希表结构（散列表结构）。

3、Hash算法：根据元素信息，算出下标位置(比ArrayList更快)。

哈希冲突：冲突后对元素进一步判断，判断元素的内容，用equals方法。

4、哈希表：用于存储元素和哈希值对应关系的容器

hashCode():返回该对象的哈希码值。该方法默认调用的是本地的算法，即操作系统的算法。

5、哈希表判断元素位置是否相同：依据hashCode()方法，如果哈希重复，则判断元素的equals方法。

6、哈希表存储自定义对象：覆盖hashCode()方法，根据对象自身的特点定义哈希值，重写equals方法。

        public int hashCode() {
		final int NUMBER = 31;
		return name.hashCode() + age*NUMBER; 
	}
	
	public boolean equals(Object obj) {
		if(this == obj) {
			return true;
		}
		if(!(obj instanceof Student)) {
			throw new ClassCastException("类型错误");
		}
		return 自定义判断条件;
	}

7、总结：自定义哈希表如何保证唯一性？

元素必须覆盖hashCode()和equals()方法。

覆盖hashCode()方法是为了根据元素自身特点确定哈希值，

覆盖equals()方法是为了解决哈希冲突。

*eclipse中可以通过右键 -> Source -> Generic hashCode() and equals() 来覆盖以上两个方法。

8、LinkedHashSet：具有可预知迭代顺序的Set接口的哈希表和链表实现。有序，不可重复。

9、TreeSet：不保证有序，可以对元素进行排序。线程不同步。

10、Comparable接口：此接口强行对实现它的每个类的对象进行整体排序，这种排序被称为类的自然排序。

*存入TreeSet的对象必须实现Comparable接口。

11、TreeSet用的比较算法：二叉树结构排序，其中用到了折半比较。

12、总结：如何保证TreeSet中元素的唯一性？

参考的comparaTo()的返回值，如果是0，则表示该元素重复，不存。

13、Comparator比较器：需求中有这样一种情况，元素具备的比较功能不是所需要的，需要按照自定义的排序方式，对元素进行排序。这时就只能使用集合的排序方式，即使用集合的比较器。

compare(Object o1,Object o2)

equals(Object obj) 判断两个比较器是否相同

14、集合名称阅读技巧：前缀名是数据结构名，后缀名是所属体系名

*对于数组的遍历，如果不操作其角标，可以使用foreach循环；如果需要操作角标，则使用传统for循环。

*若在foreach循环内修改集合元素，会报并发异常。

四、Enumeration枚举

具备枚举取出方式的容器只有Vector。

                Vector v = new Vector();
		Enumeration en = v.elements();
		while(en.hasMoreElements()) {
			System.out.println("enumeration:"+en.nextElement());
		}