java基础整理十四（集合一）

集合框架：

Collection:
|--List:元素有序可以重复,因为集合体系有索引
|--ArrayList:底层的数据结构使用的是数组结构.特点查询速度快,但是增删稍慢.线程不同步
|--LinkedList:底层使用的链表数据结构.特点增删速度快,但是查询稍慢
|--Vector:底层数组数据结构.线程同步.被ArrayList替代了.
|--Set:元素无序(存入和取出的顺序不一致)不可重复.功能和Collection是一致的
|--HashSet:底层数据结构是哈希表.
HashSet是如何保证元素唯一性的?是通过元素的两个方法,hashCode和equals来完成
当元素的hashCode值相同才会判断equals是否为true反之则不调用equals.
注意:对于判断元素是否存在以及删除操作,依赖的方法是元素的hashCode和equals方法.
|--TreeSet:可以对Set集合中的元素进行排序,底层数据结构是二叉树,保证元素唯一性的依据compareTo方法return 0;
TreeSet排序的第一种方式:让元素自身具备比较性,元素需要实现Comparable接口,覆盖compareTo方法,这种方式也称为元素的自然顺序.
TreeSet的第二种排序方式：当元素自身不具备比较性时，或者具备的比较性不是所需要的这时就需要让集合自身具备比较性
在集合初始化时就有了比较方式
import java.util.*;//导入包
/*1,add方法的参数类型是Object.以便于接收任意类型对象
2,集合中存储的都是对象的引用(地址)


什么是迭代器?
就是集合的取出元素的方式.
*/
class CollectionDemo
{
public static void main(String[]args)
{






}
public static void method_get()//获取方法的实例
{
ArrayList al = new ArrayList();
al.add("java1");
al.add("java4");
al.add("java3");
al.add("java2");
Iterator it = al.iterator();//获取迭代器.用于取出集合中的元素
while(it.hasNext())//判断是否还能取到值
{
sop(it.next());//取到下一个值
}
for (Iterator it = al.iterator();it.hasNext ; )
{
sop(it.next());
}
/*
把取出方式定义在集合的内部,这样取出方式就可以直接访问集合内部的元素,取出方式就被定义成了内部类
每一个容器的数据结构不同,所以取出的动作细节也不一样,但是都有共性内容 判断和取出,即可以将共性进行抽取
这些内部类都符合一个规则,该规则是Iterator.如何获取集合的取出对象呢 通过一个对外提供的方法iterator();
*/
}
public static void method_2()
{
ArrayList al1 = new ArrayList();
al1.add("java1");
al1.add("java4");
al1.add("java3");
al1.add("java2");


ArrayList al2 = new ArrayList();
al2.add("java1");
al2.add("java2");
al2.add("java5");
al2.add("java6");

al1.retainAll(al2);//取交集,al1中只会保留和al2中相同的元素
al1.removeAll(al2);//除去al1中和al2中相同的元素.
}
public static void base_method()
{
//1,创建一个集合容器,使用Collection接口的子类.ArrayList
ArrayList al = new ArrayList();
//添加元素
al.add("java1");//add(Object obj)
al.add("java4");
al.add("java3");
al.add("java2");


//打印集合
sop(al);//打印的为内部元素


//3,删除元素
al.remove("java02");
al.clear();//清空集合


//4,判断元素
sop("java03是否存在:"+al.contains("java03"));
sop("集合是否为空:"+al.isEmpty());


//2,获取元素个数,集合长度.
sop(al.size());


//打印改变后的集合
sop(al);
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}


List:
特有方法,凡是可以操作角标的方法都是该体系特有的方法


增:
add(index,element);
addAll(index,Collection);
删:
remove(index);
改:
set(index,element);
查:
get(index);
subList(from,to);


List集合特有的迭代器.ListIterator是Iterator的子接口
在迭代时,不可以通过集合对象的方法操作集合中的元素.
因为会发生ConcurrentModificationException异常.所以在迭代器时只能使用迭代器的方法操作元素,但Iterator方法有限
只能对元素进行判断,取出,删除的操作.如果想要其他的操作如添加,修改等,就需要使用其子接口ListIterator
该接口只能通过List集合的ListIterator方法获取.


import java.util.*;
class ListDemo
{
public static void sop(Object obj)
{
System.out.println(obj);
}
public static void method()
{
//演示列表迭代器
ArrayList al = new ArrayList();
al.add("java1");
al.add("java2");
al.add("java3");

//完整的在迭代过程中准备添加或删除元素
ListIterator li = new al.listIterator();
while (li.hasNext())
{
Object obj = li.next();
if (obj.equals("java2"))
li.add("java009");//添加
li.set("java006");//修改
}
while (li.hasPrevious())
{
sop(li.previous());//从后面开始遍历
}
sop("hasNext():"+li.hasNext());//判断是否有后一个元素false
sop("hasPrevious():"+li.hasPrevious());//判断是否有前一个元素true
sop(al);

/*
//存在缺陷的在迭代过程中准备添加或删除元素
Iterator it = al.iterator();
while (it.hasNext())
{
Object obj = it.next();
if (obj.equals("java02"))
//al.add("java08");不能实现此功能不能执行添加功能
it.remove();//将java02的引用从集合中删除但是仍被obj使用
sop("obj="+obj)
}
sop(al);//缺少java02
}
*/




public static void main(String[]args)
{
ArrayList al = new ArrayList();
//添加元素
al.add("java01");
al.add("java02");
al.add("java03");
//在指定位置添加元素
al.add(1,"java09");
//删除指定位置元素
al.remove(2);
//修改元素
al.set(2,"java007");
//通过角标获取元素
al.get(1)
sop(al);
//获取所有元素
for (int x = 0;x<al.size() ;x++ )
{
System.out.println("al("+x+")="+al.get(x));
}
Iterator it = al.iterator();
while (it.hasNext())
{
sop("next:"+it.next());
}
//通过indexOf获取对象的位置
sop("index="+al.indexOf("java02"));
List sub = al.subList(1,3);获取1角标到3角标位置的元素,含头不含尾
sop("sub="+sub);
}
}




Vector实例演示:
import java.util.*;
/*
枚举就是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();
NoSuchElementException 删除或获取的元素不存在异常


在JDK1.6出现了替代方法
offerFirst();添加
offerLast();
peakFirst();获取
peakLast();
pollFirst();删除
pollLast();
删除或获取的元素不存在会返回null


练习:使用LinkList模拟一个堆栈或者队列数据结构.
堆栈先进后出,队列先进先出
import java.util.*;
class DuiLie
{
private LinkedList link;
DuiLie()
{
link = new LinkedList();
}
public void myAdd(Object obj)
{
link.addFirst(obj);
}
public Object myGet()
{
return link.removeLast();
}
public boolean isNull()
{
return link.isEmpty();
}
}
class LinkedListTest
{
public static void main(String[]args)
{
DuiLie d1 = new DuiLie();
d1.myAdd("java01");
d1.myAdd("java02");
d1.myAdd("java03");
d1.myAdd("java04");
while (d1.isEmpty())
{
System.out.println(d1.myGet());
}
}
}


练习:去除ArrayList集合中的重复元素
import java.util.*;
class ArrayListTest
{
public static void main(String[]args)
{
ArrayList a1 = new ArrayList();\
a1.add("java01");
a1.add("java01");
a1.add("java02");
a1.add("java04");
a1.add("java02");
a1.add("java03");
a1 = SingleEment(a1);
}

public static ArrayList SingleEment(ArrayList a1)
{
//定义一个临时容器
ArrayList newA1 = new ArrayList();
Iterator it = a1.iterator();
while (it.hasNext())
{
Object obj = it.next();
if (!newA1.contains(obj))
newA1.add(obj);
}
return newA1;
}
}




练习:将自定义对象作为元素存到ArrayList集合中,并去除重复元素.
比如:存人对象,同姓名年龄视为同一个人,为重复元素
思路:1,对人描述,将数据封装进入对象.2,定义容器,将人存入.3,取出.
List集合判断元素是否相同,依据是元素的equals方法.
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)//复写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 ArrayListTest
{
public static void main(String[]args)
{
ArrayList a1 = new ArrayList();
a1.add(new Person("lisi01",29));//a1.add(Object obj);//Object obj = new Person("lisi01",29);
a1.add(new Person("lisi02",39));
a1.add(new Person("lisi03",49));
a1.add(new Person("lisi04",19));
a1 = singleElement(a1);
Iterator it = al.iterator();
while (it.hasNext())
{
Person p = (person)it.next();//Object obj = it.name; Person p = (Person)obj;
sop(p.getName()+"--"p.getAge());
}
}
public static ArrayList SingleEment(ArrayList a1)
{
ArrayList newA1 = new ArrayList();
Iterator it = a1.iterator();
while (it.hasNext())
{
Object obj = it.next();
if (!newA1.contains(obj))
newA1.add(obj);
}
return newA1;
}


练习:往HashSet集合中存入自定义对象
姓名和年龄相同为同一个人,视为重复元素


import java.util.*;
class HashSetText
{
public static void sop(Object obj)
{
System.out.println(obj);
}
public static void main(String[]args)
{
HashSet hs = new HashSet();
hs.add(new person("a1",11));
hs.add(new person("a2",12));
hs.add(new person("a3",13));
hs.add(new person("a2",12));
Iterator it = hs.iterator();
while (it.hasNext())
{
Person p = (person)it.next();
sop(p.getName()+"--"p.getAge());
}
}
}
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;
}
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;
}

}