集合框架 List，Set，Map和泛型

最新推荐文章于 2022-05-10 13:41:50 发布

_清酒暖风Warmsake

最新推荐文章于 2022-05-10 13:41:50 发布

阅读量452

点赞数

分类专栏：笔记文章标签： java 框架泛型

本文链接：https://blog.csdn.net/ambiguous_/article/details/73477195

版权

笔记专栏收录该内容

12 篇文章 0 订阅

订阅专栏

集合

定义：Java中的集合类：是一种工具类，就像是容器，存储任意数量的具有共同属性的对象。

作用：集合可以：

1、在类的内部，对数据进行组织；
2、简单而快速的搜索大数量的条目；
3、有的集合接口，提供了一系列排列有序的元素，并且可以在序列中间快速的插入或者删除元素；
4、有的集合接口，提供了映射关系，可以通过关键字（key）快速的查找到对应的唯一对象，而这个关键字可以是任意类型。

与数组的对比：

1、数组的长度固定，集合长度可变，添加内容能自动扩容。
2、数组只能通过下标访问元素，下标类型只能是数字型，而有的集合可以通过任意类型查找所映射的具体对象。

List结构的集合

ArrayList类，LinkedList类。

ArrayList集合类，（无同步性，线程不安全）
底层使用数组存储（连续）
优点：遍历元素和随机访问元素的效率比较高
缺点：添加和删除需要大量移动元素效率低，按照内容查询效率低。

ArrayList的一些方法：

 ArrayList al = new ArrayList();  
    //将元素添加到al集合中的尾部  
    String str1 = "a";  
    al.add(str1);  
    String str2 = "b";  
    al.add(str2);  
    //将元素添加到al集合中的指定位置  
    String str3 = "c";  
    al.add(0, str3);  
    //可以添加重复元素  
    al.add(str1);  
    al.add(str2);  
    //按下标移除元素  
    al.remove(0);  
    //按元素移除集合中指定元素
    al.remove(str2);  
    //遍历输出  
    for(int i = 0; i < al.size(); i++){  
        //按下标获取元素,PS:因为get()方法返回的是Object类型的数据，所以要强制类型转换  
        String tmp = (String)al.get(i);  
        System.out.print(tmp + " ");  
    }  
    System.out.println();  
    //删除集合中所有元素  
    al.removeAll(al);

LinkeList集合类，线程安全。
底层使用链表存储，不连续。
优点：插入、删除元素时效率比较高
缺点：缺点：遍历和随机访问元素效率低下

LinkedList的一些方法：

    LinkedList list = new LinkedList();  
    //上述ArrayList所使用的方法LinkedList都能使用  
    //除此之外，还有以下这些  

    //将元素添加到集合的首部  
    list.addFirst(str1);  
    //将元素添加到集合的尾部  
    list.addLast(str2);  
    list.addLast(str3);  
    list.addLast(str1);  
    list.addLast(str2);  
    list.addLast(str3);  
    list.addLast(str1);  
    //移除集合首部元素  
    list.removeFirst();  
    list.remove();  
    //移除集合尾部元素  
    list.removeLast();  
    //移除与指定元素相同的，从首部到尾部之间第一个元素  
    list.removeFirstOccurrence(str1);  
    //移除与指定元素相同的，从首部到尾部之间最后一个元素  
    list.removeLastOccurrence(str2);  
    //获取首部元素  
    list.getFirst();  
    //获取尾部元素  
    list.getLast();  
    //移除所有元素  
    list.removeAll(list);

我们由代码可以看出，ArrayList和LinkedList的一些方法用法一样，之所以这样，是因为他们有共同的父类collection。

Set结构的集合类

HashSet类，TreeSet类

HashSet

HashSet底层是使用数组（hash算法）+链表实现的。
相等的对象的hash码值一定相等。
它不允许出现重复元素，不保证和政集合中元素的顺序。

HashSet一些常用的方法：

Set set=new HashSet<>();
//添加元素
set.add(“abc”);
set.add(“BCD”);
set.add(“ab”);
//清空所有元素
set.clear();
//是否包含某个元素，包含返回true
set.contains(“ab”);
//是否为空,是就返回true；
set.isEmpty();
//删除某个元素
set.remov(“abc”);
//使用iterator迭代器遍历。
Iterator iterator = set.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());

TreeSet:

底层采用二叉数的储存结构。
自带查询，查询的速度比List快。
查询速度没有HashSet快。
需要实现Comparable或者Compartor接口。
二叉树比较是否相等用从compareTo比较。

TreeSet一些常用的方法：

代码实例：

//先创建一个学生类，设置其属性的set值，并且重写toString方法
public class Student {
private String name;
private int age;
private boolean sex;// true 男 
public Student(String name, int age, boolean sex) {
    super();
    this.name = name;
    this.age = age;
    this.sex = sex;
}
public String getName() {
    return name;
}
public int getAge() {
    return age;
}
public boolean isSex() {
    return sex;
}

@Override
public String toString() {
    // TODO Auto-generated method stub
    return "姓名:"+name+",年龄:"+age+",性别:"+sex;
}

在创建另一个类实现TreeSet的一些方法。

    public class TestTree {
    public static void main(String[] args) {
    Set set=new TreeSet<>( new Comparator<Student>() {
    @Override
        public int compare(Student o1, Student o2) {  
            //实现compartor接口，重写compare方法进行比较
            // TODO Auto-generated method stub
            int c=o1.getAge()-o2.getAge();

            if(c!=0){
                return c;
            }
            c=o1.getName().compareTo(o2.getName());
            if(c!=0){
                return c;
            }
            return new Boolean(o1.isSex()).compareTo(o2.isSex());
        }
    } );
         //添加
        set.add(new Student("张三", 10, true));//true男生，false女生
        set.add(new Student("张三", 11, true));
        set.add(new Student("李四", 10, false));
        set.add(new Student("张三", 10, true));
        set.add(new Student("李四", 10, false));//
        //set.clear(); //清空
       //set.contains(o)//是否包含
       //set.remove(o); //删除
        print(set);
      }

  private static void print(Set set) {  //定义方法，进行遍历。
      // TODO Auto-generated method stub
      Iterator iterator = set.iterator();
       while(iterator.hasNext()){
        System.out.println(iterator.next());
        }
     }
 }

运行结果：

 姓名:战三,年龄:10,性别:true
 姓名:李四,年龄:10,性别:false
 姓名:战三,年龄:11,性别:true

根据结果发现，TreeSet也有去重的功能，实现compartor接口也可以进行排序。

Map（映射）

Map 是一种把键对象和值对象映射的集合，它的每一个元素都包含一对键对象和值对象。 Map没有继承于Collection接口从Map集合中检索元素时，只要给出键（Key）对象，就会返回对应的值（value）对象。
这里主要说一下HashMap和TreeMap。

HashMap

代码实例：

import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class TestMap{
    public static void main{
        Map map = new HashMap();
        map.put("a","abc");//添加元素
        map.put("b","bcd");
        map.put("c","cde");
        map.remove("a");//删除元素。参数是key
        print(map);
    }

    private static void print(Map map){  //定义遍历方法，使用keySet遍历
        Set keySet = map.keySet();
        for(Object key:keySet){
            System.out.println(key+"---->"+map.get(key));
        }
    }
}

TreeMap

代码实例：

import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
public class TestTreeMap {
public static void main(String[] args) {
    Map map=new TreeMap<>();
    map.put("b", "bcd");//增加
    map.put("d", "sd");
    map.put("a", "sd");
    map.remove("d");//删除
    print(map);
    }
    private static void print(Map map){  //定义遍历方法，使用keySet遍历
        Set keySet = map.keySet();
        for(Object key:keySet){
            System.out.println(key+"---->"+map.get(key));
        }
    }
}

输出结果：

a---->sd
b---->bcd
d---->sd

由结果可以发现，TreeMap可以对键值对的元素进行排序，并且可以去重。

泛型

泛型就是解决数据类型操作不统一产生的异常。
提高性能。
消除代码中许多强制类型转换出现的问题。

例如：

list<String> list = new ArrayList<String>();
尖括号里面是String类型的，所以集合中只能放String类型的。

代码实例：

List<String> list = new ArrayList<>();
list.add("asd");
list.add("abc");
list.add(23);//错误
list.add(new Student("张三"，10));//错误

list<>中定义了String类型的，所以只能添加字符串类型的元素。

Set<Student> set = new TreeSet<>();
set.add(new Student("张三",10));
set.add(new Student("李四",13));
set.add("王五");//错误

Set<>中定义了Student类型的，所以同样只能添加Student类型的。

_清酒暖风Warmsake

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
集合框架 List，Set，Map和泛型

集合定义：Java中的集合类：是一种工具类，就像是容器，存储任意数量的具有共同属性的对象。作用：集合可以：1、在类的内部，对数据进行组织；2、简单而快速的搜索大数量的条目；3、有的集合接口，提供了一系列排列有序的元素，并且可以在序列中间快速的插入或者删除元素；4、有的集合接口，提供了映射关系，可以通过关键字（key）快速的查找到对应的唯一对象，而这个关键字可以是任意类型。与数组的对比：1
复制链接

扫一扫