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

时间：2023-02-18 15:15:33

-----------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学习型技术博客、期待与您交流！------------  
 


 

 
 




标签：
相关文章