java集合框架

最新推荐文章于 2024-09-15 14:15:43 发布

goature

最新推荐文章于 2024-09-15 14:15:43 发布

阅读量123

点赞数

文章标签： java集合框架 set list map

本文链接：https://blog.csdn.net/gcdnf16/article/details/100150716

版权

List,Set,Map 是否继承自Collection接口？
你所知道的集合类都有哪些？主要方法？
说出ArrayList,Vector, LinkedList 的存储性能和特性？
Collection 和Collections 的区别？
List、Map、Set 三个接口，存取元素时，各有什么特点？

1、概念

为什么要使用集合框架？

数组：存在一系列相同数据类型，一旦创建后长度固定。

2、Collection接口

隶属包:java.util;

collection:集合的顶级的接口;

3、List接口及其实现类

List接口：

有序集合(也称为序列)。该界面的用户可以精确控制列表中每个元素的插入位置。用户可以通过整数索引(列表中的位置)访问元素，并搜索列表中的元素。

与集合不同，列表通常允许重复的元素

实现类：ArrayList、LinkedList

重点：ArrayList

实现类：ArrayList

实现原理：基于数组实现的，动态数组，初始化容量为10的数组，再次添加元素是会根据需要自动扩容；

有利于查找、遍历数据，不利于插入删除

常用方法：

方法名	返回值类型	描述
add(Object o)	boolean	在集合末尾添加元素
size()	int	返回集合列表中元素个数
get(int index)	Object	返回指定索引位置的元素，索引从零开始
removeAll(Collection col)	boolean	删除集合中的所有元素
contains(Object o)	boolean	判断集合中是否存在指定元素
remove(Object o)	boolean	从集合中删除指定元素
remove(int index)	Object	从集合中删除指定索引位置的元素
toArray()	数组	将集合转化为对象数组

示例：

public static void main(String[] args) {
//        步骤：
       /* 1、添加
            2、读取数据
             3、删除数据
             4、遍历显示
       */

        //创建对象:Object
        List list1=new ArrayList(5);

        //添加
        list1.add("姓名");
        list1.add("张三");
        list1.add(18);
        list1.add('男');
        list1.add(new Tiger("美洲虎", "美洲"));
        list1.add("隔壁老王");
        //读取数据
        Object o1= list1.get(0);
        Object o2= list1.get(1);

        System.out.println(o1);
        System.out.println(o2);

        System.out.println("数量:"+list1.size());

//        list1.remove("张三");//删除元素
//        list1.remove(1);//删除指定索引对应的元素
        System.out.println(list1.get(1));


        //遍历显示
        for (int i = 0; i < list1.size(); i++) {
           Object tmp= list1.get(i);
            System.out.println(tmp);

        }

        if(list1.contains("隔壁老王")){
            System.out.println("存在");
        } else{
            System.out.println("不存在");
        }

         //转换数组
        Object[] objs=list1.toArray();
        for (Object obj : objs) {
            System.out.println(obj);
        }

//        list1.clear();

        list1.removeAll(list1);
        System.out.println(list1.size());
    }

Vector

ArrayLis和Vector实现原理都一样；

ArrayList:线程不安全，效率高

Vector:线程安全，效率低；

LinkedList

实现原理：基于双向链表实现；

有利于插入删除，不利于查找遍历

存储特点：元素在内存中不是连续的，前一个元素存在一个指针指向后一个元素。

public static void main(String[] args)
{
    LinkedList list=new LinkedList();
    list.addFirst("西施");
    list.addFirst("西施");
    list.addFirst("西施");
    list.addFirst("西施");
    list.addFirst("西施");
    for(Object o:list)
    {
        System.out.println(o);
    }
}

4、Set接口及其实现类

特点：不允许重复的集合；无序的集合；

实现类：HashSet、TreeSet

HashSet

此类实现Set接口，由哈希表(实际为HashMap)支持

常用方法

方法名及说明	返回值类型
add(E e) 将指定的元素添加到此集合(如果尚未存在)	boolean
clear() 从此集合中删除所有元素	void
clone( ) 返回此HashSet实例的浅层副本，元素本身不被克隆	Object
isEmpty( ) 如果此集合不包含元素，则返回true	boolean
contains(Object o) 如果此集合包含指定的元素，则返回true	boolean
iterator( ) 返回此集合中元素的迭代器	Iterator<E>
remove(Object o) 如果存在，则从该集合中删除指定的元素	boolean
size( ) 返回此元素集合中的元素数(其基数)	int
spliterator( )	Spliterator<E>

实现原理：

public HashSet(){
    map=new HashMap<>();
}

示例

publlic static void main(String[] args)
{
        Set set=new HashSet();
        set.add("诸葛亮");
        set.add("孙武");
        set.add("孙斌");
        set.add("白起");
        set.add("岳飞");
        set.add("岳飞");
        set.add("霍去病")
         //取数据
         System.out.println(set);
    
    //迭代
    Iterator iterator=set.iterator();
    //判断是否有下一个元素
    while(iterator.hasNext())
    {
        String str=(String) iterator.next();
        System.out.println(str);
    }
    //foreach遍历
    for(Object o:set)
    {
        System.out.println(o);
    }
}

TreeSet

默认按照元素的自然顺序进行排序

public static void main(String[] args)
{
    Set set=new Treeset();
    set.add("bbb");
    set.add("ccc");
    set.add("aab");
    set.add("ddd");
    set.add("aac");
    set.add("caa");
    //迭代
    Iterator iterator=set.iterator();
    //判断是否有下一个元素
    while(iterator.hasNext())
    {
        //读取下一个元素
        String str=(String) iterator.next();
        System.out.println(str);
    }
}

TreeSet默认不能存储对象类型的数据，需要该对象实现Comparable接口

public class Food implements Comparable {
    private String type;
    private Integer  fat;

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    public Integer getFat() {
        return fat;
    }

    public void setFat(Integer fat) {
        this.fat = fat;
    }

    public Food(String type, Integer fat) {
        this.type = type;
        this.fat = fat;
    }

    public Food() {
    }

    @Override
    public String toString() {
        return "Food{" +
                "type='" + type + '\'' +
                ", fat=" + fat +
                '}';
    }

    //正数：A>B
    // 0 : A==B
    // 负数 :A<B
    @Override
    public int compareTo(Object o) {
        //要比较的食物对象
        Food food= (Food) o;
        return this.fat-food.getFat();
    }
}

测试：

public static void main(String[] args) {
        Set set=new TreeSet();
        set.add(new Food("面包", 300));
        set.add(new Food("巧克力", 1000));
        set.add(new Food("火腿肠", 200));
        set.add(new Food("泡面", 500));


        //迭代
        Iterator iterator=set.iterator();
        //判断是否有下一个元素
        while(iterator.hasNext()){
            //读取下一个元素
           Food food= (Food) iterator.next();
            System.out.println(food);
        }

     /*   //foreach遍历
        for (Object object : set) {
            System.out.println(object);
        }
*/
    }

5、Iterator迭代器

迭代器：依次去遍历集合中的每一个元素

常用方法：

hasNext( ) 如果迭代具有更多元素，则返回true

next( ) 返回迭代中的下一个元素

Iterator it=set.iterator();
while(it.hasNext())
{
    String str=(String)it.next();
    System.out.println(str);
}

6、Map接口及其实现类

Map接口：存储键值对

实现类：HashMap，HashTable

重点：HashMap

特点键值不能重复，可以为null，但只能有一个键值是null

public static void main(String[] args)
{
    Map map=new HashMap();
    map.put("豫","河南");
     map.put("冀", "河北");
     map.put("冀", "河北");
     map.put(null, "山东");
     map.put("鲁", "山东");
         //取数据
        Object object= map.get("豫");
        System.out.println(object);
        //删除数据
        map.remove("豫1");

        //遍历

        //获取键的集合
        Set set= map.keySet();
        Iterator iterator= set.iterator();
        while(iterator.hasNext()){
            String key = (String) iterator.next();
            System.out.println(key+":"+map.get(key));
        }

        //获取值的集合
        Collection collection= map.values();

        //获取键值对
     /*   for (Object entry : map.entrySet()) {
            //键值对
           Map.Entry entry1= (Map.Entry) entry;
            System.out.println(entry1.getKey()+"----"+entry1.getValue());
        }*/
         System.out.println(map);
}

7、集合中泛型的使用

为什么要使用泛型?

1、集合中默认的类型是Object类型，所有类型都可以存进去；存数据：装箱；其它类型-->Object类型

2、取数据的时候需要进行各种判断；取数据：拆箱；Object--->转换成其它类型；

泛型：参数化类型；将类型当作参数使用，对类型进行约束（限制）；

推荐使用泛型集合；

 //E:Element :元素：作用：类型占位符；实际使用时要指定具体的数据类型（引用类型）
public interface List<E> extends Collection<E> {

}

示例：

 public static void main(String[] args) {

        List<String> list=new ArrayList<>();//ctrl+alt+space
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");

        for (String s : list) {
            System.out.println(s);
        }

        List<Integer> list1=new ArrayList<>();
        list1.add(100);
        list1.add(200);

        List<Bird> list2=new ArrayList<>();
        list2.add(new Parrot("小八", "爱唱歌"));

    }

示例2：

public static void main(String[] args) {

        Map<String,Bird> map=new HashMap<>();

        map.put("B01", new Parrot("八哥1", "鹦鹉学舌"));
        map.put("B02", new Parrot("八哥2", "鹦鹉学舌"));
        map.put("B03", new Parrot("八哥3", "鹦鹉学舌")) ;
        map.put("B04", new Parrot("八哥4", "鹦鹉学舌"));

         //获取键集合
        Set<String> keys=map.keySet();
        Iterator<String> iterator=keys.iterator();
        while(iterator.hasNext()){
            //获取键
            String key=iterator.next();
            //根据键获取值
            Bird bird=map.get(key);

            System.out.println("key："+key+"值："+bird);
        }

    }