java之14天 Collection,Vectory,ArrayList集合 (一)
Collection集合框架
Collection的操作
Vector
ArrayList的使用
ArrayList的练习
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
/***
*Cellection
* |--List:元素是有序的,元素可以重复,因为该集合体系有索引.
* |--ArrayList :底层的数据结构使用的是数组结构,特点: (查询,修改)速度很快,但是(插入删除)很慢 ,线程不同步
* |--LinkedList :底层使用的是链表数据结构,特点: (查询,修改)慢,(插入,删除)快! 线程不同步
* |--Vector :元老级干部 1.0的时候 就是Vector天下,1.2后 集合框架才出来.
* 特点 :线程同步,
* 底层是数据结构是数组结构.被ArrayList替代了.
* 如果后期要用到同步的,那么也不使用vector,需要自己加锁.
*
* 数组结构 的 ArrayList 和 Vector 一般数组长度是不变的
* ArrayList:默认长度为10,以后使用 50%的增加,超过后,将原来的10个元素复制到 长度为15的数组中,然后再在后面添加新的元素(可变长度数组,就是不断new数组完成的)
* Vector:默认长度为 10,超过后100%延长,这样就变成了20,比较浪费空间
*
*
* |--Set : 元素是无序,元素不可以重复,该集合中没有索引.
*
* List:
* 特有方法: 凡是可以操作角标的方法都是该体系中特有的方法.
*
* 增
* add(index,element)
* addAll(index,Collection);
* 删
* remover(index);
* 改
* set(index,element);
* 查
* get(index)
* subList(from,to);
* listIterator();
*
* list集合特有的迭代器 叫做 listIterator 是Iterator的子接口.
*
* 在迭代时,不可以通过集合对象的方法操作集合中的呀un苏.因为会发生ConcurrentModificationException
*
* 所以,在迭代时,只能使用迭代器的方法操作元素,可是Iterator方法是有限的,只能对元素进行判断,取出,删除的操作.
* 如果想要其他的操作如,添加 修改 等就需要使用 listIterator 子接口
*
* 该接口只能通过list集合的listIterator 获取
*
*
*
*/
public class ListDemo {
public static void sop(Object obj){
System.out.println(obj);
}
public static void main(String[] args) {
method_1();
method_2();
}
public static void method_2(){
//演示列表迭代器
ArrayList al=new ArrayList();
al.add("java01");
al.add("java02");
al.add("java03");
sop("原集合:"+al);
//跌带动的时候 找到后想删除 发现 使用普通的 Iterator 不能做到
/*Iterator it=al.iterator();
while(it.hasNext()){
Object obj=it.next();
if(obj.equals("java02")){
//发现 有问题 .因为在使用it时候,同时对集合al进行了操作,这样就有可能出现安全问题
al.add("java08");
//it.remove(); //在使用 Iterator 的只能使用 Iterator的方法.
}
sop("obj="+obj);
}*/
//正向遍历
ListIterator li=al.listIterator();
while(li.hasNext()){
Object obj=li.next();
if(obj.equals("java02")){
li.add("java007");
}
}
sop("obj="+al);
//逆向遍历
while(li.hasPrevious()){
sop("previous:"+li.previous());//是否有前一个
}
}
public static void method_1(){
ArrayList al=new ArrayList();
al.add("java01");
al.add("java02");
al.add("java03");
sop("原集合:"+al);
//在制定的位置添加元素
al.add(1,"java09");
sop("添加:"+al);
//删除指定位置上的元素
al.remove(2);
sop("删除:"+al);
//修改元素
al.set(2, "java007");
sop("修改:"+al);
//通过角标获取元素
sop("get(1):"+al.get(1));
//获取所有元素
for(int x=0;x<al.size();x++){
System.out.println("al("+x+")="+al.get(x));
}
Iterator it=al.iterator();
while(it.hasNext())
it.next();
//通过indexOf获取对象的位置
sop("indexOf="+al.indexOf("java09"));
List sub=al.subList(1, 2);
sop("sub"+sub);
}
}
Collection的操作
/**
*集合类
* 1.add方法 的参数类型是Object,以便于接受任意类型对象
* 2.集合中存储的都是对象的引用 (地址)
*
* 什么是迭代器呢 ?
* 其实就是 集合的取出元素的方式.
*
*
*/
public class CollectionDemo {
public static void main(String[] args) {
base_method2();
method_get();
}
//取出元素
public static void method_get(){
ArrayList al=new ArrayList();
al.add("java01");
al.add("java02");
al.add("java03");
al.add("java04");
al.add("java05");
/*
*
Iterator it=al.iterator(); //获取迭代器 用于取出集合中的元素
while(it.hasNext())
sop(it.next());
*/
//这种有优势, 增加了 内存优化,使用完后 it就会被回收.
for(Iterator it=al.iterator();it.hasNext();){
sop(it.next());
}
}
//取交集 批量删除
public static void base_method2(){
ArrayList al=new ArrayList();
al.add("java01");
al.add("java02");
al.add("java03");
al.add("java04");
al.add("java05");
ArrayList al2=new ArrayList();
al2.add("java01");
al2.add("java02");
al2.add("java05");
al2.add("java06");
//al.retainAll(al2); //取交集,al中只会保留和 al2中相同的元素
al.removeAll(al2);// 一次删除一堆元素
sop("al1"+al);
sop("al2"+al2);
}
public static void base_method(){
//创建一个集合容器,使用Collection接口的子类.ArrayList
ArrayList al=new ArrayList();
al.add("java01");
al.add("java02");
al.add("java03");
al.add("java04");
al.add("java05");
//1.获取集合的长度
sop("size:"+al.size());
//2.打印集合
sop("原集合:"+al);
//3.删除元素
al.remove("java02");
sop("现集合:"+al);
//判断元素
sop("java03是否存在:"+al.contains("java03"));
sop("集合是否为空:"+al.isEmpty());
//清空集合
al.clear();
sop("现集合:"+al);
}
public static void sop(Object obj){
System.out.println(obj);
}
}
Vector
/**
* 元老级
* Vector类中 带有Element的就是 Vector的特有方法
*
* Enumeration 枚举 就是早起Vector特有的取出方式.
* 发现 枚举和 迭代器很像
*
* 其实枚举和 迭代器是一样的.
* 因为枚举的名称以及方法的名称都过长,所以被迭代器取代了 枚举郁郁而终了
*
*/
public class VectorDemo {
//Vector中 带有Element的就是 Vector的特有方法
public static void main(String[] args) {
// TODO Auto-generated method stub
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());
}
}
}
ArrayList的使用
/**
* 将自定义对象最为元素存储到ArrayList集合中,并除去重复元素
* 比如 :存人对象, 同姓名 同年龄,视为同一个人,为重复元素
*
* 思路:
* 1.对人描述,将数据封装进人对象
* 2.定义容器,将人存如
* 3.取出
*
* List判断元素是否相同,依据的是元素的equals
*
*/
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;
}
@Override
public boolean equals(Object obj) {
if(!(obj instanceof Person))
return false;
Person p=(Person)obj;
return this.getName().equals(p.getName()) && this.getAge()==p.age;
}
}
public class ArrayListDemo {
public static void main(String[] args) {
ArrayList al=new ArrayList();
al.add(new Person("admin",12));
al.add(new Person("BBBBB",12));
al.add(new Person("CCCCC",12));
al.add(new Person("admin",12));
al=singleElement(al);
Iterator it=al.iterator();
while(it.hasNext()){
//sop(it.next().getName()+"::"+it.next().getAge());//编译失败 父类引用指子类对象
Person p=(Person)it.next();
sop(p.getName()+":::"+p.getAge());
}
sop("remove 03:"+al.remove(new Person("BBBBB",12)));
sop(al);
}
public static void sop(Object obj){
System.out.println(obj);
}
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;
}
}
ArrayList的练习
/**
* 去除ArrayList中的重复元素
*/
public 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("java01");
al.add("java02");
al.add("java01");
al.add("java02");
al.add("java03");
sop("原集合:"+al);
sop(al=singleElement(al));
/*在迭代时循环中next调用一次,就要使用hasNext判断一次
Iterator it=al.iterator();
while(it.hasNext()){
System.out.println(it.next()+"..."+it.next());
}
*/
}
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;
}
}