您的位置 首页 java

Java集合入门,看这篇就够了

一、概述

Java中的集合框架大类可分为 collection 和Map;两者的区别如下:

  1. Collection是单列集合;Map是双列集合
  2. Collection中只有Set系列要求元素唯一;Map中键需要唯一,值可以重复
  3. Collection的数据结构是针对元素的;Map的数据结构是针对键的

二、 Collection体系:

List的特点:

  • List 代表一个元素有序、且可重复的集合,集合中的每个元素都有其对应的顺序索引。
  • List 允许使用重复元素,可以通过索引来访问指定位置的集合元素。
  • List 默认按元素的添加顺序设置元素的索引。
  • List 集合里添加了一些根据索引来操作集合元素的方法

Set的特点 :存取无序,元素不可以重复

List集合:

下面有ArrayList,LinkedList, Vector (已过时)

集合的的最大目的就是为了存取;List集合的特点就是存取有序,可以存储重复的元素,可以用下标进行元素的操作。

ArrayList:

底层是使用数组实现,所以查询速度快,增删速度慢

  public static void main(String[] args) {
        // 使用ArrayList进行添加和遍历
        List<String> list = new ArrayList<String>();

        list.add("a");
        list.add("b");
        list.add("c");

        // 第一种遍历方式,使用 迭代器 
         Iterator <String> it = list.iterator();
        while(it.hasNext()){
            String next = it.next();
            System.out.println(next);
        }
        System.out.println("-------------------");
        // 第二种遍历方式,使用 foreach 
        for (String str : list){
            System.out.println(str);
        }
    }
复制代码  

LinkedList:

是基于链表结构实现的,所以查询速度慢,增删速度快,提供了特殊的方法,对头尾的元素操作(进行增删查)。

使用LinkedList来实现栈和队列;栈是先进后出,而队列是先进先出

 package org.example.test;

import java.util.LinkedList;

/**
 * 利用LinkedList来模拟栈
 * 栈的特点:先进后出
 */public class Test12 {

    private LinkedList<String> linkList = new LinkedList<String>();

    // 压栈
    public void push(String str){
        linkList.addFirst(str);
    }

    // 出栈
    public String pop(){
        return linkList.removeFirst();
    }

    // 查看
    public String peek(){
        return linkList.peek();
    }

    // 判断是否为空
    public boolean isEmpty(){
        return linkList.isEmpty();
    }
}

class Test13 {
    public static void main(String[] args) {
        // 测试栈
        Test12 test12 = new Test12();
        test12.push("我是第1个进去的");
        test12.push("我是第2个进去的");
        test12.push("我是第3个进去的");
        test12.push("我是第4个进去的");
        test12.push("我是第5个进去的");
        // 取出
        while (!test12.isEmpty()){
            String pop = test12.pop();
            System.out.println(pop);
        }
        // 打印结果
        /*我是第5个进去的
        我是第4个进去的
        我是第3个进去的
        我是第2个进去的
        我是第1个进去的*/    }
}

复制代码  

LinkedList实现Queue:

 package org.example.test;
import java.util.LinkedList;

/**
 * 利用linkedList来实现队列
 * 队列: 先进先出
 */public class Test12 {

    private LinkedList<String> link = new LinkedList<String>();
    // 放入
    public void put(String str) {
        link.addFirst(str);
    }

    // 获取
    public String get() {
        return link.removeLast();
    }

    // 判断是否为空
    public boolean isEmpty() {
        return link.isEmpty();
    }
}

class Test13 {
    public static void main(String[] args) {
        // 测试队列
        Test12 queue = new Test12();
        queue.put("我是第1个进入队列的");
        queue.put("我是第2个进入队列的");
        queue.put("我是第3个进入队列的");
        queue.put("我是第4个进入队列的");
        // 遍历队列
        while (!queue.isEmpty()) {
            String str = queue.get();
            System.out.println(str);
        }
        // 打印结果
        /*我是第1个进入队列的
        我是第2个进入队列的
        我是第3个进入队列的
        我是第4个进入队列的*/    }
}
复制代码  

Vector:

因为已经过时,被ArrayList取代了;它还有一种迭代器通过vector.elements()获取,判断是否有元素和取元素的方hasMoreElements()nextElement()。

 public static void main(String[] args) {
    Vector<String> vector = new Vector<>();
    vector.add("a");
    vector.add("v");
    vector.add("d");
    Enumeration<String> elements = vector.elements();
    while (elements.hasMoreElements())
    {
        String nextElement = elements.nextElement();
        System.out.println(nextElement);
    }
}
复制代码  

还有一些基本操作:

 public static void main(String[] args) {
    List<String> list = new ArrayList<String>();
    list.add("b");//第一个,索引下标0
    list.add("d");//索引下标1
    list.add("c");//索引下标2
    list.add("a");//索引下标3
    list.add("d");//允许使用重复元素

    System.out.println(list);//结果:[b, d, c, a, d]
    System.out.println(list.get(2));//通过索引来访问指定位置的集合元素.结果:c

    list.add(1,"f");//在指定索引下标的位置插入数据
    System.out.println(list);//结果:[b, f, d, c, a, d]

    List<String> m = new ArrayList<String>();
    m.add("123");
    m.add("456");

    list.addAll(2, m);//在指定索引下标的位置插入集合

    System.out.println(list);//结果:[b, f, 123, 456, d, c, a, d]

    System.out.println(list.indexOf("d"));//获取指定元素在集合中第一次出现的索引下标.结果:4
    System.out.println(list.lastIndexOf("d"));//获取指定元素在集合中最后一次出现的索引下标.结果:7

    list.remove(2);//根据指定的索引下标移除元素
    System.out.println(list);//结果:[b, f, 456, d, c, a, d]

    list.set(1, "ff");//根据指定的索引下标修改元素
    System.out.println(list);//结果:[b, ff, 456, d, c, a, d]

    //根据索引下标的起始位置截取一段元素形参一个新的集合,截取的时候,包含开始的索引不包含结束时的索引
    List<String> sublist =  list.subList(2, 4);//取索引下标在大于等于2,小于4的元素

    System.out.println(sublist);//结果:[456, d]

    System.out.println(list.size());//集合的长度.结果:7
}
复制代码  

set集合:

Set集合下面有:HashSet,LinkedHashSet,TreeSet

Set集合的特点:元素不重复,存取无序,无下标

HashSet:

 public static void main(String[] args) {
        // 利用HashSet来存取
        Set<String> set = new  Hash Set<String>();
        set.add("a");
        set.add("b");
        set.add("b");
        set.add("c");
        // 遍历 第一种方式 迭代器
        Iterator<String> it = set.iterator();
        while(it.hasNext()){
            String str = it.next();
            System.out.println(str);
        }

        System.out.println("--------------");
        for (String str : set){
            System.out.println(str);
        }
        // 打印结果,重复的已经去掉了
        /*  a
            b
            c
            --------------
            a
            b
            c*/    }
复制代码  

HashSet 按 Hash 算法来存储集合中的元素,因此具有很好的存取和查找性能。HashSet 具有以下特点:

  • 不能保证元素的排列顺序
  • 不可重复( hashcode 不相同)
  • HashSet 不是线程安全的
  • 集合元素可以使 null

当向 HashSet 集合中存入一个元素时,HashSet 会调用该对象的 hashCode() 方法来得到该对象的 hashCode 值,然后根据 hashCode 值决定该对象在 HashSet 中的存储位置,存在set集合哪个位置由这个值的hashcode决定,而不是按先来后到。如果两个元素的 equals() 方法返回 true,但它们的 hashCode() 返回值不相等,hashSet 将会把它们存储在不同的位置,但依然可以添加成功。

演示HashSet来存储自定义对象:

 package org.example.test;

public class Person {
    // 属性
    private String name;
    private int age;

    // 构造方法
    public Person() {
        super();

    }

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

    // 要让 哈希表 存储不重复的元素,就必须重写hasCode和equals方法
    @ Override 
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + age;
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Person other = (Person) obj;
        if (age != other.age)
            return false;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        return true;
    }


    @Override
    public String toString() {
        return "Person [name=" + name + ", age=" + age + "]";
    }
    // getter & setter


    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;
    }
    
}
复制代码  
  public static void main(String[] args) {
     // 利用HashSet来存取自定义对象 Person
     Set<Person> set = new HashSet<Person>();

     set.add(new Person("张三", 12));
     set.add(new Person("李四", 13));
     set.add(new Person("王五", 22));
     set.add(new Person("张三", 12));

     // 遍历
     for (Person p : set){
         System.out.println(p);
     }
     // 结果:向集合中存储两个张三对象,但是集合中就成功存储了一个
     /*Person [name=王五, age=22]
        Person [name=李四, age=13]
        Person [name=张三, age=12]*/}
复制代码  

所以在向HashSet集合中存储自定义对象时,为了保证set集合的唯一性,那么必须重写hashCode和equals方法。

LinkedHashSet:

是基于链表和哈希表共同实现的,所以具有存取有序,元素唯一

 public static void main(String[] args) {
    // 利用LinkedHashSet来存取自定义对象 Person
    LinkedHashSet<Person> set = new LinkedHashSet<Person>();
    set.add(new Person("张三", 12));
    set.add(new Person("李四", 13));
    set.add(new Person("王五", 22));
    set.add(new Person("张三", 12));
    // 遍历
    for (Person p : set){
        System.out.println(p);
    }
    // 结果:向集合中存储两个张三对象,但是集合中就成功存储了一个,
    // 并且存进的顺序,和取出来的顺序是一致的
    /*Person [name=张三, age=12]
        Person [name=李四, age=13]
        Person [name=王五, age=22]*/}
复制代码  

TreeSet:

  • TreeSet 是 SortedSet 接口的实现类
  • TreeSet 特点:存取无序,元素唯一,可以进行排序(排序是在添加的时候进行排序)
  • TreeSet 支持两种排序方法:自然排序和定制排序。默认情况下,TreeSet 采用自然排序

TreeSet集合存储String对象

   public static void main(String[] args) {
        TreeSet<String> treeSet = new TreeSet<String>();
        treeSet.add("a");
        treeSet.add("c");
        treeSet.add("d");
        treeSet.add("b");

        for (String str : treeSet){
            System.out.println(str);
        }
        // 结果:取出来的结果是经过排序的
        /*
        a
        b
        c
        d*/    }
复制代码  

TreeSet保证元素的唯一性是有两种方式:

1、自定义对象实现Comparable接口,重写comparaTo方法,该方法返回0表示相等,小于0表示准备存入的元素比被比较的元素小,否则大于0;

2、在创建TreeSet的时候向构造器中传入比较器Comparator接口实现类对象,实现Comparator接口重写compara方法。

如果向TreeSet存入自定义对象时,自定义类没有实现Comparable接口,或者没有传入Comparator 比较器 时,会出现ClassCastException异常。

下面就是演示用两种方式来存储自定义对象

 package org.example.test;

import java.util.TreeSet;

public class Person implements Comparable<Person> {
    // 属性
    private String name;
    private int age;

    // 构造方法
    public Person() {
        super();

    }

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

    // 要让哈希表存储不重复的元素,就必须重写hasCode和equals方法
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + age;
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Person other = (Person) obj;
        if (age != other.age)
            return false;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        return true;
    }


    @Override
    public String toString() {
        return "Person [name=" + name + ", age=" + age + "]";
    }
    // getter & setter


    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 int compareTo(Person o) {
        int result = this.age - o.age;
        if (result == 0) {
            return this.name.compareTo(o.name);
        }
        return result;
    }


    public static void main(String[] args) {
        // 利用TreeSet来存储自定义类Person对象
        TreeSet<Person> treeSet = new TreeSet<Person>();
        // Person类实现了Comparable接口,并且重写comparaTo方法
        // 比较规则是先按照 年龄排序,年龄相等的情况按照姓名排序
        treeSet.add(new Person("张山1", 20));
        treeSet.add(new Person("张山2", 16));
        treeSet.add(new Person("张山3", 13));
        treeSet.add(new Person("张山4", 17));
        treeSet.add(new Person("张山5", 20));
        for (Person p : treeSet) {
            System.out.println(p);
        }
        // 结果:按照comparaTo方法内的逻辑来排序的
        /*
        Person [name=张山3, age=13]
        Person [name=张山2, age=16]
        Person [name=张山4, age=17]
        Person [name=张山1, age=20]
        Person [name=张山5, age=20]
         */    }
}
复制代码  

另一种方式:使用比较器Comparator

 package org.example.test;

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

public class Person {
    // 属性
    private String name;
    private int age;

    // 构造方法
    public Person() {
        super();

    }

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

    // 要让哈希表存储不重复的元素,就必须重写hasCode和equals方法
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + age;
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Person other = (Person) obj;
        if (age != other.age)
            return false;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        return true;
    }


    @Override
    public String toString() {
        return "Person [name=" + name + ", age=" + age + "]";
    }
    // getter & setter


    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;
    }


    public static void main(String[] args) {
        // 利用TreeSet来存储自定义类Person对象
        // 创建TreeSet对象的时候传入Comparator比较器,使用匿名内部类的方式
        // 比较规则是先按照 年龄排序,年龄相等的情况按照姓名排序
        TreeSet<Person> treeSet = new TreeSet<Person>(new Comparator<Person>() {
            @Override
            public int compare(Person o1, Person o2) {
                if (o1 == o2){
                    return 0;
                }
                int result = o1.getAge() - o2.getAge();
                if (result == 0){
                    return o1.getName().compareTo(o2.getName());
                }
                return result;
            }

        });

        treeSet.add(new Person("张山1", 20));
        treeSet.add(new Person("张山2", 16));
        treeSet.add(new Person("张山3", 13));
        treeSet.add(new Person("张山4", 17));
        treeSet.add(new Person("张山5", 20));

        for (Person p : treeSet){
            System.out.println(p);
        }
        // 结果:按照compara方法内的逻辑来排序的
        /*
        Person [name=张山3, age=13]
        Person [name=张山2, age=16]
        Person [name=张山4, age=17]
        Person [name=张山1, age=20]
        Person [name=张山5, age=20]
         */    }
}
复制代码  

三、Map集合

map集合下面有HashMap,LinkedHashMap和TreeMap

  • Map 用于保存两组具有映射关系的数据,一组值用于保存 Map 里的 Key,另外一组用于保存 Map 里的 Value
  • Map 中的 key 和 value 都可以是任何引用类型的数据
  • Map 中的 Key 不允许重复,即同一个 Map 对象的任何两个 Key 通过 equals 方法比较中返回 false
  • Key 和 Value 之间存在单向一对一关系,即通过指定的 Key 总能找到唯一的,确定的 Value。

HashMap:

是基于哈希表结构实现的,所以存储自定义对象作为键时,必须重写hasCode和equals方法,存取无序的。

下面演示HashMap以自定义对象作为键:

 public static void main(String[] args) {
    // 利用HashMap存储,自定义对象Person作为键
    // 为了保证键的唯一性,必须重写hashCode和equals方法
    HashMap<Person,String> map = new HashMap<Person,String>();
    map.put(new Person("张三", 12), "JAVA");
    map.put(new Person("李四", 13), "IOS");
    map.put(new Person("小花", 22), "JS");
    map.put(new Person("小黑", 32), "PHP");
    map.put(new Person("张三", 12), "C++");
    Set<Entry<Person, String>> entrySet = map.entrySet();
    Iterator<Entry<Person, String>> it = entrySet.iterator();
    while (it.hasNext()){
        Entry<Person, String> entry = it.next();
        System.out.println(entry.getKey() + "---" + entry.getValue());
    }
    // 结果:存入的时候添加了两个张三,如果Map中键相同的时候,当后面的值会覆盖掉前面的值
    /*
        Person [name=李四, age=13]---IOS
        Person [name=张三, age=12]---C++
        Person [name=小黑, age=32]---PHP
        Person [name=小花, age=22]---JS
        */}
复制代码  

LinkedHashMap:

用法跟HashMap基本一致,它是基于链表和哈希表结构的所以具有存取有序,键不重复的特性。

下面演示利用LinkedHashMap存储,注意存的顺序和遍历出来的顺序是一致的:

 public static void main(String[] args) {
    // 利用LinkedHashMap存储,自定义对象Person作为键
    // 为了保证键的唯一性,必须重写hashCode和equals方法
    LinkedHashMap<Person,String> map = new LinkedHashMap<Person,String>();

    map.put(new Person("张三", 12), "JAVA");
    map.put(new Person("李四", 13), "IOS");
    map.put(new Person("小花", 22), "JS");
    map.put(new Person("小黑", 32), "PHP");
    map.put(new Person("张三", 12), "C++");

    // foreach遍历
    for (Entry<Person,String> entry : map.entrySet()){
        System.out.println(entry.getKey()+"==="+entry.getValue());
    }
    // 结果:存入的时候添加了两个张三,如果Map中键相同的时候,当后面的值会覆盖掉前面的值
    // 注意:LinkedHashMap的特点就是存取有序,取出来的顺序就是和存入的顺序保持一致
    /*
        Person [name=张三, age=12]===C++
        Person [name=李四, age=13]===IOS
        Person [name=小花, age=22]===JS
        Person [name=小黑, age=32]===PHP
        */}
复制代码  

TreeMap:

给TreeMap集合中保存自定义对象,自定义对象作为TreeMap集合的key值。由于TreeMap底层使用的二叉树,其中存放进去的所有数据都需要排序,要排序,就要求对象具备比较功能。对象所属的类需要实现Comparable接口。或者给TreeMap集合传递一个Comparator接口对象。

利用TreeMap存入自定义对象作为键:

 public static void main(String[] args) {
    // 利用TreeMap存储,自定义对象Person作为键
    // 自定义对象实现Comparable接口或者传入Comparator比较器
    TreeMap<Person,String> map = new TreeMap<Person,String>(new Comparator<Person>() {
        @Override
        public int compare(Person o1, Person o2) {
            if (o1 == o2){
                return 0;
            }
            int result = o1.getAge() - o2.getAge();
            if (result == 0){
                return o1.getName().compareTo(o2.getName());
            }
            return result;
        }
    });

    map.put(new Person("张三", 12), "JAVA");
    map.put(new Person("李四", 50), "IOS");
    map.put(new Person("小花", 32), "JS");
    map.put(new Person("小黑", 32), "PHP");
    map.put(new Person("张三", 12), "C++");

    // foreach遍历
    for (Entry<Person,String> entry : map.entrySet()){
        System.out.println(entry.getKey()+"==="+entry.getValue());
    }
    // 结果:存入的时候添加了两个张三,如果Map中键相同的时候,当后面的值会覆盖掉前面的值
    // 注意:TreeMap 取出来的顺序是经过排序的,是根据compara方法排序的
    /*
        Person [name=张三, age=12]===C++
        Person [name=小花, age=32]===JS
        Person [name=小黑, age=32]===PHP
        Person [name=李四, age=50]===IOS
        */}
复制代码  

结尾

我是一个正在被打击还在努力前进的码农。如果文章对你有帮助,记得点赞、关注哟,谢谢!

作者:初念初恋
链接:
来源:掘金
著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。

文章来源:智云一二三科技

文章标题:Java集合入门,看这篇就够了

文章地址:https://www.zhihuclub.com/190539.shtml

关于作者: 智云科技

热门文章

网站地图