集合框架和泛型

最新推荐文章于 2019-04-24 16:56:52 发布
最新推荐文章于 2019-04-24 16:56:52 发布
阅读量773 收藏 4
点赞数 2
分类专栏： Java 文章标签： 泛型
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/FST_XUAN/article/details/78170494
版权

集合框架概述

  1. 集合类的作用：存储对象，长度可变。
  2. 所属的包：java.util
  3. 集合框架常用体系 
     
    
Collection 
    
    |---List（有序）：通过重写equals()保证唯一性。 
    
        |---ArrayList（变长数组）：查询效率高，更新效率低。线程不同步 
    
        |---LinkedList（链表）：更新效率高，查询效率低。 
    
        |---Vector（数组）：线程同步，效率低，被ArrayList取代。 
    
    |---Set（唯一） 
    
        |---HashSet（哈希表）：重写hashCode()和equals()保证唯一性。 
    
        |---TreeSet（二叉树）：通过让元素具备比较性或让集合具备比较性保证唯一性和排序。 
    
Map 
    
    |---HashMap（哈希表）：允许使用null键null值，线程不同步，效率高。 
    
    |---TreeMap（二叉树）：可以按键排序，不同步。 
    
    |---HashTable（二叉树）：不允许使用null键null值，线程同步，效率低。
  4. 如何选择具体的集合类？
    1. 要求时间复杂度：List
      • 查询操作多：ArrayList
      • 更新操作多：LinkedList
    2. 要求空间复杂度：Set
      • 只要求唯一性：HashSet
      • 要求唯一、有序：TreeSet

Collection接口

  1. 共性方法（关于集合）

    1. 增：add(Object)
    2. 删：remove(Object)、clear()
    3. 查：size()、contains(Object)、isEmpty()
    4. 并：addAll(Collection)
    5. 交：retainAll(Collection)
    6. 差：removeAll(Collection)

  2. Iterator迭代器

    1. 为什么出现迭代器？

      由于Collection子接口下有的有索引有的没索引，不能像数组循环一样获取元素，因此必须有hasNext()和next()，两个方法只有一起使用时才有意义，因此将其封装成Collection的内部类，修饰为private并对外提供获取内部类对象的接口iterator()，返回类型是Iterator。比喻：Collection接口是娃娃机，Iterator是娃娃机的夹子，娃娃机夹子有抓取娃娃的操纵杆next()。

    2. 迭代器示例

      Iterator it = al.iterator();
while(it.hasNext())
{
    sop(it.next());
}

    3. 注意

      在迭代时不可以通过集合对象的方法操作集合中的元素，因为会发生并发修改异常，所以只能通过迭代器的方法操作元素。

  3. List接口

    1. List特有方法（关于索引） 
       
      
增：add(index,ele)、addAll(index,Collection) 
      
删：remove(index) 
      
改：set(index,ele) 
      
查：get(index)、indexOf(ele)、subList(from,to)、listIterator()

    2. ListIterator迭代器

      ListIterator相较于Iterator迭代器的作用：由于List集合有索引，因此可在迭代的同时使用ListIterator迭代器的增删改查方法对元素进行操作。方法：add(ele)、remove()、set(ele)、hasNext()、hasPrivious()。

      ListIterator li = al.listIterator();
while(li.hasNext())
{
    Object obj = li.next(); 
    if(obj.equals("haha"))
        li.add("hehe");     //利用迭代器进行集合的添加元素
}

    3. LinkedList特有方法（关于收尾结点）

      1.增：addFirst()、addLast()、
2.删：removeFirst()、removeLast()
3.查：getFirst()、getLast()
若集合中没有元素，会出现NoSuchElementException异常

JDK1.6出现的替代方法
1.增：offerFirst()、offerFirst()
2.删：peakFirst()、peakLast()
3.查：pollFirst()、pollLast()
若集合中没有元素，会返回null。

  4. Set接口

    1. HashSet保证唯一性依据：hashCode和equals()。先比较两个对象的hashCode是否相同，若不同，直接存储进集合；若相同，再用equals()比较是否是同一个对象，若不是就存储进集合，否则不存储。代码示例。

      import java.util.*;
class Person
{
    private String name;
    private int age;
    Person(String name,int age)
    {
        this.name = name;
        this.age = age;
    }

    //重写hashCode()
    public int hashCode()
    {
        return name.hashCode()+age;
    }

    //重写equals()
    public boolean equals(Object obj)
    {
        if(!(obj instanceof Person))
            return false;
        Person p = (Person)obj;

        return name.equals(p.name) && age == p.age;
    }

    public String getName()
    {
        return name;
    }
    public int getAge()
    {
        return age;
    }
}
class  HashSetDemo
{
    public static void main(String[] args) 
    {
        HashSet hs = new HashSet();

        hs.add(new Person("a1",11));
        hs.add(new Person("a2",12));
        hs.add(new Person("a2",12));    //重复元素
        hs.add(new Person("a3",13));


        for(Iterator it  = hs.iterator();it.hasNext();)
        {
            Person p = (Person)it.next();
            System.out.println(p.getName()+":"+p.getAge());
        }
    }
}

    2. TreeSet可实现元素排序，排序的两种方式

      • 让元素自身具备比较性：实现Comparable，重写compareTo()，使元素实现自然排序。
      • 让集合具备比较性：自定义比较器类，实现Comparator接口，重写compare()，传自定义比较器类的对象给集合的构造函数，让集合排序。应用场景：当使用别人的类，但比较性不是自己需要的时候。
      //第一种排序方式：让元素自身具备比较性，实现自然排序
import java.util.*;
class Person implements Comparable      
{
    private String name;
    private int age;
    Person(String name,int age)
    {
        this.name = name;
        this.age = age;
    }

    //重写compareTo方法
    public int compareTo(Object obj)
    {
        if(!(obj instanceof Person))
            throw new RuntimeException("不是人对象");
        Person p = (Person)obj;

        if(this.age > p.age)
            return 1;
        if(this.age == p.age)   //若主要依据相同，要比较次要依据
            return this.name.compareTo(p.name);
        return -1;
    }

    public String getName()
    {
        return name;
    }
    public int getAge()
    {
        return age;
    }
}
class TreeSetDemo 
{
    public static void main(String[] args) 
    {
        TreeSet ts = new TreeSet();

        ts.add(new Person("lisi01",22));
        ts.add(new Person("lisi02",25));
        ts.add(new Person("lisi03",22));
        ts.add(new Person("lisi03",22));    //重复元素
        ts.add(new Person("lisi04",23));

        for(Iterator it = ts.iterator();it.hasNext();)
        {
            Person p = (Person)it.next();
            System.out.println(p.getName()+":"+p.getAge());
        }
    }
}
      //第二种排序方式：让集合具备比较性
import java.util.*;
class MyComparator implements Comparator
{
    //重写compare方法
    public int compare(Object o1,Object o2)
    {
        Person p1 = (Person)o1;
        Person p2 = (Person)o2;

        int num = p1.getName().compareTo(p2.getName());
        if(num == 0)        //若主要依据相同，要比较次要依据
            return new Integer(p1.getAge()).compareTo(new Integer(p2.getAge()));
        return num;
    }
}
class TreeSetDemo1
{
    public static void main(String[] args) 
    {
        //传入比较器对象使集合具备比较性
        TreeSet ts = new TreeSet(new MyComparator());

        ts.add(new Person("lisi01",22));
        ts.add(new Person("lisi02",25));
        ts.add(new Person("lisi03",22));
        ts.add(new Person("lisi03",22));    //重复元素
        ts.add(new Person("lisi04",23));

        for(Iterator it = ts.iterator();it.hasNext();)
        {
            Person p = (Person)it.next();
            System.out.println(p.getName()+":"+p.getAge());
        }
    }
}

泛型

  1. 作用

    1. 将运行时期出现的问题ClassCastException转移到了编译时期，方便于程序员解决问题。
    2. 避免了强制转换麻烦。
    3. 一般在集合类中使用。
    import java.util.*;
class  GenericDemo
{
    public static void main(String[] args) 
    {
        //定义时就明确了要操作的类型
        ArrayList<String> al = new ArrayList<String>();

        //只能操作String类型
        al.add("abc01");
        al.add("abc02");
        al.add("abc03");

        for(Iterator<String> it = al.iterator();it.hasNext();)
        {
            String s = it.next();
            System.out.println(s);
        }
    }
}

  2. 泛型类

    使用场景：当类的对象要操作的类型一确定，成员方法操作的类型就明确，就可定义泛型类。

    /*
//泛型前做法
class Tool
{
    private Object obj;
    public void setObject(Object obj)
    {
        this.obj = obj;
    }
    public Object getObject()
    {
        return obj;
    }
}
*/

//泛型类
class Utils<T>
{
    private T t;
    public void setObject(T t)
    {
        this.t = t;
    }
    public T getObject()
    {
        return t;
    }
}

class GenericDemo2
{
    public static void main(String[] args) 
    {
        //泛型前做法
//      Tool t = new Tool();
//      t.setObject(new String("abc"));
//      String s = (String)t.getObject();   //需要转型
//      System.out.println(s);

        //泛型做法
        Utils<String> u = new Utils<String>();
        u.setObject(new String("abc"));
        String s = u.getObject();           //无需转型
        System.out.println(s);
    }
}

  3. 泛型方法

    使用场景：为了让类中的不同方法可以操作不同类型，就可以将泛型定义在法上，类似于重载。

    class Demo<T>
{
    public void show(T t)       //跟随类的泛s型
    {
        System.out.println("show:"+t);
    }
    public <Q> void print(Q q)  //方法上的泛型
    {
        System.out.println("print:"+q);
    }
}

class  GenericDemo3
{
    public static void main(String[] args) 
    {
        Demo<Integer> d = new Demo<Integer>();  //指定操作的类型是Integer

        d.show(new Integer(3));
        //d.show("abc");                        //编译出错，show()参数类型只能是Integer

        d.print(3);                             //print()参数类型任意
        d.print("abc");
    }
}

    静态方法的泛型只能定义在方法上，因为静态比对象先加载。

  4. 泛型限定

    1. 泛型的限定：? 通配符，代表任意类型
2. 泛型限定上限：<? extends E> 接收E或者E的子类型
3. 泛型限定下限：<? super E>> 接收E或者E的父类型
    //泛型限定上限
import java.util.*;
class GenericDemo4 
{
    public static void main(String[] args) 
    {
        TreeSet<Person> ts = new TreeSet<Person>(new Comp());
        ts.add(new Person("lisi1"));
        ts.add(new Person("lisi2"));
        ts.add(new Person("lisi3"));

        TreeSet<Student> ts1 = new TreeSet<Student>(new Comp());
        ts1.add(new Student("zhang1"));
        ts1.add(new Student("zhang2"));
        ts1.add(new Student("zhang3"));

        print(ts);
        print(ts1);
    }

    //泛型限定，只可以接收Person及其子类对象
    public static void print(TreeSet<? extends Person> al)  
    {
        for(Iterator<? extends Person> it = al.iterator();it.hasNext();)
        {
            //只能调用父类中的方法
            System.out.println(it.next().getName());
            //it.next().showName();     //编译出错，无法使用子类特有方法
        }
    }
}

class Person
{
    private String name;
    Person(String name)
    {
        this.name = name;
    }
    public String getName()
    {
        return name;
    }
}
class Student extends Person
{
    Student(String name)
    {
        super(name);
    }
    public void showName()
    {
        System.out.println(getName());
    }
}

//比较器泛型使用，可以比较Person和Person子类
class Comp implements Comparator<Person>    
{
    public int compare(Person p1,Person p2)
    {
        //只能用父类方法
        return p1.getName().compareTo(p2.getName());    
    }
}
    //泛型限定下限
import java.util.*;  
import stu.love.v.Demo11;  

//父类的比较器   <Person>  
class CompareByAge implements Comparator<Person>  
{  
    public int compare(Person s1,Person s2)  
    {  
        int num = new Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));  
        if(num==0)  
            return s1.getName().compareTo(s2.getName());  
        return num;  
    }  

}  

/*// 子类 特殊的 比较器  Student  
class ComByAge implements Comparator<Student>  
{  
    public int compare(Student s1,Student s2)  
    {  
        int num = new Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));  
        if(num==0)  
            return s1.getName().compareTo(s2.getName());  
        return num;  
    }  
}  

// 子类 特殊的 比较器 Teacher  
class ComByAge2 implements Comparator<Teacher>  
{  
    public int compare(Teacher s1,Teacher s2)  
    {  
        int num = new Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));  
        if(num==0)  
            return s1.getName().compareTo(s2.getName());  
        return num;  
    }  
}*/  

class Demo13   
{  
    //TreeSet<E>(Comparator<? super E> comparator) 定义比较器时，可以是E类型，还可以是E的父类型,E在创建集合对象时确定  
    public static void main(String[] args)   
    {  
        TreeSet<Student> t1 = new TreeSet<Student>(new CompareByAge());  
        t1.add(new Student("zhaosi",23));  
        t1.add(new Student("lisi",25));  
        t1.add(new Student("wangwu",20));  


        TreeSet<Teacher> t2 = new TreeSet<Teacher>(new CompareByAge());  
        t2.add(new Teacher("wang",38));  
        t2.add(new Teacher("lilaoshi",48));  
        t2.add(new Teacher("zhanglaoshi",58));  
    }  
}

Map接口

  1. 描述

    存储键值对，一个键对应一个值，当后添加的键与之前的键相同时，后添加的元素会覆盖之前的元素。

  2. 方法 
     
    
增：put(key,value)、putAll(Map) 
    
删：remove(key)、clear() 
    
获取：size()、get(key)、values()、entrySet()、keySet() 
    
判断：isEmpty()、containsKey(key)、containsValue(value)

  3. 获取元素的两种方式：keySet和entrySet()

    1. keySet()：获取Map集合的键集合
    2. entrySet()：获取Map集合的映射关系集合
    //keySet()和entrySet()用法案例
import java.util.*;
class MapDemo2 
{
    public static void main(String[] args) 
    {
        Map<String,String> map = new HashMap<String,String>();

        map.put("02","lisi2");
        map.put("01","lisi1");
        map.put("03","lisi3");
        map.put("04","lisi4");

        //1,通过keySet获取键的集合
        Set<String> keySet = map.keySet();
        for(Iterator<String> it = keySet.iterator();it.hasNext();)
        {
            //取出一个键
            String key = it.next(); 
            //通过键获取值            
            System.out.println(key+":"+map.get(key));   
        }

        //2，通过entrySet获取映射关系集合
        Set<Map.Entry<String,String>> entrySet = map.entrySet();
        for(Iterator<Map.Entry<String,String>> it1 = entrySet.iterator();it1.hasNext();)
        {
            //取出一个映射关系
            Map.Entry<String,String> me = it1.next();
            //通过映射关系获取键
            String key = me.getKey();
            //通过映射关系获取值
            String value = me.getValue();
            System.out.println(key+":"+value);
        }
    }
} 
    /*
    Map集合一键一值用例

    "yure"  Student("01","zhangsan")
    "yure"  Stduent("02","lisi")

    "jiuye"  Student("01" "wangwu")
    "jiuye"  Student("02" "zhaoliu")
    即一对多关系，由于Map是一对一关系，后会覆盖前，
    因此要将一对多化解为一对一：将值存储在集合中。
*/

import java.util.*;
class  MapDemo5
{
    public static void main(String[] args) 
    {
        //预热班
        List<Student> yure = new ArrayList<Student>();
        yure.add(new Student("01","zhangsan"));
        yure.add(new Student("02","lisi"));

        //就业班
        List<Student> jiuye = new ArrayList<Student>();
        jiuye.add(new Student("01","wangwu"));
        jiuye.add(new Student("02","zhaoliu"));

        //学校
        HashMap<String,List<Student>>  czbk = new HashMap<String,List<Student>>();
        czbk.put("yure",yure);      //学校有预热班和就业班
        czbk.put("jiuye",jiuye);

        //遍历czbk集合，获取所有教室
        for(Iterator<String> it  = czbk.keySet().iterator();it.hasNext();)
        {
            String roomName = it.next();                //获取一个键（教室名称）
            List<Student> room = czbk.get(roomName);    //通过教室名称获取学生集合
            System.out.println(roomName);   
            getInfos(room);         //输出每个学生的信息
        }
    }
    //遍历list集合中每个学生的信息
    public static void getInfos(List<Student> list)
    {
        for(Iterator<Student> it = list.iterator();it.hasNext();)
        {
            System.out.println(it.next());
        }
    }
}
class Student
{
    private String id;
    private String name;
    Student(String id,String name)
    {
        this.id = id;
        this.name = name;
    }
    public String toString()
    {
        return id+name;
    }
}

Collections 工具类

作用：由于List集合不能排序，Collections工具类提供了对List集合进行排序的方法和其他对集合进行操作的方法。

FST_XUAN
关注
  • 2
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
集合框架与泛型
weixin_40154786的博客
10-11 456
集合框架和泛型 本章技能目标 掌握集合框架包含的内容 掌握ArrayList和LinkedList的使用 掌握HashMap的使用 掌握Iterator的使用 掌握泛型集合的使用 1. 集合框架概述 Java集合框架为我们提供了一套性能优良、使用方便的接口和类，它们都位于java.util包中。Java集合框架包含的主要内容以及彼此之间的关系如图所示： 从上面的集合框架图可以看到，Java 集合框架主要包括两种类型的容器，一种是集合（Collection），存储一个元素集合，另一种是图（Map），存储
1、集合框架和泛型
-简简单单就好♥ﻬ‥
07-13 285
一、知识点：集合框架在不知道程序运行时会需要多少对象，或者需要更复杂的方式存储对象，可以使用Java集合框架***集合中不可以存放基础数据类型，只可以放引用数据类型。集合框架位于java.util包中————————————————————————————————1.1 接口(集合的父接口)Collection接口：储存一组不唯一，无序的对象(集合的子接口)List接口：储存一组不唯一，有序(插入...
java 集合框架和泛型
chen449757520的博客
09-06 515
//常用的集合类: Set(集):集合中的对象不按特定的方式排序,不允许元素重复 List(列表):集合中的对象按照索引位置排序,允许元素重复 Map(映射):集合中每一个元素都包含一对key和value对象,不允许key对象重复,值对象可以重复     Colllection集合的使用         //1.创建一个线性列表的集合         Collection co
Java集合框架和泛型机制
12-22
　JDK API中专门设计用来存储其他对象的类，一般称为对象容器类，简称容器类，这组类和接口的设计结构也被统称为集合框架（Collection Framework）。集合框架中容器类的关系如下图示 　主要从两方面来选择容器...
《集合框架及泛型》
11-08
BDQN ACCP 7.0 Java《集合框架及泛型》学习资料.part1
学士后Java集合框架和泛型课后习题答案
02-28
通过学习和练习这些内容，你可以深入理解Java集合框架的核心概念和泛型的应用，从而在编程实践中更加灵活和高效地处理数据。同时，不断的学习和实践是提升技能的关键，希望你能在Java世界中不断进步。
Java高级特性 第一章 集合框架和泛型
最新发布
10-23
"Java高级特性：集合框架和泛型" Java高级特性系列第一章：集合框架和泛型 Collections Framework是Java语言中一个基础的数据结构.framework，它提供了多种类型的数据结构，包括List、Set、Map等，帮助开发者更...
集合框架和泛型机制的解释
04-22
在集合框架中，泛型机制的引入则进一步提升了类型安全性和代码的简洁性。 首先，让我们深入了解一下Java集合框架。集合框架包含了多种类型的容器，如List、Set和Queue等，它们各自有不同的特性以满足不同场景的需求...
Java集合框架及泛型
10-11
集合框架及泛型的介绍和基础理解，方便大家了解集合框架及泛型。
Java集合框架与泛型详解
Iefegend的专栏
08-25 764
一、java集合框架 1、集合类与容器 为什么出现集合类？ 面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，就要对对象进行存储，集合就是存储对象最常用的一种方式。 数组和集合类同是容器，有何不同？ 数组元素既可以是基本数据类型的数据，也可以是引用数据类型的数据。而集合里只能存储引用数据类型。 数组一旦定义后，长度不可变。而集合的长...
集合框架和泛型——JAVA
Angels_Descent的博客
04-24 369
@月月鸟 集合 数组与集合的区别 数组可以存储基本数据类型或者引用数据类型，集合只能存储引用数据类型，如果存储基本数据类型，会自动转换为包装类型 。 数组在定义的时候，就会确定存储的数据类型，即只能存储一种数据类型，集合中如果没有泛型限制，默认存储的都是Object类型。 数组的长度是固定不变的，不能够进行自动增长，而集合是可以根据数据的多少进行自动增长。 List接口 1. 使用Arra...
Java集合框架与泛型基础
"Java基础技术文档涵盖了Java开发的核心概念，包括集合框架、线程以及相关的工具包。...这个Java基础技术文档涵盖了从集合框架到泛型，再到实用工具类的重要知识，对于理解和掌握Java编程的基础非常有帮助。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值