Java集合的简单使用

于 2021-01-05 00:07:46 发布
阅读量152 收藏
点赞数 2
分类专栏： Java的基础知识 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45595845/article/details/112191191
版权

常用集合的简单使用

目录：

集合基础知识
一、几个常用结合类的特点
二、ArrayList集合的简单使用（LinkedList类似）
三、HashSet的简单使用
四、TreeSet的简单使用
五、HashMap的简单使用

集合的基础知识：

Java集合类，又被称为容器，类似前面讲到的数组，但是有没有发现数组的特点：数组的长度是固定的，有时不明确需要多大容量的数组，定义太大了，浪费内存空间，定义小了，不够用咋办；在我们开发的时候带来的一些不便，而下面讲到的集合，长度是可变的，并且集合是专门存放对象的引用的

在学习集合的时候，先看一下常用的集合的层级关系：
在这里插入图片描述
1. Collection接口常用方法：

  • add (E e)----------------将指定的对象添加到该集合中
  • remove(Object obj)—将指定的对象从该集合中移除
  • isEmpty()----------------返回boolean值，判断集合是否为空
  • iterator()-----------------返回在集合的元素上进行的迭代的迭代器，用于遍历集合
  • size()---------------------返回int型值，获取集合的元素个数

2. TreeSet类增加的方法：

  • first() ---------------------返回Set的第一个（最小）元素
  • last()----------------------返回Set的最后一个（最大）元素
  • comparator()-----------返回对此Set集合进行排序的比较器，如果使用的是自然顺序，则返回null
  • 还有用的比较少的不提了

3. Map接口的常用方法：

  • put(K key,V value) ---------------向集合中添加指定的key与value的映射关系
  • containsKey(Object key)--------如果此集合有指定的key，则返回true
  • containsValue(Object value)—如果有一个或者多个key映射到指定值，则返回true
  • get(OIbject key)-------------------如果存在指定的key对象，则返回该对象对应的值，否则返回null.
  • keySet()-----------------------------返回该集合中的所有key对象形成的Set集合
  • value()-------------------------------返回该集合中所有值对象形成的Collection集合

一、几个常用集合类的特点：

1. ArrayList：

  • List的实现类，底层维护了一个数组，可以自动扩容，所以特点是随机访问速度非常快，有对应的下标即可查找到，但是增删可能需要进行复制数组的操作，这类操作性能较差。
  • 允许保存所有元素（重复元素），包括null。

2. LinkedList

  • List的实现类，底层是一个双向循环链表，可以自动扩容，特点是便于向集合中插入和删除元素，但是查询操作略低于ArrayList。
  • 允许保存重复元素。

3. HashSet

  • Set的实现类，由哈希表支持，不保证集合里面的迭代顺序，也就是顺序不固定。
  • 不可以存放相同的对象，允许存放null。

4. TreeSet

  • Set的实现类，还实现了java.util.SortedSet接口，因此TreeSet集合在遍历的时候按照自然顺序递增排序。
  • 不可以存放相同的对象

5. HashMap

  • HashMap是基于哈希表的Map接口的实现类，此类提供所有可选的映射操作，通过哈希表可以进行快速的查找操作。
  • 键不可重复，允许null值null键。

6. TreeMap

  • TreeMap不仅实现了Map接口，还实现了java.util.SortedMap接口，映射关系有一定的顺序，但是进行添加，删除，定位映射关系时，TreeMap性能比HashMap稍差。
  • 键不可重复，不允许键对象为null；

二、ArrayList集合的简单使用（LinkedList类似）

import java.util.ArrayList;

public class ArrayList_01 {
    public static void main(String[] args) {
        ArrayList coll = new ArrayList();

        //add()方法添加元素到集合中
        coll.add(1);
        coll.add("abc");
        coll.add(12.0);
        coll.add('A');
        coll.add(10.3f);

        //增强for循环遍历结合
        for (Object util : coll) {
            System.out.print(util+"   ");
        }
        System.out.println(" ");

        //remove()移除指定元素
        coll.remove("abc");

        //isEmpty()判断集合是否为空（true为空）
        boolean iE = coll.isEmpty();
        System.out.println("集合是否为空："+iE);

        //size()打印集合元素个数
        int num = coll.size();
        System.out.println("集合元素个数："+num);
    }
}

// 运行结果：
// 1 abc 12.0 A 10.3
// 集合是否为空：false
// 集合元素个数：4

三、HashSet的简单使用

import java.util.HashSet;

public class HashSet_01 {
    public static void main(String[] args) {
        //使用泛型，规定好存储的元素类型
        HashSet<Cat> coll = new HashSet();
        coll.add(new Cat("小花","black"));
        coll.add(new Cat("小草","black"));
        coll.add(new Cat("小花","black"));//new了同样参数的对象
        for (Cat cat : coll) {
            System.out.println(cat);
        }
    }
}

class Cat{
    String name;
    String color;

    public Cat(String name, String color) {
        this.name = name;
        this.color = color;
    }

    @Override
    public String toString() {
        return "Cat{" +
                "name='" + name + '\'' +
                ", color='" + color + '\'' +
                '}';
    }
}

//运行结果： 为啥会有重复的对象？
//Cat{name=‘小草’, color=‘black’}
//Cat{name=‘小花’, color=‘black’}
//Cat{name=‘小花’, color=‘black’}

看到上见面的运行结果没，new了一样参数的对象，但是这种匿名生成的对象，在内存空间其实是开辟了两个cat对象，所以可以显示写出对象名，再添加到集合中，但是new一个匿名的对象效率更高，有没有办法解决添加重复对象的问题呢？

答案是有的：重写对象的equals方法

package com.maihualong.blog;

import java.util.HashSet;

public class HashSet_01 {
    public static void main(String[] args) {
        //使用泛型，规定好存储的元素类型
        HashSet<Cat> coll = new HashSet();
        coll.add(new Cat("小花","black"));
        coll.add(new Cat("小草","black"));
        coll.add(new Cat("小花","black"));//new了同样参数的对象
        for (Cat cat : coll) {
            System.out.println(cat);
        }
    }
}

class Cat{
    String name;
    String color;

    public Cat(String name, String color) {
        this.name = name;
        this.color = color;
    }

    @Override
    public String toString() {
        return "Cat{" +
                "name='" + name + '\'' +
                ", color='" + color + '\'' +
                '}';
    }

    @Override
    public boolean equals(Object obj) {
        if(this==obj) return true;//添加同一个对象，返回true
        if(obj == null||getClass()!= obj.getClass()) return false;//添加null,或者元素类型不同，返回false
        Cat c = (Cat)obj;//强转为Cat类型，比较他们的名字以及颜色,把比较结果boolean值返回
        return this.name.equals(c.name)&&this.color.equals(c.color);
    }

    //重写hashcode方法，使得每次存数据的时候都返回相同的哈希值，
    // 这样重写每次存数据都会调用equals方法，判断是否为同一个对象，十分浪费性能，后面有进阶的重写方法
    @Override
    public int hashCode() {
        return 1;
    }
}

//运行结果：
//Cat{name=‘小花’, color=‘black’}
//Cat{name=‘小草’, color=‘black’}

四、TreeSet的简单使用

  1. 继承Comparable，并重写compareTo()方法

适用于自己编写的引用类型

import java.util.TreeSet;

public class TreeSet_01 {
    public static void main(String[] args) {
        TreeSet<Dog> coll = new TreeSet<>();
        coll.add(new Dog(6,"小花"));
        coll.add(new Dog(7,"小草"));
        coll.add(new Dog(9,"小狗1"));
        coll.add(new Dog(8,"小狗2"));

        for (Dog dog : coll) {
            System.out.println(dog);
        }
    }
}

//自己写的类继承了Comparable,并重写compareTo()方法
class Dog implements Comparable{
    int age;
    String name;

    public Dog(int age, String name) {
        this.age = age;
        this.name = name;
    }

    @Override
    public String toString() {
        return "Dog{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }

    //根据自己的需求重写compareTo()
    //返回1为这个元素比集合的大，返回-1为小，返回0则相同
    @Override
    public int compareTo(Object o) {
        Dog d = (Dog)o;
        return this.age-d.age;
    }
}

//运行结果：
//Dog{age=6, name=‘小花’}
//Dog{age=7, name=‘小草’}
//Dog{age=8,name=‘小狗2’}
//Dog{age=9, name=‘小狗1’}

  1. 继承Comparator，并重写compare()方法

适用于不可修改的类，比如jar包的类

import java.util.Comparator;
import java.util.TreeSet;

public class TreeSet_02 {
    public static void main(String[] args) {

        A a = new A();
        //定义一个TreeSet集合coll
        TreeSet<Student> coll = new TreeSet<>(a);
        //添加元素，年龄无序
        coll.add(new Student(18,"后羿"));
        coll.add(new Student(16,"小鲁班"));
        coll.add(new Student(19,"伽罗"));
        coll.add(new Student(33,"亚瑟"));
        coll.add(new Student(22,"张飞"));

        //增强for循环遍历集合
        for (Student s : coll) {
            System.out.println(s);
        }
    }
}

//class A充当Student类的比较器，继承Comparator,重写Compare()
class A implements Comparator{
    @Override
    public int compare(Object o1, Object o2) {
        Student s1 = (Student)o1;
        Student s2 = (Student)o2;
        return s1.age-s2.age;
    }
}

//假设Student是一个工具类，里面的源码不便修改，可以用另一个类充当比较器
class Student{
    int age;
    String name;

    public Student(int age, String name) {
        this.age = age;
        this.name = name;
    }

    @Override
    public String toString() {
        return "Student{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
}

//运行结果
//Student{age=16, name=‘小鲁班’}
//Student{age=18, name=‘后羿’}
//Student{age=19, name=‘伽罗’}
//Student{age=22, name=‘张飞’}
//Student{age=33, name=‘亚瑟’}

五、HashMap的简单使用

1：这样写会使集合的key可以是重复的，需要改进

import java.util.HashMap;

public class HashMap_01 {
    public static void main(String[] args) {
        //创建一个HashMap集合coll
        HashMap<Tower,String> coll = new HashMap<>();
        coll.put(new Tower(100,"铁塔"),"1900年");
        coll.put(new Tower(200,"大厦"),"1980年");
        coll.put(new Tower(800,"迪拜"),"1990年");
        coll.put(new Tower(300,"东方明珠"),"2010年");

        //调用get(Obiect key)方法，获取对应的value值
        String s = coll.get(new Tower(100,"铁塔"));
        
        //返回值为空，因为集合put了匿名的对象，
        // 每次new都在内存中生成新对象，导致集合判断key是不一样的，
        //所以取不出来
        System.out.println(s);
    }
}

class Tower{
    int hight;
    String name;

    public Tower(int hight, String name) {

        this.hight = hight;
        this.name = name;
    }

    @Override
    public String toString() {
        return "Tower{" +
                "hight=" + hight +
                ", name='" + name + '\'' +
                '}';
    }
}

//运行结果
//null

2：重写hashcode()和equals()方法，解决key重复问题

class Tower{
    int hight;
    String name;

    public Tower(int hight, String name) {

        this.hight = hight;
        this.name = name;
    }

    @Override
    public String toString() {
        return "Tower{" +
                "hight=" + hight +
                ", name='" + name + '\'' +
                '}';
    }
    
    //为了演示equals()被调用，简单粗暴返回一个固定值
    //实际开发不建议这样写
    @Override
    public int hashCode() {
        return 1;
    }

    //重写equals()方法
    @Override
    public boolean equals(Object obj) {
        if(this == obj) return true;
        if(getClass() != obj.getClass()) return false;
        Tower t = (Tower)obj;
        return t.hight==this.hight&&t.name.equals(this.name);
    }
}

//运行结果
//1900年

还有几个集合后续再说，但是这几个集合的简单使用一定要熟练掌握，再进行进阶的学习。

衣咧问
关注
专栏目录
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值