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 abi
 * 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----集合框架和泛型

泛型

集合框架

代码实例

猜你喜欢