黑马程序员——Java基础—集合(Set、List)

最新推荐文章于 2021-11-25 10:36:08 发布

迦略圣军

最新推荐文章于 2021-11-25 10:36:08 发布

阅读量434

点赞数

本文链接：https://blog.csdn.net/qq_22909255/article/details/42558491

版权

Java基础之集合

集合框架（集合类Collection）

为什么出现集合类？因为面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，就对对象进行存储，集合就是存储对象最常用的一种方式。

数组和集合类同是容器，有何不同？数组虽然也可以存储对象，但长度是固定的，集合长度是可变的。数组只能存储指定类型的对象，因为创建数组的时候类型就确定了，而集合可以存储任意类型的对象。数组中可以存储基本数据类型，集合只能存储对象，不可以存储基本数据类型的值。

集合类的特点：集合只用于存储对象，集合长度是可变的，集合可以存储不同类型的对象。

集合是一个存储对象的容器，容器分为很多种，容器进行向上抽取出来的共性内容产生了一个体系称之为集合框架。集合框架出现了很多的容器，因为每一个容器对数据的存储方式都不同，这个存储方式称之为：数据结构。

Collection 是层次结构中的根接口。Collection 表示一组对象，这些对象也称为 collection 的元素。

Collection在java.util包里。

使用Collection接口的子类创建一个集合容器。示例：ArrayList al = new ArrayList(); al.add("java")，

添加元素的方法：boolean add(Object obj)。

add方法的参数类型是Object，以便于接收任意类型的对象，集合中存储的都是对象的引用(地址值)。

获取集合中元素的个数(长度)的方法：al.size() 。

删除指定的元素：boolean remove(元素)，al.remove("java")，

清空集合：void clear()，al.clear()。

判断集合中是否包含指定的元素：boolean contains(元素)，al.contains("java") 。

判断集合是否为空：boolean isEmpty()，al.isEmpty()。

Collection集合中的方法演示：

import java.util.ArrayList;
import java.util.Collection;
class CollectionDemo
{
	public static void main(String[] args) 
	{
		Collection coll = new ArrayList();

		show(coll);
	}
	public static void show(Collection coll)
	{
		//添加元素
		coll.add("abc1");
		coll.add("abc2");
		coll.add("abc3");
		System.out.println(coll);

		//获取集合中元素的个数(长度)。
		System.out.println(coll.size());

		//删除元素 remove
		coll.remove("abc2");

		coll.clear(); //清空集合。
		System.out.println(coll);

		boolean b = coll.isEmpty();  //判断集合是否为空

		//判断元素 contains
		boolean b = coll.contains("abc5");
		System.out.println(b);
	}
}

取交集：boolean retainAll(对象)，示例：a1.retainAll(a2)，a1只取与a2的交集部分。

boolean addAll(Collection coll)：将指定集合中的元素全添加到调用集合中。示例：c1.addAll(c2)，将c2中的元素添加到c1中。

boolean removeAll(Collection coll)：将两个集合中的相同元素从调用removeAll的集合中删除。示例：c1.removeAll(c2)，将c1和c2中相同的元素从c1中删除。

boolean containsAll(Collection coll):判断调用containsAll方法的集合中是否包含指定的集合中所有的元素。示例：c1.containsAll(c2)，判断c1中是否包含c2中所有的元素。

bollean retainAll(Collection coll):取交集，调用retainAll方法的集合中保留和指定的集合相同的元素，删除不相同的元素，和removeAll功能相反。示例：c1.retainAll(c2); c1中只取和c2中交集的部分。

Collection集合中的方法演示：

<pre name="code" class="html">class  CollectionDemo
{
	public static void main(String[] args) 
	{		
		method();
	}
	public static void method()
	{
		ArrayList al1 = new ArrayList();
		al1.add("java01");
		al1.add("java02");
		al1.add("java03");
		al1.add("java04");

		ArrayList al2 = new ArrayList();
		al2.add("java03");
		al2.add("java04");
		al2.add("java05");
		al2.add("java06");
		
		al1.retainAll(al2);//取交集，al1中只会保留和al2中相同的元素。
		al1.removeAll(al2);  //将两个集合中的相同元素从调用removeAll的集合中删除。
		al1.containsAll(al2); //判断调用containsAll方法的集合中是否包含指定的集合中所有的元素

		sop("al1:"+al1);
		sop("al2:"+al2);
	}
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

迭代器就是取出集合中元素的方式。把取出的方式定义在集合的内部，就可以直接访问集合内的元素，那么取出方式就成了内部类。而每一个容器的数据结构不同，因此取出的动作也不同，但都有共性内容：判断和取出。那么可以将这些共性内容抽取得到了Iterator接口。ArrayList al = new ArrayList(); Iterator it = al.iterator();获取迭代器用于取出集合中的元素。

迭代器代码示例：

import java.util.Collection;
import java.util.ArrayList;
import java.util.Iterator;
class  IteratorDemo
{
	public static void main(String[] args) 
	{
		Collection coll = new ArrayList();
		
		coll.add("abc2");
		coll.add("abc3");
		coll.add("abc4");
		coll.add("abc5");
		System.out.println(coll);
	
		//使用Collection中的iterator()方法，调用集合中的迭代器方法，为了获取集合中的迭代器对象
		Iterator it = coll.iterator(); 
		while(it.hasNext())
		{
			System.out.println(it.next());
		}
	
		for (Iterator it = coll.iterator(); it.hasNext(); )//在开发中使用for循环，更优化内存。
		{
			System.out.println(it.next());
		}
	}
}

Collection接口下面有两个最常用的子接口List和Set。List元素是有序的(存入和取出的顺序一致)，元素可以重复，因为

该集合体系有索引(角标)。Set元素是无序的，元素不可以重复。

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

增：

add(index,element)：在指定角标位置插入一个元素。

addAll(index,Collection)：在指定的角标位置插入一个集合。

删：

remove(index)：删除指定位置的元素。

改：

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

查：

get(index)：通过角标获取元素。利用该方法遍历可以获取到所有元素。

indexOf(element)：通过元素获取该元素所在的角标位置，如果列表不包含此元素，则返回 -1。

lastindexOf(element)：从后向前查找元素所在的位置，如果列表不包含此元素，则返回 -1。

subList(from,to)：从包含from到不包含to获取子列表。 listIterator()：List集合的迭代器。
List集合特有方法演示：

import java.util.*;
class  ListDemo
{
	public static void main(String[] args) 
	{
		ArrayList al = new ArrayList();
		al.add("java01");
		al.add("java02");
		al.add("java03");
		al.add("java04");
		al.add("java05");
		sop(al);

		al.add(1,"java09");//在指定角标位置添加一个元素
		sop(al);
		
		al.remove(2);//删除指定位置的元素
		sop(al);

		al.set(1,"java07");//修改指定位置的元素
		sop(al);
		
		sop(al.get(3));//通过角标获取元素

		sop(al.subList(1,4));//从包含from到不包含to获取子列表

		for(int x=0; x<al.size(); x++)//获取所有元素，将所有角标遍历一遍。
		{
			sop("al("+x+")="+al.get(x));
		}

		Iterator it = al.iterator();//调用集合中的迭代器方法，获取集合中的迭代器对象
		while(it.hasNext())
		{
			sop(it.next());
		}

		sop("Index="+al.indexOf("java04"));//通过元素获取该元素所在的角标位置
	}
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

List集合特有的迭代器ListIterator是Iterator的子接口。List集合通过equals方法判断元素是否相同。

在迭代时不可以通过集合对象的方法操作集合中的元素，否则会发生ConcurrentModificationException 异常。所以在迭

代时只能用迭代器的方法操作元素，但Iterator方法是有限的，只能对元素进行判断、取出、删除的操作。如果想要其他

的操作如添加、修改等，就需要使用其子接口ListIterator，该接口只能通过List集合的listIterator方法获取。

枚举是Vector特有的取出方式和迭代器是一样的，但因为名称和方法名称都过长，所以被迭代器取代了。

列表迭代器演示：

import java.util.*;
class ListDemo 
{
	public static void main(String[] args) 
	{
		ArrayList al = new ArrayList();
		//添加元素
		al.add("java01");
		al.add("java02");
		al.add("java03");

		sop(al);
		ListIterator li = al.listIterator();

		while(li.hasNext())
		{
			Object obj = li.next();

			if(obj.equals("java02"))
				li.set("java006");
		}
	}	
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

List集合中三个常见的子类对象：ArrayList、LinkedList、Vector

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

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

3.Vector：底层使用的是数组数据结构。增删查询速度都很慢，线程同步。已经被ArrayList替代了，不使用了。

Vector集合代码示例：

class VectorDemo 
{
	public static void main(String[] args) 
	{
		Vector v = new Vector();

		v.add("java01");
		v.add("java02");
		v.add("java03");
		v.add("java04");

		Enumeration en = v.elements();

		while(en.hasMoreElements())
		{
			System.out.println(en.nextElement());
		}
	}
}

LinkedList特有的方法：

addFirst(); addLast(); getFirst();getLast(); removeFirst();removeLast();

在JDK1.6出现了替代的方法：

offerFirst();offerLast()：添加到第一位，添加到最后一位。

peekFirst();peekLast()：获取(First/Last)元素,如果集合中没有元素返回null。

pollFirst();pollLast()：获取并删除(First/Last )元素,如果集合中没有元素返回null。

LinkedList特有的方法演示：

class LinkedListDemo 
{
	public static void main(String[] args) 
	{
		LinkedList link = new LinkedList();

		link.addLast("java01");
		link.addLast("java02");
		link.addLast("java03");
		link.addLast("java04");

		sop(link); //打印原集合。
		sop(link.getFirst()); //获取第一个元素。
		sop(link.getLast()); //获取最后一个元素。
		sop(link.removeFirst()); //获取并删除第一个元素。
		sop(link.removeLast()); //获取并删除最后一个元素。

		sop("size="+link.size());

		while(!link.isEmpty()) //LinkedList独创的取出元素方式。
		{
			sop(link.removeLast());
		}
	}
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

ArrayList练习：将自定义对象作为元素存入到ArrayList集合中，并去除重复元素。例如：存入人对象，姓名和年龄相同则视为重复元素。代码示例：

import java.util.*;
class Person   //描述人对象，将数据封装进人对象。
{
	private String name;
	private int age;

	Person(String name,int age)
	{
		this.name = name;
		this.age = age;
	}
	public boolean equals(Object obj)  //重写Object的equals方法。
	{
		if(!(obj instanceof Person))
			return false;
		Person p =(Person)obj;

		return this.name.equals(p.name) && this.age == p.age;
	}
	public String getName()
	{
		return name;
	}
	public int getAge()
	{
		return age;
	}
}
class  ArrayListTest1
{
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
	public static void main(String[] args) 
	{
		ArrayList al = new ArrayList();  //定义容器存储人对象

		al.add(new Person("lisi01",20));
		al.add(new Person("lisi01",20));
		al.add(new Person("lisi02",18));
		al.add(new Person("lisi03",22));
		al.add(new Person("lisi03",22));
		al.add(new Person("lisi04",19));
		
		al = singleElement(al);

		Iterator it = al.iterator();
		while(it.hasNext())
		{
			Person p = (Person)it.next();   //取出人对象。
			sop(p.getName()+"::"+p.getAge());
		}
	}

	public static ArrayList singleElement(ArrayList al)
	{
		ArrayList newal = new ArrayList();//定义一个新的集合

		ListIterator it = al.listIterator();

		while(it.hasNext())//迭代原集合中的元素
		{
			Object obj = it.next();

			if(!newal.contains(obj))//如果新集合中没有原集合中的元素。
				newal.add(obj); //就将元素存到新集合中。
		}
		return newal;
	}
}

Set接口里的方法和Collection中的方法是一致的。Set元素是无序的，元素不可以重复。常见的子类对象有HashSet和TreeSet。

HashSet：底层使用的是哈希表数据结构。HashSet集合通过元素的两个方法hashCode和equals，来保证元素的唯一性。如果元素的hashCode值相同，则判断equals是否为true。如果元素的hashCode值不同，不会调用equals 。先判断hashCode值，如果值相同则会进行比较，如果值不同则不会进行比较。在描述对象的时候，如果该对象要被存到集合中，通常情况都要重写hashCode和equals方法。

练习：往HashSet集合中存入自定义的Person对象，如果姓名和年龄相同视为重复元素。代码示例：

import java.util.*;
class Person
{
	private String name;
	private int age;

	Person(String name,int age)
	{
		this.name = name;
		this.age = age;
	}
	public int hashCode() //重写hashCode方法，算出哈希值。
	{
		return name.hashCode() + age*26;
	}
	public boolean equals(Object obj) //重写equals方法，比较元素的内容是否相同。
	{
		if(!(obj instanceof Person))
			return false;
		Person p = (Person)obj;
		return this.name.equals(p.name) && this.age == p.age;
	}
	public String getName()
	{
		return name;
	}
	public int getAge()
	{
		return age;
	}
}
class  HashSetDemo
{
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
	public static void main(String[] args) 
	{
		HashSet sh = new HashSet();

		sh.add(new Person("xiaoyu01",20));
		sh.add(new Person("xiaoyu02",23));
		sh.add(new Person("xiaoyu03",22));
		sh.add(new Person("xiaoyu02",23));
		sh.add(new Person("xiaoyu03",22));

		Iterator it = sh.iterator();
		while(it.hasNext())
		{
			Person p = (Person)it.next();
			sop(p.getName()+"::"+p.getAge());
		}
	}
}

HashSet集合对于判断元素是否存在和删除元素的操作，是依靠元素的hashCode和equals方法实现的。

TreeSet：底层数据结构是二叉树。可以对Set集合中的元素进行排序，通过compareTo方法return 0，保证元素的唯一性。

TreeSet的第一种排序方式：让元素自身具备比较性，让元素实现Comparable接口，覆盖compareTo方法，这种排序方式称为元素的自然顺序，或者默认顺序。排序时当主要条件相同时要判断一下次要条件。

练习：往TreeSet集合中存入自定义的Student对象，按照学生的年龄进行排序。代码示例：

import java.util.*;
class Student implements Comparable //该接口强制让学生具有比较性
{
	private String name;
	private int age;
	Student(String name,int age)
	{
		this.name = name;
		this.age = age;
	}
	public int compareTo(Object obj) //重写Comparable接口中的compareTo方法，定义要比较的属性
	{
		if(!(obj instanceof Student))//如果obj不是学生类型的则抛出异常
			throw new RuntimeException("此对象错误");
		Student s = (Student)obj; //如果是学生类型的则向下转型

		if(this.age > s.age)
			return 1;
		if(this.age == s.age) //如果两个对象的年龄相同则再比较姓名是否相同
		{
			return this.name.compareTo(s.name);
		}
		return -1;
	}
	public String getName()
	{
		return name;
	}
	public int getAge()
	{
		return age;
	}
}
class  TreeSetDemo
{
	public static void main(String[] args) 
	{
		TreeSet ts = new TreeSet();

		ts.add(new Student("lisi05",18));
		ts.add(new Student("lisi08",19));
		ts.add(new Student("lisi03",20));
		ts.add(new Student("lisi01",18));

		Iterator it = ts.iterator();
		while(it.hasNext())
		{
			Student st = (Student)it.next();
			System.out.println(st.getName()+"::"+st.getAge());
		}
	}
}

TreeSet的第二种排序方式：当元素自身不具备比较性，或者具备的比较性不是所需要的时，就需要让集合自身具备比较性，自定义一个比较器，将比较器对象作为参数传递给TreeSet集合的构造函数，在集合初始化时就有了比较方式。定义一个类，实现Comparator接口，覆盖compare方法。定义比较器代码示例：

//自定义一个比较器，将比较器对象作为参数传递给TreeSet集合的构造函数。
class MyComparator implements Comparator
{
	public int compare(Object o1,Object o2) //覆盖compare方法
	{
		if(!(o1 instanceof String) || !(o2 instanceof String))
			throw new ClassCastException("....");
		String s1 = (String)o1;
		String s2 = (String)o2;

		int num = new Integer(s1.length()).compareTo(new Integer(s2.length()));
		if(num==0)  //当主要条件相同时判断一下次要条件。
			return s1.compareTo(s2);
		return num;
	}
}

import java.util.*;
class Student implements Comparable  //让学生具备比较器按年龄排序。
{
	private String name;
	private int age;
	Student(String name,int age)
	{
		this.name = name;
		this.age = age;
	}
	public int compareTo(Object obj) //覆盖compareTo方法
	{
		if(!(obj instanceof Student))
			throw new RuntimeException("不是学生对象");
		Student s = (Student)obj;

		if(this.getAge() > s.getAge())
			return 1;
		if(this.getAge() == s.getAge()) 
		{
			return this.getName().compareTo(s.getName());
		}
		return -1;
	}
	public String getName()
	{
		return name;
	}
	public int getAge()
	{
		return age;
	}
}
class  TreeSetDemo1
{
	public static void main(String[] args) 
	{
		TreeSet ts = new TreeSet(new MyCompare());
		
		ts.add(new Student("xuyv03",13));
		ts.add(new Student("xuyv02",19));
		ts.add(new Student("xuyv07",16));
		ts.add(new Student("xuyv06",15));
		ts.add(new Student("xuyv03",12));
		ts.add(new Student("xuyv09",20));
		ts.add(new Student("xuyv07",15));

		Iterator it = ts.iterator();
		while(it.hasNext())
		{
			Student st = (Student)it.next();
			System.out.println(st.getName()+"::"+st.getAge());
		}
	}
}
class MyCompare implements Comparator  //自定义比较器，按学生的姓名排序。
{
	public int compare(Object o1,Object o2)
	{
		if(!(o1 instanceof Student) && !(o2 instanceof Student))
			throw new RuntimeException("不是学生对象");
		Student s1 = (Student)o1;
		Student s2 = (Student)o2;

		int num = s1.getName().compareTo(s2.getName());

		if(num == 0)
		{
			return new Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));
			/*
			if(s1.getAge() > s2.getAge())
				return 1;
			if(s1.getAge() < s2.getAge())
				return -1;
			return 0;
			*/
		}
		return num;
	}
}