黑马程序员java基础知识之集合Collection
2015-01-23 09:02
603 查看
------- android培训、java培训、期待与您交流！ ----------
集合框架：collection
--List：元素是有序的，元素可以重复，因为该集合体系有索引
--ArrayList：底层使用数组结构；查询速度很快，增删较慢，线程不同步
--LinkList：底层使用链表结构；增删速度快，查询速度慢
--Vector：底层是数组数据结构，线程同步
--Set：元素无序，不可以重复
--HashSet：底层数据结构是哈希表
--TreeSet
这些容器对数据的存储方式都有所不同，所以将这些存储方式称之为数据结构
1.collection集合中的增删改查
元素的取出：Iterator 迭代器
迭代器的for循环写法：
2.List集合：特有方法，可以操作角标的方法都是该体系特有的方法
Vector的枚举方法
LinkedList :特有方法：addFirst,addLast;getFirst,getLast,获取元素，但不删除元素;removeFirst,removeLast获取元素，元素被删除
但当集合为空的时候，remove 和get都会产生异常，所以在JDK1.6有了替代办法，用offer替代add,用peek替代get,用poll替代remove，此时集合如果为空，返回null
模拟一个队列的数据结构
练习：ArrayList练习：去除集合中的重复元素
AaaryList练习2：将自定义对象作为元素存入ArrayList集合中，去除相同元素。存人对象，名称相同视为同一个人
注：contains ,remove底层都是用的equals方法，只比较地址值
3.set集合
HashSet集合的应用：无序性，取进和取出的顺序不一样。其取出元素只有迭代器一种方法
练习：往HashSet中存入自定义对象，姓名和年龄相同为同一个人
因此，其判断元素是否存在以及删除元素的判断依据都是hashCode值和equals方法
集合框架：collection
--List：元素是有序的，元素可以重复，因为该集合体系有索引
--ArrayList：底层使用数组结构；查询速度很快，增删较慢，线程不同步
--LinkList：底层使用链表结构；增删速度快，查询速度慢
--Vector：底层是数组数据结构，线程同步
--Set：元素无序，不可以重复
--HashSet：底层数据结构是哈希表
--TreeSet
这些容器对数据的存储方式都有所不同，所以将这些存储方式称之为数据结构
1.collection集合中的增删改查
import java.util.*;
class CollectionDemo
{
public static void main(String[] args)
{
ArrayList al=new ArrayList(); //创建一个集合容器
//添加元素
al.add("java01");
al.add("java02");
al.add("java03");
al.add("java04");
//获取个数，集合长度。
sop("size:"+al.size());
//打印集合
sop(al);
//删除元素
al.remove("java02");
//打印集合
sop(al);
//判断元素
sop(al.contains("java03"));
sop(al.isEmpty());
}
public static void method_2()
{
ArrayList al1=new ArrayList();
al1.add("java01");
al1.add("java02");
al1.add("java03");
al1.add("java04");
ArrayList al2=new ArrayList();
al2.add("java01");
al2.add("java02");
al2.add("java05");
al2.add("java06");
al1.retainAll(al2); //取交集，al1中只保存和al2中相同的元素
al1.removeAll(al2); //将al1中与al2相同的元素去掉
sop("al1:"+al1);
sop("al2:"+al2);
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}元素的取出：Iterator 迭代器
import java.util.*;
class CollectionDemo2
{
public static void main(String[] args)
{
getMethod();
}
public static void getMethod()
{
ArrayList al=new ArrayList(); //创建一个集合容器
//添加元素
al.add("java01");
al.add("java02");
al.add("java03");
al.add("java04");
Iterator it=al.iterator(); //获取迭代器，用于取出集合中的元素
while(it.hasNext()) //判断是否有元素
{
sop(it.next()); //打印出元素
}
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}迭代器的for循环写法：
for(Iterator it=al.iterator;it.hasNext(); )
{
<span style="white-space:pre"> </span>sop(it.next());
}2.List集合：特有方法，可以操作角标的方法都是该体系特有的方法
import java.util.*;
class ListDemo
{
public static void main(String[] args)
{
ArrayList al= new ArrayList();
//添加元素
al.add("java01");
al.add("java02");
al.add("java03");
al.add("java04");
sop("原集合是："+al);
ListIterator li=al.listIterator(); //Iterator 只能其自身方法操作元素，比如取出删除，但要想用到添加和修改，就需要子接口ListIterator
while(li.hasNext())
{
Object obj= li.next(); //接收遍历出来的元素
if(obj.equals("java02"))
li.set("java006"); //替换元素
}
sop(al);
/*
Iterator it=al.iterator();
while(it.hasNext())
{
Object obj=it.next();
if(obj.equals("java02"))
{
it.remove();
sop(obj);
}
}
*/
}
public static void sop(Object obj)
{
System.out.println(obj);
}
public static void method_1()
{
ArrayList al= new ArrayList();
//添加元素
al.add("java01");
al.add("java02");
al.add("java03");
al.add("java04");
sop("原集合是："+al);
//在指定位置添加元素
al.add(1,"java09");
sop("现在的集合是："+al);
//删除指定位置的元素
al.remove(2);
sop(al);
//修改元素
al.set(1,"java009");
sop(al);
//通过角标获取元素
sop(al.get(1));
//获取所有元素
for(int x=0;x<al.size();x++) //for循环遍历元素
{ sop(al.get(x));}
Iterator it= al.iterator(); //迭代器遍历元素
while(it.hasNext())
{
sop(it.next());
}
sop(al.indexOf("java02")); //获取元素角标
List sub=al.subList(1,3); //获取指定位置的元素集合，包含1不包含3
sop(sub);
}
}Vector的枚举方法
import java.util.*;
class VictorDemo
{
public static void main(String[] args)
{
Vector va=new Vector();
va.add("java01");
va.add("java02");
va.add("java03");
va.add("java04");
Enumeration en=va.elements(); //枚举获取元素
while(en.hasMoreElements())
{
System.out.println(en.nextElement());
}
}
}LinkedList :特有方法：addFirst,addLast;getFirst,getLast,获取元素，但不删除元素;removeFirst,removeLast获取元素，元素被删除
但当集合为空的时候，remove 和get都会产生异常，所以在JDK1.6有了替代办法，用offer替代add,用peek替代get,用poll替代remove，此时集合如果为空，返回null
import java.util.*;
class LinkListDemo
{
public static void main(String[] args)
{
LinkedList li=new LinkedList(); //新建一个LinkedList对象
li.addFirst("java01"); //将元素添加到第一个位置
li.addFirst("java02");
li.addFirst("java03"); //将元素添加到第一个位置
li.addFirst("java04");
sop(li.removeFirst());
/*
while(!li.isEmpty())
{
sop(li.removeFirst());
}
*/
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}模拟一个队列的数据结构
//使用LinkedList模拟一个堆栈或者队列的数据结构
import java.util.*;
class LinkedListTest
{
public static void main(String[] args)
{
Duilie dl=new Duilie(); //新建一个队列对象
dl.Myadd("java01"); //运用自定义的添加方法添加元素
dl.Myadd("java02");
dl.Myadd("java03");
dl.Myadd("java04");
while(!dl.isNull())
{
sop(dl.Myget()); //运用自定义的get方法，获取元素
}
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
class Duilie //自定义一个队列类
{
private LinkedList link; //声明一个LinkedList链表变量
Duilie() //构造函数
{
link=new LinkedList(); //初始化link
}
public void Myadd(Object obj) //自定义一个增加元素的方法
{
link.addFirst(obj);
}
public Object Myget() //自定义一个获取元素的方法
{
return link.removeLast();
}
public boolean isNull() //判断是否为空
{
return link.isEmpty();
}
}练习：ArrayList练习：去除集合中的重复元素
import java.util.*;
class ArrayListTest
{
public static void main(String[] args)
{
ArrayList al=new ArrayList();
al.add("java01");
al.add("java02");
al.add("java03");
al.add("java02");
al.add("java05");
sop(al);
al=singleElement(al);
sop(al);
}
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; //将新集合返回
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}AaaryList练习2：将自定义对象作为元素存入ArrayList集合中，去除相同元素。存人对象，名称相同视为同一个人
注：contains ,remove底层都是用的equals方法，只比较地址值
import java.util.*;
class Person //定义一个Person类
{
//声明name,age变量
private String name;
private int age;
Person(String name,int age) //构造函数
{
//将name,age作用于整个类中
this.name =name;
this.age=age;
}
public boolean equals(Object obj) //构造属于Person的比较方法
{
//如果obj不属于person类型，就返回假
if(!(obj instanceof Person))
return false;
//属于peron类型，则说明两个对象相等
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 ArrayListTest2
{
public static void main(String[] args)
{
ArrayList al=new ArrayList();
al.add(new Person("lise1",31));
al.add(new Person("lise2",32));
al.add(new Person("lise1",31));
al.add(new Person("lise2",32));
al=singleElement(al);
Iterator it=al.iterator(); //创建迭代器
while(it.hasNext()) //迭代集合中内容
{
Person p=(Person)it.next();
System.out.println(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; //将新集合返回
}
}3.set集合
HashSet集合的应用：无序性，取进和取出的顺序不一样。其取出元素只有迭代器一种方法
import java.util.*;
class HashSetDemo
{
public static void main(String[] args)
{
HashSet hs=new HashSet(); //新建一个hashSet集合
hs.add("java01");
hs.add("java02");
hs.add("java02");
hs.add("java01");
Iterator it=hs.iterator(); //获取迭代器，注意，hashSet取出元素只有迭代器一种方法
while(it.hasNext())
{
System.out.println(it.next());
}
}
}练习：往HashSet中存入自定义对象，姓名和年龄相同为同一个人
import java.util.*;
class HashSetTest
{
public static void main(String[] args)
{
HashSet hs=new HashSet(); //新建一个hashSet集合
hs.add(new Person("lise1",31));
hs.add(new Person("lise2",32));
hs.add(new Person("lise1",31));
hs.add(new Person("lise2",32));
Iterator it=hs.iterator(); //获取迭代器，注意，hashSet取出元素只有迭代器一种方法
while(it.hasNext())
{
Person p=(Person)it.next();
System.out.println(p.getName()+"::"+p.getAge());
}
}
}
class Person //定义一个Person类
{
//声明name,age变量
private String name;
private int age;
Person(String name,int age) //构造函数
{
//将name,age作用于整个类中
this.name =name;
this.age=age;
}
public int hashCode() //重写hashCode方法，集合就会根据哈希值不同保证元素唯一性
{
return name.hashCode()+age;
}
public boolean equals(Object obj) //构造属于Person的比较方法
{
//如果obj不属于person类型，就返回假
if(!(obj instanceof Person))
return false;
//属于peron类型，则说明两个对象相等
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;
}
}hashSet保持元素唯一性的原理：通过hashCode和equals方法来完成，如果元素hashCode相同，则调用equals方法，因为调用equals方法会比较慢，所以最好保持hashCode的唯一性因此，其判断元素是否存在以及删除元素的判断依据都是hashCode值和equals方法
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- 黑马程序员学习log第五篇基础知识：JAVA的面向对象之集合总结
- 黑马程序员----------java基础知识加强之集合总概述
- 黑马程序员——Java基础——集合类、Collection、List体系、集合框架LinkedList操作等
- 黑马程序员——java基础——集合框架（1）Collection
- 黑马程序员——java基础知识之泛型、集合（Map、工具类等）
- 黑马程序员——Java基础——集合(上)之Collection
- 黑马程序员 Java基础知识总结-j集合框架
- 黑马程序员——JAVA基础之简述集合collection
- 黑马程序员_java基础6-集合框架Collection和泛型
- 黑马程序员_Java第14天知识总结_集合类（集合框架）_Collection_迭代器_List_Set_HashSet
- 黑马程序员——java基础之集合框架（Collection 和 Map)
- 黑马程序员-JAVA基础-Java 集合之Collection 接口和遍历方法
- 黑马程序员——Java基础知识（集合框架（上））
- 黑马程序员——Java基础知识——集合框架、集合工具类、Arrays
- 黑马程序员——Java集合基础知识之Map
- 黑马程序员java基础集合知识整合
- 黑马程序员--集合框架知识总结和泛型--java学习日记7（基础知识）
- 黑马程序员————java基础---------集合之Collection与List
- 黑马程序员—java基础_集合Collection
- 黑马程序员 Java基础之 集合框架（collection）