java----集合框架和泛型

泛型

• 作用：类型参数化，将类型进行参数传递达到动态确定类型的目的

• 实现方法：

  • 泛型接口：public interface 接口名 { }
  • 泛型方法：public 返回值类型 方法名（E e）{ }

集合框架

• 集合定义：一个解决数组固定长度缺陷的动态容器。集合中只能存放对象。

• 集合框架图
  

• Collection：单值保存根接口

  • 分类：按照重复有序，或者不重复无序分成两个接口：List集合 + Set集合 + Queue队列

  • 详解

    • List集合：有序可重复

      • 实现类：ArrayList + LinkedList
      • 实现类详解
        • ArrayList：使用最多。用于替代Vector，本质是动态数组。两者之间的区别在于：ArrayList线程不安全，但效率高；Vector线程安全，但效率低。
        • LinkedList:链状结构。因此在增加，删除时效率要比ArrayList要高，但查找和修改的效率要比ArrayList低。
        • Queue队列：详细以下博客：https://www.cnblogs.com/mercuryli/p/4636231.html

    • Set集合：无序不能重复

      • 实现类：HashSet + TreeSet
      • 实现类详解
        • HashSet：只能保证Set集合唯一，但不能保证有序。
        • TreeSet：不但可以保证Set集合的元素唯一，而且还能保证此时放入该容器的元素是有序的的。其实现类要求该容器元素所在的类实现Comparable，重写CompareTo（T t）方法，因为在对对象进行排序时，java类需要继承该接口，使用该方法。

  • 工具类：Collections是Collection集合的工具类

• Map：映射关系数据保存根接口。存放的是键值对。不允许重复数据。

  • 实现类：HashMap + TreeMap
  • 实现类详解：
    • HashMap：只保证不重复和无序。
    • TreeMap：不重复且有序

• Iterator：迭代器。遍历上述两类集合

• Set集合和Map集合的关系：Set集合底层实现依靠的是Map集合

• Properties类：是Map集合实现类HashTable的子类，因此间接地实现了Map集合

  • 方法：void load(InputStream inStream)
    从输入流中读取属性列表（键和元素对）。

代码实例

package com.xzy.FanXing;
/**
 * 
 * @author abi
 *泛型接口的定义
 * @param <T>
 */
public interface Fanx <T>{
	public T fan1(T t);
}

package com.xzy.FanXing;
/**
 * 
 * @author 
 * TreeSet所需要的类的定义
 * 
 */

public class Person implements Comparable<Person>{
	private String name;
	private int age;
	public Person() {
		super();
		// TODO Auto-generated constructor stub
	}
	public Person(String name, int age) {
		super();
		this.name = name;
		this.age = 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;
	}
	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + "]";
	}
	@Override
	public int compareTo(Person o) {
		return this.age > o.age ? 1:(this.age < o.age?-1:0);
	}
	
	
}

package com.xzy.FanXing;
import java.security.KeyStore.Entry;
/**
 * 集合框架实例测试
 */
import java.util.ArrayList;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
import java.util.TreeSet;

public class Test implements Fanx<String> {
	
	@Override
	//实现Fanx泛型接口里的方法
	public String fan1(String t) {
		// TODO Auto-generated method stub
		return t;
	}
	//定义泛型方法
	public  <E> void fan2 (E e) {
		System.out.println(e);
	}
	
	public static void main(String [] args) {
		
		Test test = new Test();
		System.out.println(test.fan1("接口泛型"));
		test.fan2("方法泛型");
		
		Person[] p = new Person[] {new Person("张三",36), new Person("李四",25),new Person("王二",34)};
		//集合connection
		List<Person> al = new ArrayList<Person>(); //用泛型将list规定为一种类型的集合
		//向ArrayList添加元素
		for(Person p1:p) {
			al.add(p1);
			
		}

		/**
		 *  HashSetSet集合
		 */
		Set<Person> st = new HashSet<Person>();
		//添加
		for(Person p1:p) {
			st.add(p1);
		}
		System.out.println(st.size());			//获取集合大小
		System.out.println(st.remove(p[0]));	//删除
		System.out.println(st.size());
		//更改
		if(st.contains(p[2]))
		{
			st.remove(p[2]);
			st.add(p[0]);
		}
		//iterator 遍历集合
		Iterator it = st.iterator();
		while(it.hasNext()) {
			System.out.println(it.next());
		}
		
		/**
		 * TreeSet集合
		 */
		Set<Person> st1 = new TreeSet<Person>();
		//增加
		for (Person person : p) {
			st1.add(person);
		}
		System.out.println(st1.size());
		System.out.println(st1.remove(p[1]));	//删除
		System.out.println(st1.size());
		
		//遍历
		Iterator it1 = st1.iterator();
		while(it1.hasNext()) {
			System.out.println(it1.next());
		}
	
		/**
		 * HashMap
		 */
		//创建HashMap（泛型必须为键-值对）
		Map<String,Integer> mp = new HashMap<String,Integer>();
		mp.put("1",6);
		mp.put("2", 36);
		mp.put("3", 46);
		mp.put("3", 69);
		System.out.println(mp.put("3", 69));//返回的是值
		System.out.println(mp.get("1"));//通过键来找值
		
		//普通遍历
		for(String key:mp.keySet()) {
			System.out.println("key:+"+key+"and value:"+mp.get(key));
		}
		
		//通过Map.entrySet使用iterator遍历key和value
		Iterator<Map.Entry<String,Integer>> it2 = mp.entrySet().iterator();
		for(Map.Entry<String, Integer> entry:mp.entrySet()) {
			System.out.println("key:+"+entry.getKey()+"and value:"+entry.getValue());
		}
		
		//容量较大时
		for(Map.Entry<String, Integer> entry:mp.entrySet()) {
			System.out.println("key:+"+entry.getKey()+"and value:"+entry.getValue());
		}
		
		//Properties
		Properties ps = new Properties();
		Map<String,String> mt = new Hashtable<String,String>();
		ps.setProperty("1", "12");
		System.out.println(" "+ps);
	}
}