本文深入探讨了Java集合框架的基础知识，包括集合类的概念、集合框架的组成及分类、集合框架的共性方法，以及如何高效地遍历和操作集合。通过实例展示了如何使用ArrayList、LinkedList、HashSet和TreeSet等集合类，以及如何实现自定义对象的存储和去重。此外，文章还介绍了Java集合遍历的多种方式，并详细解释了LinkedList的特有方法。最后，总结了集合选择的策略，帮助开发者根据需求选择合适的集合类。
------- android培训、java培训、期待与您交流！ ----------
一、集合框架
在学习集合框架之前就要先了解一些小的知识点：
1.出现集合类的原因：
面向对象语言对事物的体现都以对象的形式，所以为了方便对多个对象的操作，就对对象进行存储，集合就是存储对象最常见的一种方式。
2.数组和集合类同是容器，两者之间的区别是：
数组也可以存储对象，但是长度是固定的，集合的长度是可变的；
数组可以存储基本数据类型，也可以存储引用数据类型，集合只能存储引用数据类型；
3.集合类的特点：
集合只能用于存储对象，集合长度是可变的；集合可以存储不同类型的对象。
4.集合框架是用于存储数据的容器。
二、集合框架的构成及分类
在java体系中，容器的类库分为两大类，即Collection(集合)和Map(映像)。Collection存放的是一组各自独立的对象，而Map中存放的是“键---值”对象。
Collection
|--List:元素是有序的，元素可以重复。因为该集合体系有索引。
|--ArrayList:底层的数据结构使用的是数组结构。特点：查询速度很快。 但是增删稍慢。线程不同步。
|--LinkedList:底层使用的链表数据结构。特点：增删速度很快，查询 稍慢。线程不同步。
|--Vector:底层是数组数据结构。线程同步。被ArrayList替代了。因 为效率低。
|--Set：无序不可重复，没有索引，必须保证元素的唯一性
|--HashSet：底层数据结构是：哈希表
|--TreeSet：底层数据结构是：二叉树
Map：
|--HashTable：底层数据结构是：哈希表
|--HashMap：底层数据结构是：哈希表
|--TreeMap：底层数据结构是：二叉树
三、集合框架的共性方法：
1、添加
add（object）：添加一个元素
注意：add方法的参数类型是Object。以便于接收任意类型对象，多态。
集合中存储的都是对象的引用(地址)
addAll（collection）：添加一个集合中的所有元素
2、删除
clear（）：清空集合
remove（obj）：删除集合中指定的元素，删除成功，集合的长度会改变
removeAll（collection）：把相同的元素删除
3、判断
boolean contains（）：判断指定的元素是否存在
boolean isEmpty（）：判断集合是否为空
4、获取个数，集合长度
int size（）：获取集合的元素个数
5、取交集
boolean retainAll（Collection）：对当前集合中保留和指定集合中的相同的元素，如果两个集合元素相同，返回false，如果retainAll方法修改了当前集合，返回true
6、获取集合中的所有元素
Iterator iterator（）：迭代器
7、将集合变成数组
toArray（）；
四、集合框架中的迭代器iterator
Iterator：是一个接口，用于取集合中的元素
boolean hasNext（）：如果仍有元素可以迭代，则返回true
next（）：返回迭代的下一个元素
void remove（）：从迭代器指向的collection中移除迭代器返回的最后一个元素
迭代器的两种写法
方式一
ArrayList al=new ArrayList();
Iterator it=al.iterator(); //获取迭代器，用来取出元素
while(it.hasNext())
{
System.out.println(it.next());
}
方式二
for(Iterator it=al.iterator();it.hasNext();)
{
System.out.println(it.next);
}
五、List接口
有序，元素都有索引，元素可以重复。
|--List:元素是有序的，元素可以重复。因为该集合体系有索引。
|--ArrayList:底层的数据结构使用的是数组结构。特点：查询速度很快。 但是增删稍慢。线程不同步。
|--LinkedList:底层使用的链表数据结构。特点：增删速度很快，查询 稍慢。线程不同步。
|--Vector:底层是数组数据结构。线程同步。被ArrayList替代了。因 为效率低。
List集合的共性方法：
List中特有的方法：凡是可以操作角标的方法都是该体系中特有的方法。
（1）添加：add（int index，element);在制定的索引位插入元素
addAll(int index,Collection );在制定的索引位插入一堆元素
（2）删除：remove（int index）；删除指定索引位的元素，返回被删的元素
（3）获取：Object get（index);//通过角标获取指定元素
get方法获取到的类型是Object的，如果想调用元素的方法，就必须强转回 本身的类型。
indexOf(Object o);//获取指定元素第一次出现的索引位，不存在返回-1
lastIndexOf(Object o);//反向索引
List subList（from，to）//获取子列表，包含from不包含to
（4）修改：set(int index,element)；//修改指定位置的元素
（5）获取所有元素：迭代器：listIterator();list集合特有的迭代器
listIterator(int index);//从列表的指定位置开始迭代。
另外还提供了逆向遍历的方法：hasPrevious（）；previous（）；previousIndex （）；
六、知识点的补充：集合遍历的四种方式：
第一种方式：普通for循环语句遍历：(这种方式只适合list集合，不适合set集合)
for（int i =0;i<list.size();i++){
System.out.println(list.get(i));
}
第二种方式：增强的for循环语句：
for( Object obj:list){
System.out.println(obj);
}
第三种方式：迭代器的方式遍历集合：（这种方法是通用的）
Iterator<String>it=list.iterator<String>(); //取得list对象的迭代器
while（it.hasNext()){
System.out.println(it.next());
}
第四种方式：List集合中特有迭代器方式：（只有在List集合中才适用）
ListIterator<String>lit=list.listiterator<String>();
while(lit.hasNext()){
System.out.println(lit.next());
}
七、LinkedList的特有方法：
1.添加
addFirst();
addLast();
2.获取
1.getFirst();
getLast();
获取元素，但不删除元素。如果集合中没有元素，会出现NoSuchElementException
2.removeFirst();
removeLast();
获取元素，但是元素被删除。如果集合中没有元素，会出现NoSuchElementException
在JDK1.6出现了替代方法。
1.添加
offerFirst();
offerLast();
2.获取
1.peekFirst();
peekLast();
获取元素，但不删除元素。如果集合中没有元素，会返回null。
2.pollFirst();
pollLast();
获取元素，但是元素被删除。如果集合中没有元素，会返回null。
练习1：
importjava.util.LinkedList;
class LinkedListDemo
{
public static void main(String[] args)
{
LinkedList link = newLinkedList();
link.addLast("java01");
link.addLast("java02");
link.addLast("java03");
link.addLast("java04");
//sop(link.removeFirst());//java01
//sop(link.removeFirst());//java02
//sop("size="+link.size());//2
while(!link.isEmpty())
{
sop(link.removeLast());
}
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
练习2：将自定义对象作为元素存到ArrayList集合中，并去除重复元素。
importjava.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)
{
if(!(obj instanceof Person))
return false;
Person p = (Person)obj;
System.out.println(this.name+"....."+p.name);
return this.name.equals(p.name)&& this.age == p.age;
}
public String getName()
{
return name;
}
public int getAge()
{
return age;
}
}
class ArrayListTest
{
public static void sop(Object obj)
{
System.out.println(obj);
}
public static void main(String[] args)
{
ArrayList al = new ArrayList();
al.add(newPerson("lisi01",30));
al.add(newPerson("lisi02",32));
al.add(newPerson("lisi02",32));
al.add(newPerson("lisi04",35));
al.add(newPerson("lisi03",33));
al.add(newPerson("lisi04",35));
al = singleElement(al);
sop("remove 03:"+al.remove(new Person("lisi03",33)));
Iterator it = al.iterator();
while(it.hasNext())
{
Person p =(Person)it.next();
sop(p.getName()+"::"+p.getAge());
}
}
public static ArrayListsingleElement(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;
}
}
八、Set接口
Set集合的功能和Collection是一致的。
Set：无序，不可以重复元素。
|--HashSet：数据结构是哈希表。线程是非同步的。
保证元素的唯一性的原理：判断元素的hashCode值是否相同。如果 相同，还会继续判断元素的equals方法，是否为true。如果元素 的hashcode值不同，不会调用equals。
|--TreeSet：可以对Set集合中的元素进行排序。
底层数据结构是二叉树。保证元素唯一性的依据：compareTo方法 return 0.
--->对于ArrayList集合，判断元素是否存在，或者删除元素底层依据都是equals方法。
对于HashSet集合，判断元素是否存在，或者删除元素，底层依据的是hashCode和equals方法
练习：往hashSet集合中存入自定对象
importjava.util.HashSet;
import java.util.Iterator;
class HashSetTest
{
publicstatic void sop(Object obj)
{
System.out.println(obj);
}
publicstatic void main(String[] args)
{
HashSeths = new HashSet();
hs.add(newPerson("a1",11));
hs.add(newPerson("a2",12));
hs.add(newPerson("a3",13));
Iteratorit = hs.iterator();
while(it.hasNext())
{
Personp = (Person)it.next();
sop(p.getName()+"::"+p.getAge());
}
}
}
class Person
{
privateString name;
privateint age;
Person(Stringname,int age)
{
this.name= name;
this.age= age;
}
public inthashCode()
{
System.out.println(this.name+"....hashCode");
returnname.hashCode()+age*37;
}
publicboolean equals(Object obj)
{
if(!(objinstanceof Person))
returnfalse;
Personp = (Person)obj;
System.out.println(this.name+"...equals.."+p.name);
returnthis.name.equals(p.name) && this.age == p.age;
}
publicString getName()
{
returnname;
}
public intgetAge()
{
returnage;
}
}
--->TreeSet：
用于对Set集合进行元素的指定顺序排序，排序需要依据元素自身具备的比较性，如果元素不具备比较性，在运行时会发生ClassCastException异常。
所以需要元素实现Comparable接口，强制让元素具备比较性，复写CompareTo方法。
依据CompareTo方法的返回值，确定元素在TreeSet数据结构中的位置.
TreeSet集合有两种排序方式，Comparable和Comparator区别
1、让元素自身具备比较性，需要元素实现Comparable接口，覆盖CompareTo方法。
2、让集合自身具备比较性，需要定义一个实现了Comparator接口的比较器，并覆盖Compare方法，并将该类对象作为实际参数传递给TreeSet集合的构造函数
第二种方式较为灵活，当两种比较方式都存在时，以比较器为主。
练习：往TreeSet集合中存储自定义对象学生。想按照学生的年龄进行排序。
importjava.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;
class Student implements Comparable//该接口强制让学生具备比较性。
{
privateString name;
privateint age;
Student(Stringname,int age)
{
this.name= name;
this.age= age;
}
public intcompareTo(Object obj)
{
if(!(objinstanceof Student))
thrownew RuntimeException("不是学生对象");
Students = (Student)obj;
if(this.age>s.age)
return1;
if(this.age==s.age)
{
returnthis.name.compareTo(s.name);
}
return-1;
}
publicString getName()
{
returnname;
}
public intgetAge()
{
returnage;
}
}
class TreeSetTest
{
publicstatic void main(String[] args)
{
TreeSetts = new TreeSet();
ts.add(newStudent("lisi02",22));
ts.add(newStudent("lisi02",21));
ts.add(newStudent("lisi007",20));
ts.add(newStudent("lisi09",19));
ts.add(newStudent("lisi06",18));
ts.add(newStudent("lisi06",18));
ts.add(newStudent("lisi007",29));
Iteratorit = ts.iterator();
while(it.hasNext())
{
Studentstu = (Student)it.next();
System.out.println(stu.getName()+"..."+stu.getAge());
}
}
}
class MyCompare implements Comparator
{
public intcompare(Object o1,Object o2)
{
Students1 = (Student)o1;
Students2 = (Student)o2;
intnum = s1.getName().compareTo(s2.getName());
if(num==0)
{
ReturnnewInteger(s1.getAge()).compareTo(newInteger(s2.getAge()));
}
returnnum;
}
}
知识点的总结：
如何保证元素的排序呢？两种方式
A:让元素本身具备比较性
实现Compareable接口中的compareTo方法。
B:让集合具备比较性
实现Comparator接口中的compare方法。
以后到底用哪个集合呢？
A:如果要元素唯一，就用Set。否则，用List。
B:如果元素唯一并且要排序用TreeSet，否则，用HashSet。
C:如果元素可重复，且考虑线程问题，用Vector。
否则，用ArrayList或者LinkedList。
如果要求，增删快，那么，考虑LinkedList。
如果要求，查询快，那么，考虑ArrayList。
D:当你什么都不清楚的时候，就使用ArrayList。
------- android培训、java培训、期待与您交流！ ----------
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
