欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页

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

程序员文章站 2022-05-23 15:17:23
...

泛型

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

  • 实现方法:

    • 泛型接口:public interface 接口名 { }
    • 泛型方法:public 返回值类型 方法名(E e){ }

集合框架

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

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

  • 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);
	}
}
相关标签: java基础