赵雅智 _java 集合类（2）

 set：

• 不区分元素顺序，不包含重复元素，最多一个Null元素
• 集中主要方法：（同Collection）
  • Bollean add(E o)：添加
  • boolean remove(Object o)：删除
  • boolean isEmpty()：是否为空
  • int size()：个数
• HashSet
  • 构造方法：
    • HashSet()
    • HashSet(<E> c)
  • 常用方法：
    • boolean contains(Object o) ：判断是否存在指定元素

      import java.util.*;
      class HashSetDemo 
      {
      	public static void main(String[] args) 
      	{
      		HashSet h = new HashSet();
      		h.add("abc1");
      		h.add("abc2");
      		h.add("abc3");
      		h.add(11);
      		h.add("abc1");
      		System.out.println(h);
      		System.out.println(h.size());//无序，元素不可重复
      		Iterator it = h.iterator();
      		while(it.hasNext()){
      			System.out.print(it.next()+"\t");
      		}
      		System.out.println();
      		System.out.println(h.contains("abc1"));
      	}
      }
      

      
      

键-值对型的集合

• 在Java中，专门建立以Hashtable为代表的“键-值”对类型对象。“键”--索引信息，而“值” –同索引值相对应的信息。
• 为什么要使用“键-值”对型的数据结构 
  • 原因：便于信息检索，提高在大数据量里检索信息的速度。
• 存在“索引冲突” 问题：对于散列函数，不同的“值”会得到相同的“键”，即不同的对象可能存放在同一个索引位置上。
• 解决方法：
  • 采用技术上的方法，例如设计出尽量降低冲突情况出现的散列函数，或者是指定冲突发生时的应对策略；
  • 根据待存储的数据量，适当提高Hash表的容量--用加大空间的代价，来取冲突发生的低概率 
•  Hashtable类=HashMap 
  • 前者不允许有空值空键，后者允许
  • 构造方法：
    • Hashtable()
    • Hashtable(int initialCapacity) 
    • Hashtable(int initialCapacity, float loadFactor)
    • Hashtable(<K,V> t) 使用泛型指定Hash表里键和值的类型
  • 其它方法
    • V put(K key, V value)：插入
    • V get(Object key)：“键”对应的“值”   ht.put(new Integer(1),new String(“Tom”));String str=ht.get(new Integer(1));
    • boolean containsKey(Object key) ：判断“键”是否存在于Hashtable对象中。boolean flag=ht.containsKey(newInteger(2));
    • boolean containsValue(Object value)： 判断“值” 是否存在于Hashtable中。 flag=ht.containsValue(“Rose”);
    • public boolean contains(Object value) ：同containsValue()方法。
    • public void clear() ：清空
    • equals()：比较
    • keySet()：保存到一个集中
    • V removed(Object key)：移除
    • values()：所用值放到Collection中
  • 如果针对同一个“键”设置了两次“值”，生效的是最后一次的动作。 返回旧值
  • 如果没有重复，添加新元素，返回null

    import java.util.*;
    class MapDemo 
    {
    	public static void main(String[] args) 
    	{
    		HashMap h = new HashMap();
    		h.put(1,"abc1");
    		h.put(2,"abc2");
    		h.put(3,"abc3");
    		h.put(4,"abc4");
    		System.out.println(h);//输出
    		System.out.println(h.get(2));//取某一个
    
    		h.put(3,"qq");
    		System.out.println(h);
    		System.out.println(h.put(3,"qq"));
    		System.out.println(h.put(5,"qq"));		
    		h.put(5,"abc5");
    		System.out.println(h);//键值
    		System.out.println(h.put(5,"abc5"));//qq
    
    		System.out.println(h.containsKey(5));//是否存在
    		System.out.println(h.remove(2));//删除并显示
    
    		//【键和值放进去如何取出来？】
    		//1.取出keySet()：将map中的所有key取出存到一个set集中
    		//2.有了set之后用迭代取出
    		Set k = h.keySet();
    		Iterator it = k.iterator();
    		while (it.hasNext())
    		{
    			//System.out.print(it.next()+"\t");//输出键，12345
    			Object o = it.next();
    			Object value = h.get(o);
    			System.out.println("ket="+o+",value="+value);
    		}
    	}
    }
    

    <span style="font-family:Arial, Helvetica, sans-serif;BACKGROUND-COLOR: rgb(255,255,255); WHITE-SPACE: normal"><img src="https://img-my.csdn.net/uploads/201204/26/1335434974_1544.png" alt="" /></span>

  • 往键值对存入自定义对象

    import java.util.*;
    class Person
    {
    	private String name;
    	private int age;
    	public Person(String name,int age){
    		this.name = name;
    		this.age = age;
    	}
    	public String getName(){
    		return name;
    	}
    	public int getAge(){
    		return age;
    	}
    }
    class DiyObject
    {
    	public static void main(String[] args) 
    	{
    		Person p1 = new Person("Jone",18);
    		Person p2 = new Person("Nacy",19);
    		Person p3 = new Person("Tom",18);
    		HashMap h = new HashMap();
    		h.put(1,p1);
    		h.put(2,p2);
    		h.put(3,p3);
    		h.put(4,new Person("Jack",20));
    		Person p = (Person)h.get(4);
    		System.out.println(p.getName()+"---"+p.getAge());
    	}
    }
    

    
    
  • 往集合中存入自定义对象

    //往集合中存入自定义对象
    import java.util.*;
    class Student
    {
    	private String name;
    	private int age;
    	public Student(String name,int age){
    		this.name=name;
    		this.age=age;
    	}
    	public String getName(){
    		return name;
    	}
    	public int getAge(){
    		return age;
    	}
    	public String toString(){
    		return name+":"+age;
    	}
    	public boolean equals(Object obj){
    		if(!(obj instanceof Student))
    			return false;
    		Student s=(Student)obj;
    		return this.name.equals(s.name) && this.age==s.age;
    	}
    }
    class  DiyObj2
    {
    	public static void main(String[] args) 
    	{
    		ArrayList al=new ArrayList();
    		Student s1=new Student("Jack",20);
    		Student s2=new Student("Tom",18);
    		Student s3=new Student("Nacy",21);
    		al.add(s1);
    		al.add(s2);
    		al.add(s3);
    		al.add(new Student("Smith",20));
    		al.remove(new Student("Smith",20));
    
    		Iterator it=al.iterator();
    		while(it.hasNext()){
    			Student s=(Student)it.next();
    			System.out.println(s.getName()+"-----"+s.getAge());
    		}	
    	}
    }

    

 枚举器：迭代

•  Java中有诸多不同类型的Java集合类（比如Vector或List），用同一类型的方式来访问其中的数据
• 枚举器接口 
  •  java.util.Iterator（枚举器接口）封装“无差别访问集合对象”的方法。 
  • 相关方法
    • 在每一个集合类（比如Vector或Hashtable等）里，都有一个iterator()方法，各集合对象可以通过该方法把遍历本类的控制权交给Iterator接口。
    • 在Iterator的接口里，提供了boolean hasNext()方法，判断出是否可以通过枚举器来得到集合对象中的下一个元素。
    • 在Iterator的接口里，提供了E next()方法，用来获取集合对象里的下一个元素，它返回的是一个泛型对象。

      import java.util.*;
      class TestIterator
      {
      	public static void main(String[] args) {
      		Vector <Integer> v = new Vector <Integer>();
      		for(int i = 0;i<5;i++){
      			v.addElement(new Integer(i));
      			}
      			Iterator it = v.iterator();
      			while(it.hasNext()){
      				System.out.print(it.next().toString()+"\t");
      			}
      	}
      }