黑马程序员——java基础知识篇——>集合

-----------android培训、java培训、java学习型技术博客、期待与您交流！------------

一、集合概述

集合的特点：

1 用于存储对象的容器

2 集合的长度是可变的

3 集合中不可以存储基本数据类型值

Collection

|--List:元素是有序的，元素可以重复，因为该集合体系有索引

|--ArrayList：底层的数据结构使用的是数组结构；特点查询速度快，增删较慢，线程不同步

|--默认长度是10，再添加的话就new一个新的数组，长度延长到50%，并把新数组和老数
组放到新数组中

|--LinkedList：底层使用的是链表数据结构：增删较快，查询较慢

|--Vector：底层是数组数据结构，线程同步(v1.0版本出现的)和ArrayList一样但是ArrayList是(
v1.2版本出现的)

|--被ArrayList替代了。多线程时也不用，用ArrayList加锁

|--枚举Enumeration和Iterator迭代器用法相同

|--Set:元素无序，元素不可以重复

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

增：add(index element);

addAll(index Collection);

删：remove(index);

改：set(index,element);

查：get(index);

subList(from,to)

listIterator();

获取：indexOf("java02")
通过indexOf获取元素的具体角标

基本方法示例：

public class ListDemo1 {

/**
* @param args
*/
public static void main(String[] args) {
ArrayList al=new ArrayList();
al.add("java01");
al.add("java02");
al.add("java03");
al.add("java04");
sop("原集合是："+al);
//在指定位置添加元素
al.add(1,"java09");
//删除指定位置元素
//al.remove(2);
//修改元素
al.set(2,"java07");
//通过角标获取元素
sop("get(1):"+al.get(1));
//获取所有元素
for(int x=0;x<al.size();x++){
al.get(x);
}
//获取所有元素；迭代器
Iterator it=al.iterator();
while(it.hasNext()){
sop("next:"+it.next());
}
//List集合特有的取出元素方式
for(int x=0;x<al.size();x++){
System.out.println(al.get(x));
}
//通过indexOf获取元素的具体角标
sop(al.indexOf("java02"));
//获取角标之间的元素;含头不含尾
List sub=al.subList(1,3);
sop(sub);
sop(al);
}
public static void sop(Object obj){
System.out.println(obj);
}
}

ArrayList集合示例：去除重复元素

public class ArrayListTest1 {
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("java02");
al.add("java01");
al.add("java02");
al.add("java01");
al.add("java06");
al=getSingle(al);
sop(al);

}
public static ArrayList getSingle(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 class GatherBsae1 {

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
ArrayList al=new ArrayList();
al.add("java01");
al.add("java02");
al.add("java03");
al.add("java04");
//准备在Iterator迭代器中操作元素;Iterator迭代器没有添加功能
/*		Iterator it=al.iterator();
while(it.hasNext()){
Object obj=it.next();
if(obj.equals("java02"))
it.remove();
System.out.println(obj);//将java02的引用从集合中删除了，但是30行的引用obj还在用所以能打印
}
System.out.println(al);*/
//在List集合中遍历时候通过ListInerator进行增删改查
ListIterator li=al.listIterator();
while(li.hasNext()){	//想反向取用hasPrevious用法一样
Object obj=li.next();
if(obj.equals("java03"))
//				li.add("java003");//在03后面添加003
li.set("java009");//把03修改成009
}
System.out.println(al);
}

}

Map集合：该集合存储键值对是一对一对向里存储的，而且要保证键的唯一性

Map<K,V> K:key 键

V:value 值

1添加

put(K key,V value)

putAll(Map<? extends K,? extends V> m)

2删除

clear()

remove(Object key)

3判断

containsValue(Object value)

containsKey(Object key)

isEmpty()

4获取

get(Object key)返回V

size()

values()

entrySet()

keySet()

Map<K,V>

|--Hashtable:底层结构是哈希表，不可以存入null键和null值，该集合是线程同步的，jdk1.0

|--hashMap：底层结构是哈希表，允许使用null键和null值，该集合是线程同步的，jdk1.2

|--TreeMap：底层是二叉树数据结构，线程不同步，可以用于给Map集合中的键进行排序

示例：

public class MapDemo1 {
public static void main(String[] args){
Map<String,String> map=new HashMap<String,String>();
map.put("01","zhangsan1");
map.put("02","zhangsan2");
map.put("03","zhangsan3");
//判断是否包含此键
sop(map.containsKey("02"));
//删除元素，如果打印的话会返回被删除键对应的值
sop(map.remove("01"));//zhangsan1
//通过输入键获取值
sop(map.get("01"));
//删除或者获取不存在的键时返回null
//获取map集合所有值
Collection<String> coll=map.values();
sop(coll);
System.out.println(map.put("04","zhangsan4"));//结果是null因为put方法返回原来键对应的值。没有就是null
System.out.println(map.put("04","wangwu"));	//结果是zhangsan4，<pre name="code" class="java">

示例：每一个学生都有对应的归属地

学生Student，地址String

学生属性：姓名，年龄

注意：姓名和年龄相同视为同一个学生

保证学生唯一性

class Student implements Comparable<Student>{	//防止对象过多让其具有自然顺序
private String name;
private int age;
Student(String name,int age){
this.name=name;
this.age=age;
}
public int compareTo(Student s){
int num=new Integer(this.age).compareTo(new Integer(s.age));
if(num==0)
return this.name.compareTo(s.name);
return num;
}
public int hashCode(){
return name.hashCode()+age*34;//让不同对象获取不同地址值
}
public boolean equals(Object obj){
if(!(obj instanceof Student))
throw new ClassCastException("类型不匹配");//ClassCastException是RunntimeExcepation子类
Student s=(Student)obj;
return this.name.equals(s.name)&&this.age==s.age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}

}
public class MapTest1 {

public static void main(String[] args) {
HashMap<Student,String> hm=new HashMap<Student,String>();
hm.put(new Student("zhangsan1",21),"beijing");
hm.put(new Student("zhangsan2",22),"shanghai");
hm.put(new Student("zhangsan3",23),"guangzhou");
hm.put(new Student("zhangsan4",24),"shenzhen");
//第一种取出方式
Set<Student> keySet=hm.keySet();
Iterator<Student> it=keySet.iterator();
while(it.hasNext()){
Student/*因为返回的是键*/ stu=it.next();
String addr=hm.get(stu);
System.out.println(stu.getName()+"--"+stu.getAge()+"--"+addr);
}
//第二种取出方式
Set<Map.Entry<Student,String>> entrySet=hm.entrySet();
Iterator<Map.Entry<Student,String>> iter=entrySet.iterator();
while(iter.hasNext()){
Map.Entry<Student,String> me=iter.next();//迭代出来
Student stu=me.getKey();
String addr=me.getValue();
System.out.println(stu.getName()+":"+stu.getAge()+":"+addr);
}

}
}

-----------android培训、java培训、java学习型技术博客、期待与您交流！------------