Java--集合

沐芳莫弹冠

于 2020-05-05 20:40:57 发布

阅读量125

点赞数

分类专栏： java

本文链接：https://blog.csdn.net/jklmf1/article/details/105908208

版权

java 专栏收录该内容

16 篇文章 0 订阅

订阅专栏

1、集合概述

1.1、什么是集合？有什么用？

数组其实就是一个集合。集合实际上就是一个容器。可以来容纳其它类型的数据。

集合为什么说在开发中使用较多？
集合是一个容器，是一个载体，可以一次容纳多个对象。在实际开发中，假设连接数据库，数据库当中有10条记录，那么假设把这10条记录查询出来，在java程序中会将10条数据封装成10个java对象，然后将10个java对象放到某一个集合当中，将集合传到前端，然后遍历集合，将一个数据一个数据展现出来。

1.2、集合不能直接存储基本数据类型，另外集合也不能直接存储java对象，

集合当中存储的都是java对象的内存地址。（或者说集合中存储的是引用。）
list.add(100); //自动装箱Integer
注意：
集合在java中本身是一个容器，是一个对象。
集合中任何时候存储的都是“引用”。

1.3、在java中每一个不同的集合，底层会对应不同的数据结构。

往不同的集合中存储元素，等于将数据放到了不同的数据结构当中。什么是数据结构？数据存储的
结构就是数据结构。不同的数据结构，数据存储方式不同。例如：数组、二叉树、链表、哈希表…
以上这些都是常见的数据结构。

你往集合c1中放数据，可能是放到数组上了。
你往集合c2中放数据，可能是放到二叉树上了。
…
你使用不同的集合等同于使用了不同的数据结构。

你在java集合这一章节，你需要掌握的不是精通数据结构。java中已经将数据结构实现了，已经写好了这些常用的集合类，你只需要掌握怎么用？在什么情况下选择哪一种合适的集合去使用即可。

new ArrayList(); 创建一个集合，底层是数组。
new LinkedList(); 创建一个集合对象，底层是链表。
new TreeSet(); 创建一个集合对象，底层是二叉树。
…

1.4、集合在java JDK中哪个包下？

java.util.*;
所有的集合类和集合接口都在java.util包下。

1.5、最好能将集合的继承结构图背会！！！

集合整个这个体系是怎样的一个结构，你需要有印象。

1.6、在java中集合分为两大类：

一类是单个方式存储元素：
单个方式存储元素，这一类集合中超级父接口：java.util.Collection;

一类是以键值对儿的方式存储元素
以键值对的方式存储元素，这一类集合中超级父接口：java.util.Map;

2、总结重点：

第一个重点：把集合继承结构图背会。

第二个重点：把Collection接口中常用方法测试几遍。

第三个重点：把迭代器弄明白。

第四个重点：Collection接口中的remove方法和contains方法底层都会调用equals，
这个弄明白。

Collection集合继承图

在这里插入图片描述

Map集合继承图

在这里插入图片描述
Java 集合主要有 3 种重要的类型：
List：是一个有序集合，可以放重复的数据
Set：是一个无序集合，不允许放重复的数据实际是放到了Map的key部分
Map：是一个无序集合，集合中包含一个键对象，一个值对象，键对象不允许重复，值对象可以重
复（身份证号—姓名）key部分可以看作是set集合

3、Collection接口常用方法

Collection中可以存储Object的所有子类型

使用”泛型“之后，只能存储某个具体的类型。
Collection相当于爷爷，所有子类都包含如下常用方法。
add clear remove isEmpty contains

import java.util.ArrayList;
import java.util.Collection;

public class CollectionTest01 {
    public static void main(String[] args) {
        //创建一个集合对象
        //Collection c = new Collection();接口是抽象的，无法实例化

        //多态
        Collection c = new ArrayList();
        //测试Collection接口中的常用方法
        c.add(1200);//自动装箱，实际是放进去一个对象的内存地址。Integer x = new Integer(1200);
        c.add(3.14);
        c.add(new Object());
        c.add(true);

        //获取集合中元素的个数
        System.out.println(c.size());

        //清空集合
        c.clear();

        c.add(1);

        //判断集合中是否包含

        boolean flag = c.contains(1200);
        System.out.println(flag);

        //删除元素 返回boolean类型
        c.remove(1);

        //是否为空
       System.out.println(c.isEmpty());


    }
}

4、Collection集合迭代

额外注意：迭代器必须在集合改动元素之后获取，否则会出现异常。
迭代器是通用的。
迭代器对象最初并没有指向第一个元素
迭代器对象Iterator中有两个方法：
boolean hasNext() 如果仍有元素可以迭代，则返回true。
* Object next() 返回迭代的下一个元素
第一步：获取集合对象的迭代器对象Iterator
Iterator it = c.iterator();
第二步：通过以上获取的迭代器对象开始迭代/遍历集合
while(it.hasNext()){
Object obj = it.next();
System.out.println(obj);
}

示例：

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class CollectionTest02 {
    public static void main(String[] args) {
        //以下讲解的遍历方式/迭代方式，时所有Collection通用的。
        //在Map集合中不能使用。在Collection以及子类中使用。

        Collection c = new ArrayList();//后面的集合无所谓，主要看前面的接口如何遍历

        c.add("abc");
        c.add("def");
        c.add(100);
        c.add(new Object());
        /*
        * 迭代器对象it最初并没有指向第一个元素
        * 迭代器对象Iterator中有两个方法：
        *       boolean hasNext()如果仍有元素可以迭代，则返回true。
        *       Object next() 返回迭代的下一个元素
        * */
        //第一步：获取集合对象的迭代器对象Iterator
        Iterator it = c.iterator();
        //第二步：通过以上获取的迭代器对象开始迭代/遍历集合

        while(it.hasNext()){
            Object obj = it.next();
            System.out.println(obj);
        }

    }
}

5、Collection的contains和remove方法解析

在这里插入图片描述

public class CollectionTest02 {
    public static void main(String[] args) {
        Collection c = new ArrayList();
        
        String s1 = new String("abc");
        c.add(s1);

        String s2 = new String("abc");
        c.add(s2);
        
        String x = new String("abc");

        System.out.println(c.contains(x));//true 底层调用equals方法
    }
}

remove也调用了equals方法会认为s1和s2是一样的

public class CollectionTest02 {
    public static void main(String[] args) {
        Collection c = new ArrayList();
        
        String s1 = new String("abc");
        c.add(s1);

        String s2 = new String("abc");
        c.add(s2);
        
        String x = new String("abc");

        System.out.println(c.contains(x));//true 底层实现equals

		//remove
		Collection c1 = new ArrayList();	
		 String s1 = new String("hello");
        c1.add(s1);
          String s2 = new String("hello");
          c1.remove(s2);
			 System.out.println(c1.size());//0
    }
}

6、List接口特有方法

List集合存储元素特点：有序可重复

     有序：List集合中的元素有下标。

默认初始化容量10（底层先创建一个长度为0的数组，当添加第一个元素的时候，初始化容量10）
```
     集合底层是Object[]数组
```

     构造方法new ArrayList() new ArrayList(20) 里面可以再放一个集合可以将其他集合转化为list

     容量不够时会自动扩容为1.5倍

与LinkedList相比
数组的查询更快，增删较慢。双向链表反之。

Vector
用的最少，方法都差不多，元素满了也会扩容。底层实现也是数组。

方法
add可在指定位置添加元素但效率低用的少，默认在末尾添加
Object get根据下标获取元素
可以按类似于数组方式遍历利用.size和get
indexof获取对象第一次出现的索引（下标）
lastIndexof获取对象最后一次出现的索引
remove删除指定位置
set修改指定位置

public class ListTest01 {

    public static void main(String[] args) {

        List myList = new ArrayList();

        //添加
        myList.add("A");
        myList.add("B");
        myList.add("C");
        myList.add("D");
        myList.add(1,"KING");//使用不多 效率低 因为ArrayList底层是数组

        //迭代
        Iterator it = myList.iterator();
        while(it.hasNext()){
            Object obj = it.next();
            System.out.println(obj);
        }

        //get根据下标获取元素
        Object firstObj = myList.get(0);
        System.out.println(firstObj);

        //特殊数组遍历
        for(int i=0; i<myList.size(); i++){
            Object o = myList.get(i);
            System.out.println(o);
        }

        //获取第一次出现的位置
        System.out.println(myList.indexOf("KING"));

        //获取最后一次出现的索引
        System.out.println(myList.lastIndexOf("C"));

        //删除
        myList.remove(0);
        System.out.println(myList.size());

        //修改
        myList.set(2, "Soft");
    }
}

7、Set的简单演示

无序不可重复

HashSet
放到HashSet中的元素其实是放到了HashMao中的key部分了

public class ListTest01 {

    public static void main(String[] args) {

        Set<String> strs = new HashSet();

        strs.add("hello3");
        strs.add("hello4");
        strs.add("hello1");
        strs.add("hello2");
        strs.add("hello3");
        strs.add("hello4");
        strs.add("hello2");

        for(String s : strs){
            System.out.println(s);
        }
    }
}

结果：
hello1
hello4
hello2
hello3

TreeSet
自动排序

8、Map接口常用方法

1、Map和Collection没有继承关系
2、Map集合以key和value的方式存储数据：键值对

  key和value都是引用数据类型，存储对象的内存地址，

```
  key起到主导的地位。 
```

所有的key是set集合
3、Map接口中常用方法：

   V put(K key, V value) 向Map集合中添加键值对

  v get(Object key) 通过key获取value

```
  void clear()    清空Map集合
```

  boolean containsKey(Object key) 判断Map中是否包含某个key

  boolean containsValue(Object value) 判断Map中是否包含某个value

  boolean isEmpty()   判断Map集合中元素个数是否为0

  Set<K> keySet() 获取Map集合所有的key（所有的健是一个set集合）

  V remove(Object key)    通过key删除键值对

  int size()  获取Map集合中键值对的个数。

```
  Collection<V> values()  获取Map集合中所有的value，返回一个Collection
```
Set<Map.Entry<K,V>> entrySet()
将Map集合转换成Set集合
假设现在有个Map集合：如下
key value
1 zhangsan
2 lisi
3 wangwu
4 zhaoliu

Set set = map1.entrySet();
set集合对象
1=zhangsan 变成一个元素类型是Map.Entry<K,V> Map中的静态内部类
2=lisi
3=wangwu
4=zhaoliu

public static void main(String[] args) {
        //创建Map集合对象
        Map<Integer, String> map = new HashMap<>();

        //添加
        map.put(1, "zhangsan");
        map.put(2, "lisi");
        map.put(3, "wangwu");
        map.put(4, "zhaoliu");

        //通过key获取value
        String value = map.get(2);
        System.out.println(value);

        //获取键值对的数量
        System.out.println("键值对的数量：" + map.size());

        //通过key删除key-value
        map.remove(2);

        System.out.println("键值对的数量：" + map.size());

        //判断包含某个key contains方法底层调用都是equals方法
        System.out.println(map.containsKey(4));//t
        //判断包含某个value
        System.out.println(map.containsValue("wangwu"));//true

        //获取所有的value
        Collection<String> values = map.values();
        for(String s : values){
            System.out.println(s);
        }


        //清空map集合
        map.clear();

        map.isEmpty();//t

    }

9、遍历Map集合的两种方式

第一种方式：获取所有的key，通过遍历key，来遍历value
Map<Integer, String> map = new HashMap<>();

第二种方式 Set<Map.Entry<K,V>> entrySet()
Set<Map.Entry<Integer,String>> set = map.entrySet();
将Map集合转换成Set集合，类型是Map.Entry<K,V>， Map中的静态内部类

 public static void main(String[] args) {

        //第一种方式：获取所有的key，通过遍历key，来遍历value
        Map<Integer, String> map = new HashMap<>();

        map.put(1, "zhangsan");
        map.put(2, "lisi");
        map.put(3, "wangwu");
        map.put(4, "zhaoliu");

        //获取所有key
        Set<Integer> keys = map.keySet();

        //遍历key 迭代器或foreach

        Iterator<Integer> it = keys.iterator();
        while(it.hasNext()){
            Integer key = it.next();
            String value = map.get(key);
            System.out.println(key + "=" + value);
        }

        for(Integer i : keys){
            System.out.println(i + "=" + map.get(i));
        }


        //第二种方式 Set<Map.Entry<K,V>> entrySet()
       Set<Map.Entry<Integer,String>> set = map.entrySet();
        //遍历set集合，每一次取出一个Node
        //迭代器
        Iterator<Map.Entry<Integer,String>> it2 = set.iterator();
        while (it2.hasNext()){
            Map.Entry<Integer,String> node = it2.next();
            Integer key = node.getKey();
            String value = node.getValue();
            System.out.println(key + "=" + value);

        }

        //foreach 这种效率更高
        for( Map.Entry<Integer,String> node : set){
            System.out.println(node.getKey() + "--->" + node.getValue());
        }

    }

10、哈希表数据结构

1、HashMap集合底层是哈希表的数据结构。
2、哈希表是一个数组和单向链表的结合体。
3、HashMap集合底层的源代码：
public class HashMap{

HashMap底层是一个一维数组。
Node<K,V>[] table;
//静态的内部类HashMap,Node
static class Node<K,V>{
final int hash;//哈希值（哈希值是key的hashCode()方法的执行结果。hash值通过哈希函数/算法，可以转换存储成数组的下标。
final K key;//存储到Map集合中的那个key
V value； // 存储到Map集合中的那个value
Node<K,V> next;// 下一个节点的内存地址。
}

4、最主要掌握的是：
map.put<K,V>
v = map.get(K)
以上存和取两个方法的实现原理，是必须掌握的。

5、HashMap集合的key部分特点：
无序，不可重复。
为什么无序？因为不一定挂到哪个单向链表上。
不可重复？equals方法来保证HashMap集合的key不可重复。
6、哈希表的hashCode()方法
既不能设定返回值是固定的，也不能是都不一样的。
固定的就变为了单向链表，都不一样就变为一维数组了。
在这里插入图片描述

沐芳莫弹冠

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java--集合

1、集合概述1.1、什么是集合？有什么用？数组其实就是一个集合。集合实际上就是一个容器。可以来容纳其它类型的数据。集合为什么说在开发中使用较多？集合是一个容器，是一个载体，可以一次容纳多个对象。在实际开发中，假设连接数据库，数据库当中有10条记录，那么假设把这10条记录查询出来，在java程序中会将10条数据封装成10个java对象，然后将10个java对象放到某一个集合当中，将集合传到...
复制链接

扫一扫