集合入门到进阶

目录

单列集合

数据结构

双列集合


单列集合

一次添加一个数据 Collection

List系列集合:添加的元素是有序(存数据和取数据的顺序)、可重复、有索引

Set系列集合:添加的元素是无序(存数据和取数据的顺序)、不重复、无索引

Collection是单列集合的祖宗父接口,功能是全部单列集合都可以继承使用

add、clear、remove、contains(是否包含对象)、isEmpty、size

package Chapter07;
​
import java.util.ArrayList;
import java.util.Collection;
​
public class CollectionDemo1 {
    public static void main(String[] args) {
        // 接口对象,不能直接创建对象  创建其实现类的对象
        Collection<String> coll = new ArrayList<String>();
​
        //1. add    返回boolean  List系列 -> true      Set系列 -> 元素存在 ? false : true
        coll.add("aaa");
        coll.add("bbb");
        coll.add("ccc");
        System.out.println(coll); // [aaa, bbb, ccc]
​
        //2. clear
        coll.clear(); // []
​
        //3. remove 删除对象  存在 ? true : false
        System.out.println(coll.remove("aaa"));
        System.out.println(coll); // [bbb, ccc]
​
        //4.contains 底层依赖 equals方法  自定义对象,Javabean需要重写方法
        System.out.println(coll.contains("bbb")); // true
        System.out.println(coll); // [bbb, ccc]
​
​
        //5.isEmpty
        System.out.println(coll.isEmpty()); // false
        System.out.println(coll); // [bbb, ccc]
​
        //6.size
        System.out.println(coll); // [bbb, ccc]
        System.out.println(coll.size()); // 2
    }
}
​

遍历集合对象

迭代器(删除元素时候使用)、增强for、lambda

package Chapter07;
​
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.function.Consumer;
​
public class CollectionDemo2 {
    public static void main(String[] args) {
        // 接口对象,不能直接创建对象  创建其实现类的对象
        Collection<String> coll = new ArrayList<String>();
        coll.add("aaa");
        coll.add("bbb");
        coll.add("ccc");
        System.out.println(coll); // [aaa, bbb, ccc]
        
        //1.迭代器遍历  1)迭代器遍历时,不能使用集合的方法添加或删除   使用迭代器中的remove删除  2) 迭代器指针不会复位
        Iterator<String> iterator = coll.iterator();
        while (iterator.hasNext()) {
            String str = iterator.next();
            System.out.println(str);
        }
​
        //2.增强 for 遍历    第三方变量
        for (String str : coll) {
            System.out.println(str);
        }
​
        //3.lambda表达式遍历
        coll.forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        });
​
        // lambda表达式
        coll.forEach(s -> System.out.println(s));
    }
}

数据结构

栈、队列


二叉树 -> 查找二叉树 -> 平衡二叉树

红黑树

添加节点规则

Set系列的集合

HashSet:无序,不重复,无索引


  1. HashSet 集合底层采取哈希表存储结构

  2. 哈希表组成------------ jdk8- 数组+链表 jdk8+ 数组+链表+红黑树

  3. 底层原理 1).创建默认长度为16,加载因子(HashSet的扩容时机)为0.75 的数组

    2).int index = (数组长度 - 1)* 哈希值 算出索引值

    3).如果算出的位置已经有元素,调用equalsf方法比较属性值,如果属性值一样不存入数据,如 果不一样,形成链表(8-之前,新元素存入数组,老元素挂在新元素下,8+之后,老元素存 入数组,新元素挂在老元素下)

  4. jdk8+以后 当链表的长度超过8且数组长度>=64时,会转换为红黑树

  5. 如果集合存储的是自定义对象,必须重写hashCode和equals方法 alt+insert String和Integer不需要重写

LinkedHashSet:有序,不重复,无索引


  1. 数据的储存和取出顺序一样

  2. 底层数据结构是哈希表,但是每个元素又多了一个双链表机制记录存储顺序,

  3. 第一个元素的内部会记录第二个元素的地址值,第二个元素的内部会记录第一个元素的地址值

  4. 在遍历时,遍历的是双向链表

TreeSet:可排序,不重复,无索引


按照元素的默认规则,从小到大排序 Integer,Double 从小到大 字符串,字符从 ASCII (字典)码比较升序

TreeSet集合底层基于红黑树的数据结构实现排序,不需要重写hashCode和equals方法

两种比较方式:

1.默认比较规则/自然排序 Javabean类实现Comparable接口指定比较规则

2.比较器排序,创建TreeSet对象时候,传递比较器Comparator指定规则

默认使用第一种,第一种不能满足要求,使用第二种

使用场景

集合中,元素可重复 ArrayList

集合中,增删操作明显多于查询操作,使用LinkedList

集合中,元素去重 HashSet

集合中,元素去重,而且保持存取顺序 LinkedHashSet

集合中,元素进行排序,使用TreeSet集合

双列集合

一次添加两列数据

一次存储一对数据,分别为键和值

键不能重复,值可以重复

键和值是一一对应的,每一个键只能找到自己对应的值

键+值这个整体 称之为键值对,键值对象

map集合的遍历

一、键找值

package Chapter08;
​
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.function.Consumer;
​
public class MapDemo01 {
    public static void main(String[] args) {
        Map<String,String> map = new HashMap<>();
​
        map.put("A","a");
        map.put("B","b");
        map.put("C","c");
​
        Set<String> keySet = map.keySet();
​
        for (String string : keySet) {
            String s = map.get(string);
            System.out.println(string + "=" + s);
        }
​
        keySet.forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                String value = map.get(s);
                System.out.println(s + " = " + value);
            }
        });
​
        Iterator<String> iterator = keySet.iterator();
        while(iterator.hasNext()){
            String next = iterator.next();
            String value = map.get(next);
            System.out.println(next + " = " + value);
        }
    }
}
​

二、键值对

package Chapter08;
​
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.function.Consumer;
​
public class MapDemo02 {
    public static void main(String[] args) {
        Map<String,String> map = new HashMap<>();
​
        map.put("A","a");
        map.put("B","b");
        map.put("C","c");
​
        Set<Map.Entry<String, String>> entries = map.entrySet();
        for (Map.Entry<String, String> entry : entries) {
            String key = entry.getKey();
            String value = entry.getValue();
            System.out.println(key + "=" +value);
        }
​
        entries.forEach(new Consumer<Map.Entry<String, String>>() {
            @Override
            public void accept(Map.Entry<String, String> stringStringEntry) {
                String key = stringStringEntry.getKey();
                String value = stringStringEntry.getValue();
                System.out.println(key+"="+value);
            }
        });
​
        Iterator<Map.Entry<String, String>> iterator = entries.iterator();
        while (iterator.hasNext()){
            Map.Entry<String, String> next = iterator.next();
            String key = next.getKey();
            String value = next.getValue();
            System.out.println(key + " = " + value);
        }
    }
}
​

三、lambda表达式

package Chapter08;
​
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.function.BiConsumer;
import java.util.function.Consumer;
​
public class MapDemo03 {
    public static void main(String[] args) {
        Map<String, String> map = new HashMap<>();
​
        map.put("A", "a");
        map.put("B", "b");
        map.put("C", "c");
​
        map.forEach(new BiConsumer<String, String>() {
            @Override
            public void accept(String s, String s2) {
                System.out.println(s + " = " + s2);
            }
        });
​
        map.forEach((key,value)-> System.out.println(key + " = " + value));
​
    }
}

HashMap:对于键 无序、不重复、无索引


HashMap和HashSet底层相同,都是哈希表结结构

利用hashCode和equals方法保证键的唯一

如果键的位置存储的是自定义对象,需重写hashCode和equals方法

如果值的位置存储的是自定义对象,不需重写hashCode和equals方法

LinkedHashMap:对于键 有序、不重复、无索引


这里的有序是指保证存入和取出的顺序一致

与HashMap底层相同,都是哈希表结结构,只是每个键值对元素多一个双链表机制的记录存储的顺序

TreeMap:对于键,不重复,无索引,可排序


TreeMap和TreeSet的底层原理相同,都是红黑树结构

默认按照键的从小到大的顺序排列,也可以自定义规则

1.实现Comparable接口

2.创建集合时传递Comparator比较器对象

  • 27
    点赞
  • 28
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值