集合类的由来：
对象用于封装特有数据，对象多了需要存储，如果对象的个数不确定。就使用集合容器进行存储。
集合特点：
1.用于存储对象的容器。
2.集合的长度是可变的。
3.集合中不可以存储基本数据类型值。
集合容器因为内部的数据结构不同，有多种具体容器。不断向上抽取就形成了集合框架。
框架的顶层Collection接口：
Collection的常见方法：
1.添加。
boolean add(Object obj);
boolean addAll(Collection coll);
2.删除。
boolean remove(Object obj);
boolean removeAll(Collection coll);
void clear();
3.判断。
boolean contains(Object obj);
boolean containsAll(Collection coll);
boolean isEmpty();判断集合中是否有元素。
4.获取。
int size();
Iterator iterator();取出元素方式：迭代器。
该对象必须依赖于具体容器，因为每一个容器的数据结构都不一样。
所以该迭代器对象是在容器中进行内部实现的。对于使用容器者而言，具体的 实现不重要，
只通过容器获取到该实现的迭代器对象即可，也就是iterator方法。
Iterator接口就是对所有Collection容器进行元素取出的公共接口。
5.其他。
boolean retainAll(Collection coll);取交集
Object[] toArray;将集合转成数组。
Collection：
|--List:有序（存入和取出的顺序一致），元素都有索引（角标），元素可以重复。
|--Set：元素不能重复，无序。
List：特有的常见方法：有一个共性特点就是都可以操作角标。
1.添加
void add(index,element);
void add(index,collection);
2.删除
Object remove(index);
3.修改
Object set(index,element);
4.获取
Object get(index);
int indexOf(object);
int lastIndexOf(object);
List subList(from,to);
list集合是可以完成对元素的增删改查。
#######List:
|--Vector:内部是数组数据结构，是同步的。增删，查询都很慢。
|--ArrayList:内部是数组数据结构，是不同步的。替代了Vector。查询速度快。
|--LinkedList：内部是链表数据结构，是不同步的。增删元素的速度很快。
Collection共性功能：
public class CollectionDemo {
public static void main(String[] args) {
Collection coll=new ArrayList();
show(coll);
Collection c1=new ArrayList();
Collection c2=new ArrayList();
show(c1,c2);
}
public static void show(Collection c1, Collection c2) {
// 给c1添加元素
c1.add("abc1");
c1.add("abc2");
// 给c2添加元素
c2.add("abc3");
c2.add("abc4");
// 演示addAll
c1.add(c2);
// 演示removeAll
// boolean b=c1.removeAll(c2);将两个集合中相同的元素从调removeAll的集合中删除
//// 演示containsAll
// boolean b=c1.contains(c2);
// System.out.println("containsAll"+b);
// 演示retainAll
boolean b=c1.retainAll(c2);//取交集，保留相同元素，删除不同元素。
System.out.println("retainAll"+b);
System.out.println("c1"+c1);
}
public static void show(Collection coll) {
// 添加元素，add
coll.add("abc1");
coll.add("abc2");
coll.add("abc3");
System.out.println(coll);
// 删除元素，remove
coll.remove("abc2");//会改变集合的长度
// 清空集合
// coll.clear();
System.out.println(coll.contains("abc3"));
System.out.println(coll);
}
}
Iterator功能：
public class IteratorDemo {
public static void main(String[] args) {
Collection coll=new ArrayList();
coll.add("abc1");
coll.add("abc2");
coll.add("abc3");
coll.add("abc4");
// 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();){
System.out.println(it.next());
}
}
}
List共性功能：
public class ListDemo {
public static void main(String[] args) {
List list=new ArrayList();
show(list);
}
public static void show(List list) {
// 添加元素
list.add("abc1");
list.add("abc2");
list.add("abc3");
list.add("abc4");
System.out.println(list);
// 插入元素
list.add(1,"abc9");
// 删除元素
System.out.println("remove:"+list.remove(2));
// 修改元素
System.out.println("set"+list.set(1, "abc8"));
// 获取元素
System.out.println("get"+list.get(0));
// 获取子列表
System.out.println("sublist"+list.subList(1, 2));
System.out.println(list);
}
}
Iterator子接口ListIterator（List特有）：
public class ListDemo2 {
public static void main(String[] args) {
List list=new ArrayList();
// show(list);
list.add("abc1");
list.add("abc2");
list.add("abc3");
System.out.println("list:"+list);
/* java.util.ConcurrentModificationException
在迭代器过程中，不要使用集合操作元素，容易出现异常。
可以使用Iterator接口的子接口ListIterator来完成在迭代中对元素进行更多的操作。
Iterator it=list.iterator();
while(it.hasNext()){
Object obj=it.next();
if(obj.equals("abc2"))
list.add("abc9");
else
System.out.println("next"+obj);
}
System.out.println(list);
*/
ListIterator it=list.listIterator();//获取列表迭代器对象
// 它可以实现在迭代过程中完成对元素的增删改查。
// 注意：只有list集合具备该迭代功能
while(it.hasNext()){
Object obj=it.next();
if(obj.equals("abc2")){
it.set("abc9");
}
}
System.out.println("hasNext"+it.hasNext());
System.out.println("hasPrevious"+it.hasPrevious());
while(it.hasPrevious()){
System.out.println("previous"+it.previous());
}
System.out.println("list:"+list);
}
public static void show(List list) {
list.add("abc1");
list.add("abc2");
list.add("abc3");
list.add("abc4");
Iterator it=list.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
// list特有的取出方式
for(int x=0;x<list.size();x++){
System.out.println("get"+list.get(x));
}
}
}
LinkedList:
addFirst();
addLast();
jdk1.6：
offerFirst();
offerLast();
getFirst();获取但不移除，如果链表为空，抛出NoSuchElementException.
getLast();
jdk1.6：
peekFirst();获取但不移除，如果链表为空，返回null
peekLast();
removeFirst();获取并移除，如果列表为空，抛出NoSuchElementException.
removeLast();
jdk1.6：
pollFirst();获取并移除，如果列表为空，返回null
pollLast();
public static void main(String[] args) {
LinkedList link=new LinkedList();
link.addFirst("abc1");
link.addFirst("abc2");
link.addFirst("abc3");
link.addFirst("abc4");
/* System.out.println(link);
System.out.println(link.getFirst());//获取但不删除
System.out.println(link.removeFirst());//获取并删除
*/
while(!link.isEmpty()){
System.out.println(link.removeLast());
}
System.out.println(link);
/*Iterator it=link.iterator();
while(it.hasNext()){
System.out.println(it.next);
}*/
}
请使用LinkedList来模拟一个堆栈或者队列数据和结构。
堆栈：先进后出。
队列：先进先出。
我们应该描述这样一个容器，给使用提供一个容器对象完成这两种结构中的一种。
DuiLie类：
public class DuiLie {
private LinkedList link;
public DuiLie() {
link=new LinkedList();
}
/*
队列添加元素的功能
*/
public void myAdd(Object obj){
link.addFirst(obj);
}
public Object myGet(){
return link.removeFirst();
}
public boolean isNull(){
return link.isEmpty();
}
}
LinkedListTest类：
public class LinkedTest {
public static void main(String[] args) {
DuiLie dl=new DuiLie();
dl.myAdd("abc1");
dl.myAdd("abc2");
dl.myAdd("abc3");
dl.myAdd("abc4");
while(!dl.isNull()){
System.out.println(dl.myGet());
}
}
}
Vector：内部是数组数据结构，是同步的。增删，查询都很慢！
public static void main(String[] args) {
Vector v = new Vector();
v.addElement("abc1");
v.addElement("abc2");
v.addElement("abc3");
v.addElement("abc4");
Enumeration en = v.elements();
while(en.hasMoreElements()){
System.out.println("nextelment:"+en.nextElement());
}
Iterator it = v.iterator();
while(it.hasNext()){
System.out.println("next:"+it.next());
}
}
ArrayList：
定义功能去除ArrayList中的重复元素。
public class ArrayListTest2 {
public static void main(String[] args) {
// demo();
// singleDemo();
ArrayList al=new ArrayList();
al.add(new Person("lisi1",21));
al.add(new Person("lisi2",22));
al.add(new Person("lisi3",23));
al.add(new Person("lisi4",24));
al.add(new Person("lisi2",22));
al.add(new Person("lisi3",23));
System.out.println(al);
al=getSingleElement(al);
System.out.println(al.remove(new Person("lisi2",22)));
System.out.println(al);
}
private static void singleDemo() {
ArrayList al=new ArrayList();
al.add("abc1");
al.add("abc2");
al.add("abc2");
al.add("abc1");
al.add("abc");
System.out.println(al);
al=getSingleElement(al);
System.out.println(al);
}
private static ArrayList getSingleElement(ArrayList al) {
//1，定义一个临时容器
ArrayList temp=new ArrayList();
//2,迭代al集合
Iterator it=al.iterator();
while(it.hasNext()){
Object obj =it.next();
//3,判断被迭代的元素是否在临时容器存在
if(!temp.contains(obj)){
temp.add(obj);
}
}
return temp;
}
private static void demo() {
// al.add(5);//al.add(new Integer(5));
}
}
网友评论