黑马程序员--Java基础--集合（一）

最新推荐文章于 2023-04-17 13:15:24 发布

dashuaifei

最新推荐文章于 2023-04-17 13:15:24 发布

阅读量205

点赞数

本文链接：https://blog.csdn.net/dashuaifei/article/details/47433659

版权

------- android培训、 java培训、期待与您交流！ ----------

第一部分：集合框架概述

集合的由来：对象用于封装特有数据，对象多了需要存储；如果对象的个数不确定，就使用集合容器进行存储。

Java中有两种存储对象：数组和集合。

它们的区别在于：

1、数组的长度一旦定义了就是固定的，而集合长度是可变的。

2、数组中可以存储基本数据类型，集合只能存储对象。

因此从这里可以得出集合的特点：：

a. 用于存储对象的容器。

b. 集合的长度是可变的。

c. 集合中不可以存储基本数据类型值。

根据数据存储的方式（即数据结构）的不同，可以分为不同的集合容器。这些不同的集合容器不断的向上抽取，就形成了顶层的集合框架就是Collection。

下面代表了集合框架中List集合和Set集合的结构：

Collection

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

|--|--ArrayList:底层的数据结构使用的是数组结构。特点：查询速度很快，但是增删稍慢。线程不同步初始容量是10，超过以后按照百分之50进行延长。

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

|--|--Vector:底层是数组结构。线程同步。被ArrayList替代了。超过初始容量后按照百分之百延长。

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

|--|--HashSet:底层数据结构是哈希表。

|--|--TreeSet:可以对Set集合中的元素进行排序。

第二部分：迭代器对象Iterator

迭代器的概念：集合的取出元素的方式。

集合框架中将取出方式定义在集合的内部，作为集合的内部类，这样就能直接访问不同集合里的内部元素。

为什么要定义在内部？

因为每一个具体的集合容器的数据结构不同，所以取出的动作细节也不一样。因此迭代器对象在具体容器中进行具体实现，不同容器的实现方式是不一样的。但是都有共性的内容：判断和取出。因此抽取出了共性，即迭代器对象Iterator

因此，通过对外提供的方法：Iterator()可以获取集合的取出对象。

使用迭代器获取元素的第一种方法代码示例：

//创建一个集合容器，使用Collection接口的子类，ArrayList
ArrayList a1 = new ArrayList();
a1.add("java01");//add(Object obj)
a1.add("java02");
a1.add("java03");
a1.add("java04");

Iterator it = a1.iterator();//这个方法返回的是Iterator的子类对象
while(it.hasNext())
{
        System.out.println(it.next());//获取迭代器，用于取出集合中的元素
}

使用迭代器获取元素的第二种方法代码示例：

for(Iterator it1 = a1.iterator();it1.hasNext();)
{
	System.out.println(it1.next());
}

第三部分：集合框架的共性方法

集合的顶层是Collection接口，这个接口中定义了常见的共性方法：

1、添加：

boolean add(Object obj);

boolean addAll(Collection coll);

add()方法代码示例：

//创建一个集合容器，使用Collection接口的子类，ArrayList
ArrayList a1 = new ArrayList();
a1.add("java01");
a1.add("java02");
a1.add("java04");

2、删除：

boolean remove(Object obj);

boolean removeAll(Collection coll);

remove()方法代码示例：

a1.remove("java02");

void clear();

clear()方法示例：

a1.clear();

3、判断：

boolean contains(Object obj);判断是否包含对象obj

contain()方法示例：

a1.contains("java03");

boolean containsAll(Collection coll);

boolean isEmpty();判断集合中是否有元素。

isEmpty()方法示例

 a1.isEmpty();

4、获取

int size();

size()方法示例：

a1.size();

Iterator iterator();

5、其他

boolean retainAll(Collection coll);取两个集合的交集

retainAll()方法示例：

<span style="white-space:pre">		</span>ArrayList a1 = new ArrayList();
		a1.add("java01");
		a1.add("java03");
		
		ArrayList a2 = new ArrayList();
		a2.add("java01");
		a2.add("java04");

		a1.retainAll(a2);//取交集，a1中只会保留和a2中相同的元素
		System.out.println(a1);
		System.out.println(a2);

输出结果是：

[java01]
[java01, java04]

boolean removeAll(Collection coll);去掉两个集合的交集

removeAll()方法实例：

		a1.removeAll(a2);//a1中把和a2相同的元素去掉
                System.out.println(a1);
                System.out.println(a2);

输出结果是：

[java03]
[java01, java04]

第四部分：List集合

1、在List集合容器中，拥有特殊的共性方法：凡是可以操作角标的方法都是该体系中特有的方法。

a、添加：

void add(int index,E element);

ArrayList al = new ArrayList();
al.add("java01");
al.add("java02");
al.add("java03");

//在第二位添加元素
al.add(1,"java09");

boolean addAll(int index,Collection coll);
b、删除

boolean remove(int index);

al.remove(2);

c、修改

E set(int index,E element);

al.set(2,"java007");

d、查找

E get(index);

//获取所有元素,List的特有方式
for(int x = 0;x<al.size();x++)
{
        al.get(x);
}

List<E> subList(int from,int to);

List sub = al.subList(1,2);

ListIterator<E> listIterator();

注：ListIterator是List集合特有的迭代器，它是Iterator的子接口。

在迭代时，只能用用迭代器Iterator的方法操作元素，可是迭代器Iterator的方法是有限的，只能对元素进行判断、取出和删除操作。如果想要进行添加、修改，则会发生并发修改异常。

因此，在List集合中想要对元素在迭代过程中进行添加、修改，则必须用ListIterator迭代器。

代码示例：

		/*
		//在迭代过程中，准备添加或者删除元素
		Iterator it = al.iterator();
		while(it.hasNext())
		{
			Object obj = it.next();
			if(obj.equals("java02")
				//al.add("java008");//修改异常，不能用集合同时用迭代器操作元素。这个是并发修改
				it.remove();//把java02的引用从集合中删除了
		}
		*/

		ListIterator li = al.listIterator();
		while(it.hasNext())
		{
			Object obj = li.next();
			if(obj.equals("java02"))
				li.add("java009");//在java02后面添加了java009
				//li.set("java006");把java02修改成java006
		}

同时在ListIterator对象中提供了逆向遍历方法：hasPrevious()和previous()。代码示例：

                ListIterator li = al.listIterator();
		while(li.hasPrevious())
		{
			sop(li.previous());//逆向取元素
		}

2、LinkedList集合容器的特有方法：

a、添加

addFirst(Object obj);

addLast(Object obj);

jdk1.6版本后新方法：

offerFirst();与addFirst方法没有区别。

offerLast();与addLast方法没有区别。

b、获取

getFirst();

getLast();

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

jdk1.6版本后新方法：

peekFirst();

peekLast();

特点：获取但不移除，如果链表为空，返回null。

c、删除

removeFirst();

removeLast();

特点：获取元素，但是元素被删除。如果集合中没有元素，会出现NoSuchElementException

pollFirst();

pollLast();

特点：获取并移除，如果链表为空，返回null;

3、List集合判断元素是否相同（例如contain方法和remove方法），依据的是元素的equals()方法。

例如：以Person类为对象存入ArrayList中，同性名同年龄的视为同一个人，不能加为同一个人。

这时候要在Person类中添加一个equals方法，对姓名name和年龄age进行判断

代码示例：

import java.util.ArrayList;
import java.util.Iterator;

class Person
{
	private String name;
	private int age;
	Person(String name,int age)
	{
		this.name = name;
		this.age = age;
	}
	public String getName()
	{
		return name;
	}
	public int getAge()
	{
		return age;
	}
	//覆写equals方法。
	public boolean equals(Object obj)
	{
		if(!(obj instanceof Person))
			return false;
		Person p = (Person)obj;
		return this.name.equals(p.name) && this.age==p.age;
	}
}

class  HelloDemo
{
	//定义一个新方法，对ArrayList容器里的元素按照name和age进行比较，然后返回一个新的不带重复元素的ArrayList
	public static ArrayList singleElement(ArrayList al)
	{
		//定义一个临时容器
		ArrayList newAl = new ArrayList();
		Iterator it = al.iterator();
		while(it.hasNext())
		{
			Object obj = it.next();
			if(!newAl.contains(obj))
				newAl.add(obj);
		}
		return newAl;	
	}	
	public static void main(String[] args) 
	{
		ArrayList al = new ArrayList();
		//a1.add(Object obj)-->Object obj = new Person(..)-->类型自动提升
		al.add(new Person("lisi01",30));
		al.add(new Person("lisi02",43));
		al.add(new Person("lisi02",43));
		al.add(new Person("lisi03",23));
		al.add(new Person("lisi04",32));
		al.add(new Person("lisi04",32));

		ArrayList newAl = singleElement(al);
		
		Iterator it = newAl.iterator();
		while(it.hasNext())
		{
			Person p = (Person)it.next();
			System.out.println(p.getName()+"::"+p.getAge());
		}
	}
}

4、Vector容器的枚举。

枚举是Vector的特有方式，但是作用和迭代器一致。

因为枚举的名称以及方法的名称都过长，所以被迭代器取代了

代码示例：

		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());
		}

第五部分：Set集合

1、set集合的元素的特点：

a、元素是无序的（存入和取出的顺序不一定一致）；

b、元素不可以重复

Set接口中的方法和Collection一致。

2、HashSet

HashSet的底层数据结构是哈希表。

重点：HashSet容器保证元素唯一性的方法：

通过元素的两个方法，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 String getName()
	{
		return name;
	}
	//一般要覆写hashCode()和equals()方法
	public int hashCode()
	{
		return name.hashCod()+age*39;//一般要乘以一个数保证哈希值的唯一性
	}
	public boolean equals(Object obj)
	{
		if(!obj instanceof Person)
			throw new RuntimeException("不是学生对象");
		Person p = (Person)obj;
		return this.name.equals(p.name) && this.age==p.age;
	}
	public int getAge()
	{
		return age;
	}
}
class  
{
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
	public static void main(String[] args) 
	{
		HashSet hs = new HashSet();
		hs.add(new Person("java01",11);
		hs.add(new Person("java02",12);
		hs.add(new Person("java03",13);
		hs.add(new Person("java02",12);
		

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

	}
}

3、TreeSet

TreeSet的底层是排序二叉树，左子树比右子树大。取出时候按照中序遍历取出元素。

TreeSet保证元素唯一性的方式：就是compareTo()方法是否返回0，如果返回0则判断这两个元素相等。

重点：TreeSet排序的两种方式：

a、如果元素本身具备比较性，使用元素实现Comparable接口，然后覆写compareTo()方法。这种方式是利用了元素的自然顺序。

b、当元素自身不具备比较性时，或者具备的比较性不是所需要的，这时就需要让集合自身具备比较性。具体方法是定义一个类实现Comparator接口，覆盖compare方法。将该类对象作为参数传递给TreeSet集合的构造函数。

P.S. 当两种方式都存在时，以第二种方式、即以比较器为主。

假设存储Student类对象，按照年龄age和姓名name排序

下面是第一种方式的代码示例：

class Student implements Comparable//该接口强制让学生具备比较性
{
	private String name;
	private int age;

	Student(String name,int age)
	{
		this.name = name;
		this.age = age;
	}
	public String getName()
	{
		return name;
	}
	public int getAge()
	{
		return age;
	}
	//覆写方法,这个方法可以对对象进行比较排序。该方法先按照年龄进行排序，然后再按照姓名排序。
	public int compareTo(Object obj)
	{
		if(!(obj instanceof Student))
			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);//很多类都具有compareTo方法
		}
		return -1;
		
	}
}

<pre name="code" class="java">//主函数

class  Demo
{
	public static void main(String[] args) 
	{
		TreeSet ts = new TreeSet();
		ts.add(new Student("aisi02",22));
		ts.add(new Student("lisi007",20));
		ts.add(new Student("bisi09",22));
		ts.add(new Student("lisi01",40));
		
		Iterator it = ts.iterator();
		while(it.hasNext())
		{
			Student stu = (Student)it.next();//这里一定要强制转换回原有。
			System.out.println(stu.getName()+":"+stu.getAge());
		}
	}
}

接下来是第二种方式：

//实现MyCompare类来实现比较器接口，然后覆写比较器Comparator接口里的方法compare()方法。

//这个比较器和上面相反，先按照姓名name排序后再按照年龄age排序
class MyCompare implements Comparator
{
	public int compare(Object o1,Object o2)
	{
		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()));
		return num;
	}
}

//主函数
<pre name="code" class="java">class  HelloDemo
{
	public static void main(String[] args) 
	{
		TreeSet ts = new TreeSet(new MyCompare());//在TreeSet构造函数中就要作为参数传入。
		ts.add(new Student("aisi02",22));
		ts.add(new Student("lisi007",20));
		ts.add(new Student("bisi09",22));
		ts.add(new Student("lisi01",40));
		
		Iterator it = ts.iterator();
		while(it.hasNext())
		{
			Student stu = (Student)it.next();
			System.out.println(stu.getName()+":"+stu.getAge());
		}
	}
}

P.S.：有一个需求是TreeSet怎么存入元素就怎么取出来的办法是：co'mpareTo方法直接return 1即可。