集合/容器

最新推荐文章于 2023-03-09 09:00:42 发布

暴走的小帅

最新推荐文章于 2023-03-09 09:00:42 发布

阅读量125

点赞数

文章标签：大数据

本文链接：https://blog.csdn.net/weixin_71243923/article/details/125709285

版权

● 集合概念

● 集合 API

● List 接口及实现类

● List接口集合迭代

● Set 接口

● Set 接口集合迭代

● Map 接口

● Collections类

一.集合概念

当我们需要保存一组一样（类型相同）的元素的时候，我们应该使用一个容器来存储，数组就是这样一个容器。

缺点:

● 数组一旦定义，长度将不能再变化,需要频繁的扩容

● 在程序运行中，经常需要保存一些变长的数据集合，于是，我们需要一些能够动态增长长度的容器来保存我们的数据。

●数组优点是查询比较快.

●集合:对数据的操作多种多样,增删较多,查询较少

●我们需要对数据的保存的逻辑可能各种各样，于是就有了各种各样的数据结

构。 Java中对于各种数据结构的实现，就是我们用到的集合。

二.集合 API

集合体系概述

Java 的集合框架是由很多接口、抽象类、具体类组成的，都位于 java.util 包中。

集合分为(1)Collection(单列)(2)Map(双列)

(1)Collection:List(有序,可重复)和Set(无序,不可重复)

List:ArrayList和LinkedList和Vector Set:HashSet和TreeSet

(2)Map:HashMap和TreeMap

三.Collection 接口

Collection 接口－定义了存取一组对象的方法，其子接口 Set 和 List 分别定义了存储方式。

● Set 中的数据对象没有顺序且不可以重复。

● List 中的数据对象有顺序且可以重复

在 Collection 中定义了一些集合中的共有方法 :

Collection,作为单列接口的顶级接口,里面定义了单列集合的共有方法方法以增,删,改,查,判断,转换为主

Collection<E>和ArraysList<E>后面的E是jdk-5之后的泛型可以通过泛型语法为集合设置一个类型,这样就只能存储设置的类型

集合中建议存储同一类型集合是容器,可以存储不同的数据,严格上讲,集合可以存储任何类型(只针对引用类型)

 Collection<String> a = new ArrayList<>();
     //为其指定了具体的类型   a.add("a");
                             a.add("b");
                             a.add("c");
                             a.add("d");
        System.out.println(a);
    Collection<Integer> v = new ArrayList<>();
                        v.add(5);//自动装箱
                        v.add(4);
                        v.add(3);
                        v.add(2);//向末尾添加元素

具体的一些方法如下:

a.addAll(v) //把一个集合的元素都添加到另一个集合中

a.clear() //把这个集合清空

a.equals(v) //比较内容是否相等

a.isEmpty()//集合是否为空

a.remove("a")//删除指定元素,有"a"返回true,没有返回false

a.size() //返回集合

a.retainAll(v) //a和v俩集合的交集,将交集留下来,a集合只剩下了交集的元素,发生变化返回true,都一样是false,v集合不变

a.size()//集合里面有几个元素注意:数组长度length(属性) 字符串长度length(方法) size(方法)

Object[] o =a.toArray();//将集合转为数组

String[] b =a.toArray(new String[a.size()]);//将集合转为string类型的数组

四. List 接口及实现类

List继承了Collection接口,有三个实现的类

－ ArrayList

数组列表，数据采用数组方式存储。是可以变长的

查询快,中间增删慢(元素要进行移位)

－ LinkedList

链表结构,查询慢(必须从头或者从尾开始查找,直到找到),中间增删快(只需要改变后继节点的位置)

－ Vector

数组列表，添加同步锁,线程安全的

(1)ArrayList:

ArrayList<String> list = new ArrayList<>();
                          list.add("a");
                          list.add("b");
                          list.add("c");
                          list.add("d");
                          list.add("d");
                          list.add("d");
                          list.add("d");

//添加元素:arraylist每次添加元素时都会检查是否需要扩容：arraylist第一次添加元素时，赋予arraylist默认容量10，再往里面添加元素（所以arraylist默认容量10并不是初始化的时候赋予的，而是无参构造第一次添加元素的时候赋予的）；以后每次添加元素前先检查当前元素个数是否已经达到容量上限，若是则先以1.5倍(grow方法)*原容量上限进行扩容再添加元素

ArrayList中的一些方法:

list.add(0,"F")//给指定位置增加元素

list.get(2) //取出第二位元素,注意:index!>=size,底层源码实现

list.remove(0);//删除并返回该值

list.set(8,"K");//替换指定位置的元素

list.size());//实际存入里面的元素的数量

LinkedList:

LinkedList<String> list = new LinkedList<>();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("b");
        list.add("h");
        list.add("u");
        list.add("k");
        list.add("k");
添加元素的方法:链式的添加元素,Node对象中的后继节点如果为null,新来的元素地址就会给null,它现在的元素位置为null

list.get(3);//要找的元素位置小于size/2,那么从头结点开始查找,否则从尾节点开始查找
        list.addLast("a");
        list.addFirst("f");
       list.removeLast();//删除并返回最后一个元素

Vector:

 public static void main(String[] args) {
        //线程安全的,底层也是数组实现
        Vector<Integer> a = new Vector<>();
        a.add(5);
        a.add(5);
        a.add(5);
        a.add(5);
        a.add(5);
        a.add(5);


    }

五.List 接口集合迭代

● for循环遍历

● 增强for循环的遍历

● 迭代器遍历（Iterator）

for循环遍历:

 public static void main(String[] args) {
        //for循环遍历:
        // 可以从中删除元素,但是需要注意:删除后,元素会向前移动
        ArrayList<String> a = new ArrayList<>();
        a.add("aaa");
        a.add("bbb");
        a.add("ccc");
        a.add("aaa");
        a.add("aaa");
        a.add("aaa");
        for (int i = 0; i <a.size() ; i++) {
            for (int j = i+1; j <a.size() ; j++) {
               if(a.get(i).equals(a.get(j))){
                   a.remove(j);
               }
            }
        }
        System.out.println(a);

    }

增强for循环的遍历:

public static void main(String[] args) {//增强for循环在遍历元素时不可以删除元素,若删除,会抛出ConcurrentModificationException并发修改异常
        ArrayList<String> a = new ArrayList<>();
        a.add("aaa");
        a.add("bbb");
        a.add("ccc");
        a.add("ccc");

        /*for (int i = 0; i <a.size() ; i++) {
            if(a.get(i).equals("ccc")){
                a.remove(i);
            }
        }
        System.out.println(a);*/
        for(String t:a){
            if(t.equals("ccc")){
                a.remove(t);
            }
        }
        System.out.println(a);
    }

迭代器遍历（Iterator）:

 public static void main(String[] args) {
        ArrayList<String> a = new ArrayList<>();
        a.add("f");
        a.add("b");
        a.add("c");
        a.add("a");
        a.add("a");
        a.add("a");//iterator返回了一个ArrayList的内部类对象
        a.add("a");
        a.add("a");
        a.add("a");
        a.add("a");
        //迭代器遍历List集合1
        //iterator();返回了一个ArrayList内部类对象,实现iterator接口
        //此内部类专门用作集合进行遍历时的控制
        //hastNext();判断集合中是否还有元素,有返回true
        /*
        Iterator<String> b = a.iterator();
        while (b.hasNext()){
            String b1 = b.next();//取出来一个元素
            if(b1.equals("a")){
                b.remove();//如果在遍历中删除元素,请使用迭代器中的remove()
            }

        }
        System.out.println(a);*/


//括号里的数字表明从第几位开始遍历
        ListIterator<String> c = a.listIterator(a.size());//针对List接口下的集合类,还提供了listIterator()
        while (c.hasPrevious()){
           String a1 = c.previous();
            System.out.println(a1);
        }

    }

六.Set 接口

Set接口继承了Collection接口。

Set中所存储的元素是不重复的,但是是无序的, Set中的元素是没有索引的

● Set接口有两个实现类

● HashSet

HashSet类中的元素不能重复，即彼此调用equals方法比较，都返回false。底层数据结构是哈希表+链表

哈希表依赖于哈希值存储

● TreeSet

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

TreeSet底层数据结构是二叉树(红黑树是一种自平衡的二叉树)

HashSet:

 public static void main(String[] args) {
        HashSet<String> list = new HashSet<>();//HashSet存储元素顺序不固定,且没有重复元素
                        list.add("s");
        list.add("a");
        list.add("f");
        list.add("g");
        list.add("f");
        list.add("j");
        list.add("k");
        System.out.println(list);

        ArrayList<String> a = new ArrayList<>();
        a.add("f");
        a.add("b");
        a.add("c");
        a.add("a");
        a.add("a");
        a.add("a");
        a.add("a");
        a.add("a");
        a.add("a");
        a.add("a");
        HashSet<String> v = new HashSet<>(a);//对a集合进行去掉重复的元素
        System.out.println(v);
        TreeSet<String> n = new TreeSet<>(a);//对a去掉重复的元素并进行排序
        System.out.println(n);
    }

为什么HashSet中的元素不重复?

俩种方法:

Hash值判断和equals方法判断

public class HashSetDemo2 {
    public static void main(String[] args) {
        //carl类没有重写hashcode方法,用的是object中的方法,返回的hash值比较的是地址,四个对象地址不一样,所以队徽添加进去
        //重写后hashcode方法比较的是返回的hash值,如果hash值是一样的,会自动调用equals方法比较内容是否相等
        Car car1  = new Car(101,"宝马1");
        Car car2  = new Car(103,"宝马3");
        Car car3  = new Car(102,"宝马2");
        Car car4  = new Car(101,"宝马1");
        HashSet<Car> hashSet = new HashSet<>();
                     hashSet.add(car1);
                     hashSet.add(car2);
                     hashSet.add(car3);
                     hashSet.add(car4);
        System.out.println(hashSet);
    }
}

TreeSet:

 TreeSet<String> llist = new TreeSet<>();//TreeSet按照元素的自然顺序排序,并且也没有重复元素
        llist.add("g");
        llist.add("f");
        llist.add("j");
        llist.add("f");
        llist.add("f");
        llist.add("a");
        llist.add("f");
        System.out.println(llist);//排序就会实现comparable接口,string里面已近实现了接口

七.Set 接口集合迭代

● 遍历方式

增强for循环

迭代器遍历

八.Map 接口

Map 接口概述

将键映射到值的对象 ,一个映射不能包含重复的键 ,每个键最多只能映射到一个值

(1)HashMap

HashMap中元素的key值不能重复，排列顺序是不固定的,可以存储一个为null的键。

(2) Hashtable

实现了同步。

不能存储为null的键

(3)TreeMap

所有的元素都保持着某种固定的顺序，如果需要得到一个有序的Map就应该使用TreeMap，key值所在类必须实现Comparable接口。

(1)HashMap

public class HashMapDemo {
    //键是不能重复的,是无序的,值是可以重复的
    public static void main(String[] args) {
        HashMap<String,String> a = new HashMap<>();
        a.put("a","aaa");//
        a.put("s","sss");
        a.put("v","vvv");
        a.put("h","hhh");
        a.put("m","mmm");
        a.put("m","lll");//key时唯一的,后来的key将之前的覆盖掉了
        a.put(null,"hhh");
        System.out.println(a.remove("h"));//删除key,返回它的值
        System.out.println(a.containsKey("h"));//包含h这个键吗
        System.out.println(a.containsValue("h"));
        System.out.println(a.isEmpty());
        Collection<String> f = a.values();//将值全拿出来
        Set<String> h =a.keySet();//将键拿出来
        a.replace("v","edwede");
        System.out.println(a);
    }
}

(2) Hashtable

public class HashtableDemo {
    //Hashtable值可以重复,键不重复,无序,不可以存储null的值
    public static void main(String[] args) {
        HashMap<String,String> a = new HashMap<>();
        a.put("a","aaa");
        a.put("s","sss");
        a.put("v","vvv");
        a.put("h","hhh");
        a.put("m","mmm");
        a.put("m","lll");
        System.out.println(a.get("v"));
        System.out.println(a);

    }
}

(3)TreeMap

public static void main(String[] args) {
        //键可以排序,其他作为键类型的类必须实现排序接口
        TreeMap<String,String> a = new TreeMap<>();
        a.put("a","aaa");
        a.put("s","sss");
        a.put("v","vvv");
    }

Map 集合遍历

方式1：根据键找值

• 获取所有键的集合

• 遍历键的集合，获取到每一个键

• 根据键找值

方式2：根据键值对对象找键和值

• 获取所有键值对对象的集合

• 遍历键值对对象的集合，获取到每一个键值对对象

• 根据键值对对象找键和值

方式一:

利用集合调用keyset方法将键取出来然后

public static void main(String[] args) {
    HashMap<String,String> a = new HashMap<>();
    a.put("a","aaa");
    a.put("s","sss");
    a.put("v","vvv");

    Set<String> b1 = a.keySet();
    for(String k:b1){
        String value = a.get(k);
        System.out.println(k+"="+value);
    }

方式2：

Set<Map.Entry<String,String>> b = a.entrySet();//使用map集合的方法entryset(),把map集合中的多个entry对象取出来,存储到一个set集合中
        for(Map.Entry<String,String> entry : b){
            String key = entry.getKey();
            String value = entry.getValue();
            System.out.println(key+"="+value);

九.Collections类

Collections 是集合类的工具类，与数组的工具类 Arrays 类似

public class Collection1 {
    public static void main(String[] args) {
       List<Integer> a = new ArrayList<>();
        a.add(4);
        a.add(5);
        a.add(2);
        a.add(1);
        a.add(3);
        a.add(0);
        /*Collections.addAll(a,1,2,3,4);//
        System.out.println(a);
       Collections.sort(a);
        System.out.println(Collections.binarySearch(a,2));
       Collections.swap(a,2,3);
        System.out.println(a);*/
        ArrayList<Integer> a1 = new ArrayList<>();
        a1.add(0);
        a1.add(0);
        a1.add(0);
        a1.add(0);
        a1.add(0);
        a1.add(0);
        a1.add(0);
        /*Collections.copy(a1,a);//注意,新集合的size必须大于新集合的size
        System.out.println(a1);
        Collections.fill(a1,6);
        System.out.println(a1);
        System.out.println( Collections.max(a1));*/
        System.out.println(Collections.replaceAll(a,0,3));
       /*Collections.reverse(a);//逆序
       Collections.shuffle(a);//随机*/
        System.out.println(a);
    }
}