集合（一）Collection、List集合、Set集合

最新推荐文章于 2024-11-04 08:40:38 发布

原创最新推荐文章于 2024-11-04 08:40:38 发布 · 2.1k 阅读

CC 4.0 BY-SA版权

本文详细介绍了Java集合框架的基本概念，包括集合与数组的区别、Collection接口及其子接口List和Set的特点与用法。深入探讨了各种集合类如ArrayList、LinkedList、HashSet和TreeSet的功能与应用场景，并提供了丰富的示例代码。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

集合框架

这就是集合框架的构成。由于数据结构的不同，有不同的集合，也叫容器。

为了方便对多个对象的操作，就对对象进行存储，集合就是存储对象最常用的一种方式。

数组和集合的区别：

1）数组：长度是固定的，可存储基本数据类型

2）集合：长度是可变的，存储的事对象，不可以存储基本数据类型

Collection

Collection接口是集合体系不断向上抽取共性内容而来的。

其下有两个子接口：List（列表），Set（集）。

Collection

|--List//元素是有序的，元素可以重复。因为该集合体系有索引。

|--Set//元素是无序的，元素不可以重复。

一、Collection接口中常见的操作

import java.util.ArrayList;
import java.util.Collection;

public class CollectionDemo {

	public static void main(String[] args) {
		
       Collection coll_1=new ArrayList();
       Collection coll_2=new ArrayList();
       coll_1.add("abc1");
       coll_1.add("abc2");
       coll_1.remove("abc1");
       coll_2.add("abc1");
       coll_2.add("abc2");
       coll_2.retainAll(coll_1);
       coll_2.size();
       System.out.print(coll_2);
	}

}

如示例，常见操作：

1、添加元素

add(Objectobj); //add方法的参数类型是Object。以便于接收任意类型对象。

2、删除元素

remove(Object obj);

removeAll(另一集合);//将两个集合中相同的元素从调用集合中删除

clear();//清空集合

3、判断元素

contains(Object obj);//判断是否存在obj这个元素

isEmpty();//是否为空

4、获取个数，集合长度

size();

5、取交集

retainAll(另一集合);//调用者只保留两集合的共性元素。

注：集合中存储的都是对象的引用（地址）。

二、取出集合中元素的一种方式：迭代

1、概述

将取出这个集合元素动作封装成一个对象来描述。就把取出方式定义在集合的内部，这样取出方式就可以直接访问集合内部的元素。那么取出方式就被定义成了内部类。这些内部类都符合一个规则Iterator，通过一个对外提供的方法：iterator();，来获取集合的取出对象。

因为Collection中有iterator方法，所以每一个子类集合对象都具备迭代器。
2、迭代常见操作

hasNext();//有下一个元素，返回真

next();//取出下一个元素

remove();//移除

用法参考如下：

第一种打印方式：

for(Iterator iter = a.iterator();iter.hasNext(); )

{

System.out.println(iter.next());

}

第二种打印方式：

Iteratoriter = a.iterator();

while(iter.hasNext())

{

System.out.println(iter.next());

}

示例：

ArrayList a=new  ArrayList();//创建一个集合
 Iterator it=a.iterator();//获取一个迭代器，用于取出集合中的元素。
while(it.hasNext()) 
{System.out.print(it.next());}

注意：迭代器的next方法返回值类型是Object，所以要记得类型转换。

List集合

一、List组成

List：

|--ArrayList：底层的数据结构使用的是数组结构。特点：查询速度很快。但是增删稍慢。线程不同步。

|--LinkedList：底层使用的是链表数据结构。特点：增删速度很快，查询稍慢。

|--Vector：底层是数组数据结构。线程同步。被ArrayList替代了。

二、List特有方法

凡是可以操作角标的方法都是该体系特有的方法。

1、增

boolean add(index,element);//指定位置添加元素

Boolean addAll(index,Collection);//在指定位置增加给定集合中的所有元素，若省略位置参数，则在当前集合的后面依次添加元素

2、删

Boolean remove(index);//删除指定位置的元素

3、改

set(index,element);//修改指定位置的元素。

4、查

get(index);//通过角标获取元素

subList(from,to);//获取部分对象元素

5、其他

listIterator();//List特有的迭代器

indexOf(obj);//获取元素第一次出现的位置，如果没有则返回-1

注：List集合判断元素是否相同，移除等操作，依据的是元素的equals方法。

三、ListIterator

Iterator方法是有限的，只能对元素进行判断，取出，删除的操作。如果想要其他的操作，如添加、修改等，就需要使用其子接口：ListIterrator。该接口只能通过List集合的ListIterator方法获取。

ListIterator特有的方法

add(obj);//增加

set(obj);//修改为obj

hasPrevious();//判断前面有没有元素

previous();//取前一个元素

用法示例：

import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;

public class ListIteratorDemo {

	public static void main(String[] args) {
		List list=new ArrayList();
		list.add("abc1");
		list.add("abc2");
		list.add("abc3");
		ListIterator it=list.listIterator(1);
		while(it.hasNext()) {
			Object obj=it.next();
			if(obj.equals("abc2"))
				it.set("abc4");
		}
	}

}

四、枚举Enumeration

枚举就是Vector特有的取出方式。Vector有三种取出方式。

其实枚举和迭代是一样的。因为枚举的名称以及方法的名称都过长。所以被迭代器取代了。

特有方法：

addElement(obj);//添加元素，相当于add(obj);

Enumerationelements();//Vector特有取出方式(枚举)

hasMoreElements();//相当于Iterator的hasNext()方法

nextElements();//相当于Iterator的next()方法

用法示例：

Vector v=new Vector();
	for(Enumeration e=v.elements();e.hasMoreElements();)
{
	System.out.println(e.nextElements());
}

五、LinkedList特有方法

1、增

addFirst();

addLast();

2、获取

//获取元素，但不删除元素。如果集合中没有元素，会出现NoSuchElementException

getFirst();

getLast();

3、删

//获取元素，并删除元素。如果集合中没有元素，会出现NoSuchElementException

removeFirst();

removeLast();

在JDK1.6以后，出现了替代方法。

1、增

offFirst();

offLast();

2、获取

//获取元素，但是不删除。如果集合中没有元素，会返回null。

peekFirst();

peekLast();

3、删

//获取元素，并删除元素。如果集合中没有元素，会返回null。

pollFirst();

pollLast();

import java.util.LinkedList;

/*需求：请使用一个LinkedList模拟一个堆栈或者队列数据结构
 * 堆栈特点：先进后出
 * 队列特点：先进先出
 * 以下模拟堆栈
 */
public class LinkedListDemo {

	public static void main(String[] args) {
		LinkedList l=new LinkedList();
        l.addFirst("abc");
        l.addFirst("def");
        l.addFirst("ghj");
        while(!l.isEmpty())
        System.out.println(l.removeFirst());
	}

}

Set集合

一、概述

Set：元素是无序（存入和取出的顺序不一定一致），元素不可以重复。

|--HashSet：底层数据结构是哈希表。线程不同步。保证元素唯一性的原理：判断元素的hashCode值是否相同。如果相同，还会继续判断元素的equals方法，是否为true。

|--TreeSet：可以对Set集合中的元素进行排序。默认按照字母的自然排序。底层数据结构是二叉树。

二、HashSet

HashSet：线程不安全，存取速度快。

可以通过元素的两个方法，hashCode和equals来完成保证元素唯一性。如果元素的HashCode值相同，才会判断equals是否为true。如果元素的hashCode值不同，不会调用equals。

示例：

package cn.itcast.beans;

public class Person  {
private String name;
 private int age;
 public int hashCode() {
	return this.name.hashCode() +age*27;
 }
 public boolean equals(Object obj) {
	 Person p=(Person)obj;
	 return this.name.equals(p.name)&&this.age==p.age;
 }
public Person(String name, int age) {
	this.name = name;
	this.age = age;
}
public String getName() {
	return name;
}
public void setName(String name) {
	this.name = name;
}
public int getAge() {
	return age;
}
public void setAge(int age) {
	this.age = age;
}
}

package cn.itcast.hashsetdemo;

import java.util.HashSet;
import java.util.Iterator;

import cn.itcast.beans.Person;

public class HashSetDemo {

	public static void main(String[] args) {
		HashSet hs=new HashSet();
		hs.add(new Person("李四",23));
		hs.add(new Person("张三",24));
		hs.add(new Person("王五",25));
		hs.add(new Person("李四",24));
		Iterator it=hs.iterator();
		while(it.hasNext()) {
			Person p=(Person)it.next();
			System.out.println(p.getName()+":"+p.getAge());
		}
	}

三、TreeSet

Tree排序的两种方式:

1）第一种排序方式：自然排序

让元素自身具备比较性。元素需要实现Comparable接口，覆盖compareTo方法。这种方式也被称为元素的自然顺序，或者叫做默认顺序。

示例：

public class Person implements Comparable {
private String name;
 private int age;
 public int hashCode() {
	return this.name.hashCode() +age*27;
 }
 public boolean equals(Object obj) {
	 Person p=(Person)obj;
	 return this.name.equals(p.name)&&this.age==p.age;
 }
public Person(String name, int age) {
	this.name = name;
	this.age = age;
}
public String getName() {
	return name;
}
public void setName(String name) {
	this.name = name;
}
public int getAge() {
	return age;
}
public void setAge(int age) {
	this.age = age;
}


@Override
public int compareTo(Object o) {
	Person p=(Person)o;
	int temp=this.age-p.age;
	return temp==0?this.name.compareTo(p.name):temp;
}

}

package cn.itcast.treesetdemo;
import java.util.Iterator;
import java.util.TreeSet;
import cn.itcast.beans.Person;
public class TreeSetDemo {
	public static void main(String[] args) {
		TreeSet hs=new TreeSet();
		hs.add(new Person("李四",23));
		hs.add(new Person("张三",24));
		hs.add(new Person("王五",25));
		hs.add(new Person("李四",23));
		Iterator it=hs.iterator();
		while(it.hasNext()) {
			Person p=(Person)it.next();
			System.out.println(p.getName()+":"+p.getAge());
		}
	}
}

2）第二种方式：比较器

当元素自身不具备比较性时，或者具备的比较性不是所需要的。这时就需要让集合自身具备比较性。

在集合初始化时，就有了比较方式。定义一个比较器，将比较器对象作为参数传递给TreeSet集合的构造函数。

比较器构造方式：定义一个类，实现Comparator接口，覆盖compare方法。

当两种排序都存在时，以比较器为主。

示例：

package cn.itcast.beans;

public class Person {
private String name;
 private int age;
 public int hashCode() {
	return this.name.hashCode() +age*27;
 }
 public boolean equals(Object obj) {
	 Person p=(Person)obj;
	 return this.name.equals(p.name)&&this.age==p.age;
 }
public Person(String name, int age) {
	this.name = name;
	this.age = age;
}
public String getName() {
	return name;
}
public void setName(String name) {
	this.name = name;
}
public int getAge() {
	return age;
}
public void setAge(int age) {
	this.age = age;
}
}

package cn.itcast.treesetdemo2;
import java.util.Comparator;
import cn.itcast.beans.Person;
public class comparetorByName implements Comparator {
public int compare(Object o1,Object o2) {
	Person p1=(Person)o1;
	Person p2=(Person)o2;
	int temp=p1.getName().compareTo(p2.getName());
	return temp==0?p1.getAge()-p2.getAge():temp;
}
}

package cn.itcast.treesetdemo2;
import java.util.Iterator;
import java.util.TreeSet;
import cn.itcast.beans.Person;
public class TreeSetDemo2 {
	public static void main(String[] args) {
		TreeSet hs=new TreeSet(new comparetorByName());
			hs.add(new Person("李四",23));
			hs.add(new Person("张三",24));
			hs.add(new Person("王五",25));
			hs.add(new Person("李四",23));
			Iterator it=hs.iterator();
			while(it.hasNext()) {
				Person p=(Person)it.next();
				System.out.println(p.getName()+":"+p.getAge());
			}
		}
	}