java集合类详解

Wooo_e

已于 2024-05-23 20:13:20 修改

阅读量807

点赞数 28

文章标签：开发语言 java 学习

于 2024-05-23 20:12:40 首次发布

本文链接：https://blog.csdn.net/Wooo_e/article/details/138023539

版权

1、数组导入：

容器---->数组：

一组数据类型相同的元素集合
创建数组时，必须给定长度，而且一旦创建长度不能变。
一旦数组装满元素，需要创建一个新的数组，将元素复制过去。

缺点：
如果我们从数组中间删除了一个元素或者添加一个元素，需要移动后面的元素。
如果数组装满了，超过了数组的最大长度，会创建新的数组将旧数组复制到新数组上。

java中为了解决数据存储单一的情况，提供了许多不同结构的集合类。让我们可以根据不同的场景进行数据存储选择。

提供了数组实现的集合,链表实现的集合,哈希结构,树结构... 让iava程序员使用起来就非常方便。

2、单列集合

单例集合指的是：一次放进去一个值（对象）。集合实现Collection接口，定义了单例集合共有的方法。

List接口

特点：List类中可以有重复元素

1、ArrayList：数组列表

底层有一个数组，可以动态扩展数组的长度，并提供一个一系列方法操作。

特点：查询快，中间增加、删除慢。

ArrayList类中的方法

arrayList.add()--->添加
arrayList.remove()---->删除
arrayList.get()----->获取指定位置上的元素
arrayList.indexOf()----->查找给定元素第一次出现的位置
arrayList.lastIndexOf()---->从后往前查找指定元素第一次出现的位置
arrayList.set(int index,E element)---->将指定位置上的元素替换并返回原来的值arrayList.clear()----->清空
arrayList.isEmpty()----->判断是否为空
arrayList.contains()----->判断是否包含指定元素
arrayList.size()----->返回集合中元素的个数


public class Demo3 {
    public static void main(String[] args) {
        ArrayList arrayList = new ArrayList();
        arrayList.add("a");
        arrayList.add("b");
        arrayList.add("c");
        arrayList.add("d");
        arrayList.add("e");
        System.out.println(arrayList.remove("b"));//boolean类型，根据内容删除匹配的第一个元素,删除成功返网true,否则返回false
        System.out.println(arrayList.remove(1));//删除并返回指定位置的值
        System.out.println(arrayList.get(1));//获取指定位置上的元素
        System.out.println(arrayList.indexOf("d"));//查找第一次出现的位置
        System.out.println(arrayList.lastIndexOf("d"));//从后查找，第一次出现的位置
        System.out.println(arrayList.set(1, "v"));//将指定位置上的元素替换并返回原来的值
        arrayList.clear();
        System.out.println(arrayList.isEmpty());
        System.out.println(arrayList.contains("c"));//判断是否包含指定元素
        System.out.println(arrayList.size());//返回集合中元素的个数

        for (int i = 0; i < arrayList.size(); i++) {
            System.out.println(arrayList.get(i));

        }
    }
}

2、LinkedList：链表列表

底层是一个链表结构。

特点：查询慢，增加、删除快

linkedList.add("a")---->向链表末尾添加元素
linkedList.add(2, "y")---->向链表指定的位置插入元素
linkedList.get(2)----->获取指定位置上的元素
linkedList.remove("y")----->删除
linkedList.remove(1)------>删除并返回指定元素的值
linkedList.removeFirst())----->删除第一个元素并返回其值
linkedList.pop()----->出栈
linkedList.clear()------>清空
linkedList.contains()----->判断是否包含指定元素
linkedList.isEmpty()----->判断是否为空
linkedList.size()----->返回集合中元素的个数

3、Vector：数组列表

特点：相对于ArrayList是线程安全的。其他与arraylist相似。、

4、list集合的遍历

1、for循环遍历

允许操作（删除）元素的.

（注意索引的变化与元素位置的移动）


public class List1 {
    public static void main(String[] args) {
        ArrayList<String> arrayList = new ArrayList<String>();
        arrayList.add("a");
        arrayList.add("b");
        arrayList.add("r");

        System.out.println(arrayList);
        /*
        List 接口实现类/List集合遍历方式
         1、for循环遍历，允许操作（删除）元素的.
         注意索引的变化与元素位置的移动

         */
        for (int i = 0; i < arrayList.size(); i++) {
            if ("a".equals(arrayList.get(i))) {
                arrayList.remove("a");
                i--;
            }

        }
        System.out.println(arrayList);
    }
}

2、增强for循环

增强for循环遍历元素时, 不允许修改集合元素(删除,添加)


public class List2 {
    /*
    List接口实现类/List集合遍历
    方式2:增强for循环
    增强for循环遍历元素时,  不允许修改集合元素(删除,添加)
     */
    public static void main(String[] args) {
        ArrayList<String> arrayList=new ArrayList<>();
        arrayList.add("a");
        arrayList.add("b");
        arrayList.add("r");
        for(String s:arrayList){
            //arrayList.remove("a");ConcurrentModificationException报错
            System.out.println(arrayList);
        }
        System.out.println(arrayList);
    }
}

3、迭代器遍历

迭代器只能对list接口下的实现类遍历


public class List3 {
    public static void main(String[] args) {
        ArrayList<String> arrayList = new ArrayList<String>();
        arrayList.add("a");
        arrayList.add("b");
        arrayList.add("r");

        /*
        List接口实现类/List集合遍历
        方式3:使用迭代器遍历
        获得集合对象的选代器对象
         */
        Iterator<String> it = arrayList.iterator();
        while (it.hasNext()) {//判断数组是否遍历完成  0！=3，next,3==3,false结束
            String s = it.next();//获取到下一个元素
            if (s.equals("a")) {
                it.remove();//使用迭代器对象删除元素
            }
            System.out.println(arrayList);
        }
    }
}


//迭代器2
public class List4 {
    public static void main(String[] args) {
        ArrayList<String> arrayList=new ArrayList<>();
        arrayList.add("a");
        arrayList.add("b");
        arrayList.add("f");
        arrayList.add("b");
        arrayList.add("g");
        System.out.println(arrayList);

        System.out.println("从指定位置往后遍历");
        ListIterator<String> listIterator=arrayList.listIterator(2);//
        while(listIterator.hasNext()){
            System.out.println(listIterator.next());
        }
        System.out.println("从（最后）后往前遍历");
        ListIterator<String> listIterator1=arrayList.listIterator(arrayList.size());//
        while (listIterator.hasPrevious()){

            System.out.println(listIterator.previous());
        }

    }
}

Set接口

特点：Set类中不能有重复元素

1、HashSet

无序的，通过hashCode和equals方法判断元素是否有序。

在添加元素时，是如何判断元素重复的：
     （当我们向集合中添加一个元素时,如果每次都使用equals()比较内容是否相等效率会很低）
因此该如何比较呢？
      先判断hashcode()值是否相等，如果相等，不一定内容相同，即此情况下会出现哈希冲突，再用equals()比较内容。
      在底层会先调用hashcode()-- 0bject中的hashcode()返回的是对象的地址(但是我们不调用这个) 我们需要：调用类中重写的Hashcode(),返回的是根据内容计算的哈希值
      遍历时,会用哈希值先比较是否相等,会提高比较的效率，
      但是哈希值会存在问题。内容不同,哈希相同
      此种情况下,再调用equals()比较内容，这样设计既提高判断效率,又保证安全。

   public static void main(String[] args) {
        HashSet<String> set=new HashSet<>();
        set.add(new String("asdfgdfgdfgsa"));
        set.add("bgbgbgghjdnbu");
        set.add("通话");
        set.add("重地");
        for(String s:set){
            System.out.println(set);
        }
    }

2、TreeSet

有序的，可以给Set集合中的元素进行指定方式的排序。存储的对象必须实现Comparable接口。

 可以给Set集合中的元素进行指定方式的排序。存储的对象必须实现Comparable接口。
特点: 
1、有序的
2、不能存储重复元素的
3、存储时可以根据值进行排序，底层使用了树形结构，树结构本身即是有序的
向树形结构中添加元素时，如何判断元素大小以及元素是否重复？
    向TreeSet中添加的元素类型，必须实现Comparable接口，重写compareTo方法
    每次添加元素时，调用compareTo()方法进行比较大小
   （第一个为根节点，比他大的在右边，比它小的在左边）

package A_集合单例.Set.TreeSet;

import java.util.Objects;

public class Student implements Comparable<Student> {
    private String name;
    private int num;

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getNum() {
        return num;
    }

    public void setNum(int num) {
        this.num = num;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Student)) return false;
        Student student = (Student) o;
        return getNum() == student.getNum() &&
                Objects.equals(getName(), student.getName());
    }

    @Override
    public int hashCode() {
        return Objects.hash(getName(), getNum());
    }

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

    @Override
    public int compareTo(Student o) {
        return this.num - o.num;
    }
}

package A_集合单例.Set.TreeSet;


import java.util.TreeSet;

public class StudentTest {
    public static void main(String[] args) {
        TreeSet<Student> treeSet=new TreeSet<>();
        Student s1=new Student("张三1",103);
        Student s2=new Student("张三2",101);
        Student s3=new Student("张三3",102);
        Student s4=new Student("张三4",104);
        treeSet.add(s1);
        treeSet.add(s2);
        treeSet.add(s3);
        treeSet.add(s4);

        System.out.println(treeSet);
    }

}

3、双列集合

map接口

map接口：

数据存储是(键：值)键值对的形式存储。
键不能重复的，（重复了覆盖原键），值可以重复
通过键可以找到值
一个键只能映射到一个值

1、HashMap

键是无序的，可以存储键为空，值为空的值。

{
    public static void main(String[] args) {
        HashMap<String, String> map = new HashMap<>();
        map.put("a","ddd");
        map.put("b","eee");
        map.put("c","fff");
        map.put("e","ttt");
        map.put("a","dd");//向map中添加一组 键值对

        System.out.println(map.remove("b"));//删除指定的键值,返回对应的值
        map.clear();//清空键值对
        System.out.println(map.isEmpty());//判空
        System.out.println(map.containsKey("b"));
        System.out.println(map.containsValue("eee"));
        System.out.println(map.get("c"));
        System.out.println(map);
    }
}

HashMap的底层结构：

哈希表（数组）
链表
红黑树

对于HashMap详细的讲解可看，（讲解很清楚）：https://blog.csdn.net/Wooo_e/article/details/136974366?spm=1001.2014.3001.5501

HashMap的遍历

HashMap两种遍历方式：

1、根据键找值

2、利用map.Entry键值对的查找

package B_集合双列.hashmap;

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class Demo2 {
    /*
      1、用key计算哈希值
      static final int hash(Object key) {
        int h;
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
    }
    2、
     public V put(K key, V value) {
        return putVal(hash(key), key, value, false, true);
    }
     */
    public static void main(String[] args) {
        HashMap<String,String> map=new HashMap<>();
        map.put("a","aa");
        map.put("b","bb");
        map.put("c","ccc");
        map.put(null,null);

        System.out.println(map);
        //map遍历
        //方式1、先拿到所有的键  遍历键  根据键找值
        Set<String> keyset = map.keySet();
        for(String s: keyset) {
            System.out.println(s + ":" + map.get(s));
        }
        //方式2、推荐的遍历
        Set<Map.Entry<String, String>> entries = map.entrySet();
        for(Map.Entry entry:entries){
            System.out.println(entry.getKey()+":"+entry.getValue());
        }

    }
}

2、HashTable

HashTable的底层实现：
也是用到key的哈希值,计算位置,判断元素是否重复。
但是方法上都添加了synchronized锁
Hashtbale中不能存储为null的键和为null的值

package B_集合双列.hashtable;

import java.util.Hashtable;

public class Demo1 {
public static void main(String[] args) {
    Hashtable<String,String> hashtable=new Hashtable<>();
    hashtable.put("a","bb");
    hashtable.put("c","cc");
    hashtable.put("b","ff");
    hashtable.put("a","aa");
    //hashtable.put("d",null);//报错
    System.out.println(hashtable);
}
}

3、TreeMap

 TreeMap
     底层使用树形结构存储键值（红黑树）
     键可以排序
     键元素类型必须实现Comparable接口，重写compareTo()方法.

在TreeMap中，可以存储值为null，但是键不能为null。

package B_集合双列.TreeMap;

import java.util.TreeMap;

public class Demo1 {
    public static void main(String[] args) {
        TreeMap<Integer,String> treeMap=new TreeMap<>();
        treeMap.put(3,"aa");
        treeMap.put(2,"bb");
        treeMap.put(1,"ff");
        treeMap.put(4,"jj");
        treeMap.put(5,"oo");
        System.out.println(treeMap.get(3));
        System.out.println(treeMap.containsKey(2));
        System.out.println(treeMap.size());
        System.out.println(treeMap);
    }

}

持续更新ing........

Wooo_e

关注

28
点赞
踩
14

收藏

觉得还不错? 一键收藏
1
评论
java集合类详解

容器---->数组：一组数据类型相同的元素集合创建数组时，必须给定长度，而且一旦创建长度不能变。一旦数组装满元素，需要创建一个新的数组，将元素复制过去。缺点：如果我们从数组中间删除了一个元素或者添加一个元素，需要移动后面的元素。如果数组装满了，超过了数组的最大长度，会创建新的数组将旧数组复制到新数组上。java中为了解决数据存储单一的情况，提供了许多不同结构的集合类。让我们可以根据不同的场景进行数据存储选择。提供了让iava程序员使用起来就非常方便。
复制链接

扫一扫