Java集合

最新推荐文章于 2022-10-28 12:57:50 发布

IAmJunGod

最新推荐文章于 2022-10-28 12:57:50 发布

阅读量185

点赞数

分类专栏： Android 文章标签： android

本文链接：https://blog.csdn.net/qq_34994954/article/details/118380196

版权

Android 专栏收录该内容

8 篇文章 1 订阅

订阅专栏

1.集合是什么

Java集合是一个容器，容器内的对象可以是任意的数据类型，且长度可变。集合按照其存储结构可以分为两大类，分别是单列集合Collection，和双列集合Map。

这两种集合特点如下：

(1) Collection：单列集合接口，用于存储一系列元素。实现了Collection接口的两个子接口分别是List和Set。其中List集合内的元素是有序的并且可重复；Set集合的特点是元素无序并且不可重复。List接口的主要实现类有ArrayList和ListedList；Set接口的主要实现类有HashSet和TreeSet。

(2) Map：双列集合的根接口，用于存储具有键（Key)，值（Value）映射关系的元素。

Map集合中每个元素都包含一对键值，并且Key是唯一的，在使用Map集合时可以通过指的Key找到对应的Value。Map接口的主要实现类有HashMap和TreeMap。

2.List接口

List接口继承于Collection接口，在List集合中允许出现重复的元素，在程序中可以通过索引来访问集合中的指定元素，另外List集合还有一个特点就是存取有序。

(1) ArrayList集合

ArrayList内部封装了一个长度可变的数组对象（初始容量为10，按1.5倍扩容），在ArrayList中进行增删改查效率会比较低，但是在遍历和查找元素时显得非常高效。

(2) LinkedList集合

为了克服ArrayList增删效率低的问题，可以用LinkedList，该集合内有一个双向循环链表，增删效率较高。

(3) List集合遍历

Iterator遍历集合

Iterator对象被称为迭代器，用来访问Collection中的元素。在使用迭代器对集合元素迭代是，如果调用了remove的方法去删除元素，会出现异常。原因是集合中删除元素会导致迭代器语气的迭代次数发生改变，导致迭代器的结果不准确。

public class IteratorTest{

    public static void main(String[] args) {

        ArrayList list = new ArrayList();

        list.add("1");

        list.add("2");

        list.add("3");

        Iterator iterator = list.iterator();

        while (iterator.hasNext()){

            String object = iterator.next();

            System.out.println(object);

        }

    }

}

//输出结果为

LinkedList的使用方式与ArrayList一致。

3.Set接口

Set接口简介

Set接口中的元素无序，并且保证存入的元素不会重复。Set接口主要有两个实现类，分别是HashSet和TreeSet，其中HashSet是根据对象的哈希值来确定元素集合中的存储位置，因此具有良好的存取和查找性能。TreeSet则以二叉树的方式来存储元素，它可以实现对集合中的元素排序。

(1) HashSet集合

HashSet是set接口的一个实现类，它所存储的元素是不可重复的，并且元素都是无序的。当想HashSet集合中添加元素时，首先会调用hashcode方法来确定元素的存储位置，然后再调用元素对象的equals（）方法来确保该位置没有重复元素。

public class HashSetTest{

    public static void main(String[] args) {

        HashSet hashSet = new HashSet();

        hashSet.add("Jack");

        hashSet.add("Rose");

        hashSet.add("Eve");

        hashSet.add("Rose");

        hashSet.forEach(obj-> System.out.println(obj));

        }

    }

//输出结果为

Eve

Rose

Jack

Eve

向集合中存入元素时，为了保证HashSet正常工作，要求在存入对象是，需要重写Object类中的hashCode（）和equals（）方法。上个例子将字符串存入HashSet时，String类已经默认重写了hashCode的方法，但是有时候传入自定义类型的对象存入HashSet，需要重写方法。

package com.ok;

import java.util.ArrayList;
import java.util.*;

public class HashSetTest{
    public static void main(String[] args) {
        HashSet hashSet = new HashSet();
        hashSet.add(new Student("2","zhang"));
        hashSet.add(new Student("8","name"));
        hashSet.add(new Student("4","jack"));
        hashSet.add(new Student("6","row"));
        hashSet.forEach();
        }
    }
class Student{
    String id;
    String name;

    public Student(String id, String name) {
        this.id = id;
        this.name = name;

    }
    @Override
    public String toString(){
        return id+" "+name;
    }
    @Override
    public int hashCode(){
        return id.hashCode();
    }
    @Override
    public boolean equals(Object object){
        if(this == object){	
            return true;
        }
        if(!(object instanceof Student)){
            return false;	
        }
        Student student = (Student) object;
        boolean b = this.id.equals(student.id);
        return b;
    }
}

//输出结果为

[2 zhang, 4 jack, 6 row, 8 name]

(2) TreeSet接口

TreeSet采用平衡二叉树来存储元素，这样的结构可以保证TreeSet集合中没有重复的元素，且可以排序。集合中的元素在进行比较时，都会调用compareTo（）方法，该方法是Comparable定义的。在向TreeSet传入自定义数据时，没有实现Comparable接口。为了解决这个问题java提供了两种方法分别为自然排序和定制排序。

//自然排序

package com.ok;

import java.util.ArrayList;
import java.util.*;

public class TreeSetTest{
    public static void main(String[] args) {
        TreeSet treeSet = new TreeSet();
        treeSet.add(new Teacher("jack",18));
        treeSet.add(new Teacher("rose",19));
        treeSet.add(new Teacher("tom",19));
        treeSet.add(new Teacher("rose",19));
        System.out.println(treeSet);
    }
}
class Teacher implements Comparable{
    String name;
    int age;

    public Teacher(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString(){
        return name +":"+age;
    }

    @Override
    public int compareTo(Object obj){
        Teacher teacher = (Teacher) obj;

        if(this.age- teacher.age>0){
            return 1;
        }
        if(this.age- teacher.age==0){
            return this.name.compareTo(teacher.name);
        }
        return -1;
    }
}

//输出结果为

[jack:18, rose:19, tom:19]

Teacher类实现了Comparable接口，并重写compareTo（）方法。在compareTo（）方法中，首先针对age值进行修改，根据比较结果返回-1和1，当age相同时，再对name进行比较。教师Teacher对象首先按照年龄升序排序，年龄相同时会按照姓名进行升序排序，并且TreeSet集合会将重复的元素去掉。

//定制排序

package com.ok;

import java.util.*;
public class TreeSetComparatorTest{
    public static void main(String[] args) {
        TreeSet treeSet = new TreeSet(new MyComparator());
        treeSet.add("jack");
        treeSet.add("hello");
        treeSet.add("tom");
        System.out.println(treeSet);
        TreeSet treeSet1 = new TreeSet((obj1,obj2)->{
            String s1 = (String) obj1;
            String s2 = (String) obj2;
            return s1.length() - s2.length();
        });
        treeSet1.add("jack");
        treeSet1.add("tom");
        treeSet1.add("hello");
        System.out.println(treeSet1);
        
    }
}
class MyComparator implements Comparator{
    @Override
    public int compare(Object obj1, Object obj2){
        String str1 = (String) obj1;
        String str2 = (String) obj2;
        int temp = str1.length()-str2.length();
        return temp;
    }
}

3.Map接口

(1) Map接口简介

Map接口是一个双列集合，它的每个元素都包含一个键对象Key和值对象Value，键和值对象之间存在一种对应关系，称为映射。Map中key和value可以是任意数据类型，并且键对象Key不允许重复，在访问Map集合中的元素时，只要指定了Key，就能找到对应的Value。

(2) HashMap集合

HashMap集合时Map接口的一个实现类，它用于存储键值映射关系，该集合的键和值允许为空，但键不能重复，且集合中的元素是无序的。

(3)Map集合遍历

Iterator迭代器遍历Map集合

使用Iterator遍历集合需要先将Map集合转换为Iterator接口对象，然后进行遍历。由于Map集合中元素是有键值对构成的，所以使用Iterator遍历，有两种方法，即keySet（）和entrySet（）

keySet（）方法需要将Map集合中所有的键对象转换为Set单列集合，接着将含键对象的Set集合转换为Iterator接口对象，然后遍历Map集合中所有的键，再根据键获取相应的值。


import java.util.*;
public class KeySetTest{
    public static void main(String[] args) {
        Map map = new HashMap();
        map.put("3", "Jack");
        map.put("1", "Rock");
        map.put("2", "Tom");
        Set keySet = map.keySet();
        Iterator iterator = keySet.iterator();
        while (iterator.hasNext()) {
            Object key = iterator.next();
            Object value = map.get(key);
            System.out.println(key + ":" + value);
        }
    }
}

entrySet()方法将原有的Map集合中的键值对作为一个整体返回Set集合，接着将包含键值对对象的Set集合转换为Iterator接口对象，然后获取集合中的所有键值对映射关系，在从映射关系中取出键和值。

package com.ok;
import java.util.*;
public class EntrySetTest{
    public static void main(String[] args) {
        Map map = new HashMap();
        map.put("3", "Jack");
        map.put("1", "Rock");
        map.put("2", "Tom");
        Set entrySet = map.entrySet();
        Iterator iterator = entrySet.iterator();
        while (iterator.hasNext()){
            Map.Entry entry = (Map.Entry)(iterator.next());
            Object key = entry.getKey();
            Object value = entry.getValue();
            System.out.println(key + ":" + value);
        }
    }
}