<span style="color:#353535;"><span style="font-family:Arial;background-color: rgb(255, 255, 255);">-------------------</span><span style="font-family:Courier New;background-color: rgb(240, 240, 240);">-</span></span><a target=_blank href="http://edu.csdn.net/heima/"><span style="color:#eb00;background: rgb(255, 255, 255);">android<span style="font-family:新宋体;">培训</span></span></a><span style="color:#353535;background: rgb(255, 255, 255);">、</span><a target=_blank href="http://edu.csdn.net/heima"><span style="color:#eb00;background: rgb(255, 255, 255);">java<span style="font-family:新宋体;">培训</span></span></a><span style="color:#353535;background: rgb(255, 255, 255);">、<span style="font-family:Arial;">java</span><span style="font-family:新宋体;">学习型技术博客、期待与您交流! </span><span style="font-family:Arial;"><span style="font-family:Courier New;background-color: rgb(240, 240, 240);">--------------------</span></span></span><pre class="java" name="code">
1 集合了解
集合的作用:
面向对象语言对事物的体现都是以对象的形式,所以为了方便对多个对象的操作,就对对象进行存储,集合就是存储对象最常用的一种方式.
集合的特点:
集合只用于存储对象,集合长度是可变的,集合可以存储不同类型的对象.
集合和数组的区别:数组虽然也可以存储对象,但长度是固定的;集合长度是可变的,数组中可以存储基本数据类型,也可以存储对象,集合只能存储对象;数组存储的多个元素是同一种数据类型,集合可以存储多种引用类型的元素.
Collection接口:
Collection接口的有两个子接口:List和Set,List元素有序,元素可以重复,Set元素无序,元素要求唯一.
Collection接口的功能:
1:添加元素
boolean add(Object obj):添加单个元素
boolean addAll(Collection c):添加多个元素
2:判断元素
boolean contains(Object obj):判断元素是否存在
boolean containsAll(Collection c):判断一个集合的元素是否包含在当前集合中
boolean isEmpty():判断集合是否为空
3:删除元素
void clear():移除所有元素
boolean remove(Object o):移除单个元素,有一个删除,就返回true
boolean removeAll(Collection c):移除多个元素
4:获取元素
Iterator iterator():返回集合上的一个迭代器
5:交集
boolean retainAll(Collection c):交集
6:集合元素个数
int size():元素个数
7:把集合转成数组
Object[] toArray()
迭代器Iterator
迭代器,其实就是集合的取出元素的方式。
如同抓娃娃游戏机中的夹子。
迭代器是取出方式,会直接访问集合中的元素。
所以将迭代器通过内部类的形式来进行描述。
通过容器的iterator()方法获取该内部类的对象。
演示代码:
Iterator it = al.iterator();//获取迭代器,用于取出集合中的元素。
while(it.hasNext())//使用接口 Iterator<E>中的hasNext()命令,当仍有元素可以迭代,则返回true,再用while判断,为真就继续执行
{
sop(it.next());//返回迭代的下一个元素。直到没有元素为止。这个命令的输出是从第一个元素开始的,注意
}
Iterator<T> iterator():迭代器的返回值是一个以Iterator为接口的子类对象,书写形式为Iterator it = al.iterator();为什么这样呢?因为:
集合类中的数据有很多类型,不同的类型返回方式不一样,所以建立一个内部类,内部类方便调用成员函数和成员数据,利用内部类来返回数据。(把取出方式定义在集合内部,这样取出方式就可以直接访问集合内容的元素。这个取出方式就叫做内部类。)
而每个容器的数据结构不同,所以取出的动作细节也不一样,但是都有共性内容的判断和取出。那么可以将其写成共性抽取。这些共性抽取的内部类符合一个规则,该规则就是Iterator接口。想通过集合取出对象就通过接口对外提供的iterator(),这个方便必须通过以Iterator为接口的子类对象来实现。
通过开发要用for函数写这个迭代对象的过程
for(Iterator it = al.iterator(); it.hasNext() ; )
{
sop(it.next());
}
这样写的好处就是Iterator it作为局部变量,用完以后就释放内存。有利于提高内存利用
迭代就是取出集合中元素的一种方式.
迭代器的方法:
boolean hasNext()判断是否还有元素可以迭代
next()返回迭代的下一个元素,获取的元素默认为Object类
注意:1.迭代器在Collcection接口中是通用的,它替代了Vector类中的Enumeration(枚举)
2.迭代器的next()方法是自动向下取元素,要避免出现NoSuchElementException
3.迭代器的next方法返回值类型是Object,所以要记得类型转换
2 Set集合
Set:无序,不可以重复元素。
|--HashSet:数据结构是哈希表。线程是非同步的。
证元素唯一性的原理:判断元素的hashCode值是否相同。
如果相同,还会继续判断元素的equals方法,是否为true。
通过new的方式往HashSet里面存的元素的hashCode都不同,但通常我们定义对象,
比如学生对象时,虽然是new的两个学生对象,但是当他们name和age一样时,我们认为是
同一个对象,所以为了保证元素的唯一性,我们通常在往HashSet集合里面存储元素时,
在定义对象的类中通常复写hashCode和equals方法。
public int hashCode()
{
return name.hashCode()+age*39;
}
public boolean equals(Object obj)
{
if(!(obj instanceof Student))
return false;
Student stu = (Student)obj;
return this.name.equals(stu.name)&&this.age==stu.age;
}
HashSet是如何保证元素唯一性的呢?
如果两元素的hashCode值不同,则不会调用equals方法
如果两元素的hashCode值相同,则继续判断equals是否返回true;
hashCode和equals方法虽然定义在自定义对象类里面,但不是我们手动调用
而是往HashSet集合里面存储元素的时候,集合底层自己调用hashCode和equals
它自己拿对象去判断,自己判断两元素是否是同一个元素。
|--TreeSet:可以对Set集合中的元素进行排序。
底层数据结构是二叉树。
保证元素唯一性的依据:compareTo方法return 0.
TreeSet排序的第一种方式:让元素自身具备比较性。
元素需要实现Comparable接口,覆盖compareTo方法。
也种方式也成为元素的自然顺序,或者叫做默认顺序。
第二种排序方式:
当元素自身不具备比较性时,或者具备的比较性不是所需要的。
这时就需要让集合自身具备比较性。
在集合初始化时,就有了比较方式。
TreeSet要求往里面存的元素具备比较性,否则会报错。
1. TreeSet排序的第一种方式:让元素自身具备比较性
class Student implements Comparable {// 实现Compareble接口
private String name;
private int age;
public 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) {// 复写compareTo方法
if (!(obj instanceof Student))
throw new RuntimeException("不是学生对象!");// 运行时异常
Student stu = (Student) obj;
int num = this.age - stu.age;// 按年龄比较
if (num == 0)
return this.name.compareTo(stu.name);
return num;
}
}
2.TreeSet排序的第二种方式:让集合具备比较性
import java.util.Comparator;
import java.util.TreeSet;
class StringLengthComparator implements Comparator {// 即定义一个类, 实现Comparator接口
public int compare(Object obj1, Object obj2) {// 覆盖compare方法。
String s1 = (String) obj1;
String s2 = (String) obj2;
int num = new Integer(s1.length()).compareTo(new Integer(s2.length()));// 自然顺序比较
if (num == 0)
return s1.compareTo(s2);// 自然顺序比较
return num;
}
}
class TreeSetTest {
public static void main(String[] args) {
TreeSet ts = new TreeSet(new StringLengthComparator());// 让集合具备比较方式
ts.add("11111");// 添加元素
ts.add("2222");
ts.add("3333");
ts.add("4444");
}
}
基本数据类型或字符串对象均实现了Comparable接口,故同种类型基本数据间具备比较性,即自然顺序。
Set集合总结:
HashSet:
1. 线程不同步,集合里面存放的元素是无序的,唯一的
2. 底层数据结构是哈希表,哈希表结构的数据都是无序的,哈希表结构的操作效率都高效
3.保证元素唯一性的原理是:通过复写hashCode和equals方法,当主要条件一样时,判断次要条件
TreeSet
1.线程不同步,集合可以对存放的元素进行排序,弥补了Set集合元素无序的缺点,且元素是唯一的
2.底层数据结构是二叉树,二叉树结构都是有序的
3.集合要求往集合里存放的元素自身具备比较性,否则会报错
4.集合排序的第一种方式:让元素自身具备比较性,定义元素类实现Compareble接口,覆盖compareTo方法
5.集合排序的第二种方式:让集合具备比较性,定义一个类,实现Comparator接口,覆盖compare方法。
两种排序方式都在时,以比较器为主
3 List集合
Collection:顶层接口
|-->List:列表,元素是有序的(元素带角标索引),可以有重复元素,可以有null元素。
|-->ArrayList(JDK1.2):底层的数据结构是数组数据结构,特点是查询速度快(因为带角标),
但是增删速度稍慢,因为当元素多时,增删一个元素则所有元素的角标都得改变
线程不同步。默认长度是10,当超过长度时,按50%延长集合长度。
|-->LinkedList(JDK1.2):底层数据结构式链表数据结构(即后面一个元素记录前一个),
(1)LinkedList的特有方法:
boolean offerFirst(E e) 在此列表的开头插入指定的元素。
boolean offerLast(E e) 在此列表末尾插入指定的元素。
E peekFirst() 获取但不移除此列表的第一个元素;如果此列表为空,则返回 null。
E peekLast() 获取但不移除此列表的最后一个元素;如果此列表为空,则返回 null。
E pollFirst() 获取并移除此列表的第一个元素;如果此列表为空,则返回 null。
E pollLast() 获取并移除此列表的最后一个元素;如果此列表为空,则返回 null。
(2)通过LinkedList的特有方法,可以实现某些数据特殊方式的存取,比如堆栈和队列。
特点:查询速度慢,因为每个元素只知道前面一个元素,但增删速度快 因为元素再
多,增删一个,只要让其前后的元素重新相连即可线程是不同步的。
|-->Vector(JDK1.0):底层数据结构是数组数据结构.特点是查询和增删速度都很慢。默认长度
是10,当超过长度时,按100%延长集合长度。线程同步。(Vector功能跟ArrayList功
能一模一样,已被ArrayList替代)
import java.util.ArrayList;
import java.util.Iterator;
import java.util.ListIterator;
class ArrayListDemo {
public static void main(String[] args) {
ArrayList a = new ArrayList();// ArrayList():构造一个初始容量为 10 的空列表
a.add("1111");// 将指定的元素添加到此列表的尾部。
a.add("2222");
a.add("3333");
a.add("4444");
f2(a);
System.out.println(a);
f1(a);
System.out.println(a);
}
private static void f1(ArrayList arr) {
ArrayList a = arr;
Iterator it = a.iterator();// 获取迭代器iterator
while (it.hasNext()) {// 如果仍有元素可以迭代,则返回 true
Object obj = it.next();// 返回迭代的下一个元素。
if (obj.equals("4444")) {
// it.set("999999");//没有为类型 Iterator 定义方法 set(String)
// it.add("000000");//没有为类型 Iterator 定义方法 add(String)
}
}
}
private static void f2(ArrayList arr) {
ArrayList a = arr;
ListIterator lt = a.listIterator();// 获取迭代器对象listIterator
while (lt.hasNext()) {// 如果仍有元素可以迭代,则返回 true。
Object obj = lt.next();// 返回迭代的下一个元素。
System.out.println(obj);
if (obj.equals("2222")) {
lt.set("999999");// 可以修改
lt.add("7777777777777");// 可以添加
}
}
System.out.println(a);
}
}
List接口的功能:
1:添加元素
void add(int index, Object element):在指定位置添加指定元素
2:获取元素
Object get(int index):根据指定索引获取元素
3:列表迭代器
ListIterator listIterator()
4:删除元素
Object remove(int index):返回并删除指定位置的元素
5:修改元素
Object set(int index, Object element):修改指定位置的元素
List特有的迭代器:
列表迭代器ListIterator的方法:
void add(E e) 将指定的元素插入列表(可选操作)。
boolean hasPrevious() 如果以逆向遍历列表,列表迭代器有多个元素,则返回 true。
int nextIndex() 返回对 next 的后续调用所返回元素的索引。
E previous() 返回列表中的前一个元素。
int previousIndex() 返回对 previous 的后续调用所返回元素的索引。
void set(E e) 用指定元素替换 next 或 previous 返回的最后一个元素(可选操作)。
注意:ListIterator是Iterator的子接口,在迭代时,不可以通过集合对象的方法操作集合中的元素.
解析:
Iterator li = al.Iterator();
while(li.hasNext())
{
Object obj = li.next();
if(obj.equals("java02"))
li.add("java006");
}
在迭代时,不可以通过集合对象的方法操作集合中的元素。
因为会发生ConcurrentModificationException异常。(上面代码这个异常出现的原因是当遍历这些元素的时候,会把元素放到迭代器中,迭代器正在操作这些元素,如果使用集合中add这些命令来操作这些元素,会出现并发修改异常,不安全所以报错)
所以,在迭代器时,只能用迭代器的方法操作元素,可是Iterator方法是有限的,
只能对元素进行判断,取出,删除的操作,
演示代码:
while(it.hasNext())
{
Object obj = it.next();
if(obj.equals("java02"))
it.remove();//将java02的引用从集合中删除了。此时obj拥有it.next的值,所以可以将结果打印。这段代码不会出错因为remove是迭代器内部的命令,可以使用的
sop("obj="+obj);
}
如果想要其他的操作如添加,修改等,就需要使用其子接口,ListIterator。
该接口只能通过List集合的listIterator方法获取。
演示代码
ListIterator li = al.listIterator();
while(li.hasNext())
{
Object obj = li.next();
if(obj.equals("java02"))
li.set("java006");
}
Vector集合迭代:
枚举就是Vector特有的取出方式。
发现枚举和迭代器很像。其实枚举和迭代是一样的。
因为枚举的名称以及方法的名称都过长。所以被迭代器取代了。枚举郁郁而终了。
Linkedlist集合:
特有方法:
addFirst();从头部填充元素
addLast();从尾部填充元素
getFirst();获得第一个元素,但不删除元素
getLast();获得最后一个元素,但不删除元素
获取元素,但不删除元素。如果集合中没有元素,会出现NoSuchElementException
removeFirst();
removeLast();和getlast的区别是获得以后并删除该元素
获取元素,但是元素被删除。如果集合中没有元素,会出现NoSuchElementException
在JDK1.6出现了替代方法。
offerFirst();同getFirst();
offerLast();
peekFirst();获取但是不移除第一个元素
peekLast();获取但是不移除最后一个元素
获取元素,但不删除元素。如果集合中没有元素,会返回null。
pollFirst();获取并移除列表中的第一个元素
pollLast();获取并移除最后一个元素
获取元素,但是元素被删除。如果集合中没有元素,会返回null。
练习:
使用LinkedList模拟一个堆栈或者队列数据结构。
堆栈:先进后出 如同一个杯子。
队列:先进先出 First in First out FIFO 如同一个水管。
import java.util.*;
class LinkedListTest {
public static void main(String[] args) {
DuiLie dl = new DuiLie();// 建立对象dl为new duilie(),并进行初始化
dl.myAdd("java01");// 填充元素
dl.myAdd("java02");
dl.myAdd("java03");
dl.myAdd("java04");
while (!dl.isNull())// 当dl内部元素不为空时,就执行下面的指令
{
System.out.println(dl.myGet());// 打印元素
}
}
}
class DuiLie {
private LinkedList link;// 私有化一个linklist的对象
DuiLie() {
link = new LinkedList();// 构造函数初始化
}
public void myAdd(Object obj)// 添加元素函数
{
link.addFirst(obj);// 对象为obj,就是任意对象,使用linkaddFirst函数,从头部添加函数
}
public Object myGet()// 获得元素函数
{
return link.removeFirst();// 返回列表中的第一个元素,并移除
}
public boolean isNull() {
return link.isEmpty();// 判断是否为空。
}
}
去除ArrayList集合中的重复元素:
import java.util.*;
class ArrayListTest
{
public static void sop(Object obj)
{
System.out.println(obj);
}
public static void main(String[] args)
{
ArrayList al = new ArrayList();
al.add("java01");
al.add("java02");
al.add("java01");
al.add("java02");
al.add("java01");
al.add("java03");//填充几个元素,有重复的
/*
在迭代时循环中next调用一次,就要hasNext判断一次。所以下面的代码如果在元素个数为奇数时,会出现错误。
Iterator it = al.iterator();
while(it.hasNext())
{
sop(it.next()+"...."+it.next());
}
*/
sop(al);//打印原集合中元素
sop(singleElement(al));//打印去除重复后的元素
}
public static ArrayList singleElement(ArrayList al)//建立一个类singleElement,当做临时容器,用来放那些不重复的元素
{//对象当然是集合,返回类型也是集合。为了让数据更准确,接收的集合以及返回集合都是ArrayList
//定义一个临时容器。
ArrayList newAl = new ArrayList();//建立一个新对象
Iterator it = al.iterator();//利用Iterator接口的子类对象函数iterator(),利用迭代器来输出里面的对象
while(it.hasNext())//当it有下一个元素时
{
Object obj = it.next();//建立一个对象,为it的下一个元素
if(!newAl.contains(obj))//contains()函数是指若包含某元素返回一个布尔型,这条指令意思是如果newAl这个集合中不包含obj这个元素,那么执行下面的指令
newAl.add(obj);//不包含obj就把obj添加到该林芝容器中。
}
return newAl;//返回临时容器
}
}
练习2
将自定义对象作为元素存到ArrayList集合中,并去除重复元素。
比如:存人对象。同姓名同年龄,视为同一个人。为重复元素。
思路:
1,对人描述,将数据封装进人对象。
2,定义容器,将人存入。
3,取出。
List集合判断元素是否相同,依据是元素的equals方法。
"=="和"!="比较的是地址.也可认为"=="和"!="比较的是对象句柄;而equals()比较的是对象内容.或者说,,"=="和"!="比较的是"栈"中的内容,而equals()比较的是"堆"中的内容(包括地址).
演示代码:
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 boolean equals(Object obj)// 覆写equals函数。让equals比较对象的内容。系统自带的equals比较的是地址值。而下面代码中新添加的元素虽然内容都一样,但是在堆内存中建立了新的对象,地址值是不一样的。
{
if (!(obj instanceof Person))// 假如obj与person不相同。instanceof是用来判断两个变量(引用)是否是同一个类类型的。如果输入的obj是与person一个类型就执行下个指令。
return false;// 就返回false
Person p = (Person) obj;// 强制将obj父类类型转换为person子类类型。上面为什么不用person,而是用obj,首先是因为这个比较方法用在集合中,接收的对象不一定都是person,其实如果只写person,输入的不是person,就会报错,应该是这样解释吧~~~
// System.out.println(this.name+"....."+p.name);
return this.name.equals(p.name) && this.age == p.age;// 将对象的name和age与括号中对象p的name和age比较。
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
}
class ArrayListTest2 {
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", 30));
al.add(new Person("lisi02", 32));
al.add(new Person("lisi02", 32));
al.add(new Person("lisi04", 35));
al.add(new Person("lisi03", 33));
al.add(new Person("lisi04", 35));
al = singleElement(al);
sop("remove 03:" + al.remove(new Person("lisi03", 33)));// remove方法底层也是依赖于元素的equals方法。如果前面没有equals的覆写,这条指令也会编译是不,不会移除lisi,33
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();
Iterator it = al.iterator();
while (it.hasNext()) {
Object obj = it.next();
if (!newAl.contains(obj))
newAl.add(obj);
}
return newAl;
}
}
List使用注意:
ArrayList:
(1)当往ArrayList里面存入元素没什么要求时,即只要求有序就行时;
(2)当往ArrayList里面存入元素要求不重复时,比如存入学生对象,当同名同姓时
视为同一个人,则不往里面存储。则定义学生对象时,需复写equals方法
public boolean equals(Object obj)//覆写equals方法
{ if(!(obj instanceof Student)) //判断obj是不是Student的子类
return false;
Student stu = (Student)obj;
return this.name.equals(stu.name)&&this.age==stu.age;//根据姓名和年龄判断
}
则往ArrayList集合通过add存入学生对象时,集合底层自己会调用学生类的equals方法,
判断重复学生则不存入。
注:对于List集合,无论是add、contains、还是remove方法,判断元素是否相同,都是通过复写equals方法来判断!
List集合总结:
1. List集合里面的元素因为是带角标,所以List集合里面的元素都是有序的,
另外List集合可以包含重复元素,也可以包含null。
2. List集合有迭代器Iterator,还有一个特有迭代器列表ListIterator
3.Iterator只能对元素进行判断、取出和删除的操作, ListIterator可对元素进行添加和修改动作等。
4.List集合中判断元素是否相同都是用equals方法,无论contains、remove都依赖equals方法
比如往ArrayList集合里面存放学生,同名同年龄视为同一个人,此时就需要在学生类复
写Object类里面的equals方法
5. 一般情况下,使用哪种List接口下的实现类呢?
如果要求增删快,考虑使用LinkedList
如果要求查询快,考虑使用ArrayList
如果要求线程安全,考虑使用Vector。