什么是数据结构

数据结构是指相互之间存在一种或多种特定关系的数据元素的集合，亦是计算机存储，组织数据的方式;

通常情况下,每种数据结构均有其特定的使用场景数据结构，可带来更高效的运行或存储效率；

数据结构往往同高效的检索算法和索引技术有关;

数据结构的基本功能

同数据库类似，同样有增(Create) 删(Delete) 改(Update) 查(Retrieve)，简写：CURD

常见数据结构

数组(Array)

数组（array）是一种最简单的复合数据类型，它是有序数据的集合，数组中的每个元素具有相同的数据类型，可以用一个统一的数组名和不同的下标来确定数组中唯一的元素。根据数组的维度，可以将其分为一维数组、二维数组和多维数组等，大白话来说就类似洋葱，一层一层包裹在一起，最外层就是一维数组。

例子：

        //定义并实例化数组
        int[] num1 = {1,2};
        int[][] num2 = {{1,2},{3,4}};
        int[][][] num3 = {{{1,2},{3,4}}};
        int[][][][] num4 = {
                {
                    {
                        {0},{1}
                    },{
                        {2},{3}
                    }
                },{
                    {
                        {4},{5}
                    },{

                    }

                },{

                }
        };
        //遍历四维数组
        for (int i = 0; i < num4.length; i++) {
            for (int j = 0; j < num4[i].length; j++) {
                for (int j2 = 0; j2 < num4[i][j].length; j2++) {
                    for (int k = 0; k < num4[i][j][j2].length; k++) {
                        System.out.println("下标="+i+"-"+j+"-"+j2+"-"+k +" || 值="+num4[i][j][j2][k]);
                }
                }
            }
        }
        //输出结果
        //下标=0-0-0-0 || 值=0
        //下标=0-0-1-0 || 值=1
        //下标=0-1-0-0 || 值=2
        //下标=0-1-1-0 || 值=3
        //下标=1-0-0-0 || 值=4
        //下标=1-0-1-0 || 值=5
        //由此可以得出，多维数组本质就是一层嵌套二层，二层嵌套三层，以此类推

Map<K,V>

键-值映射的接口。且不能包含重复的键，键-值成一对一的关系。
包含方法：

int size(); //返回Map的个数。
boolean isEmpty(); //Map是否为空
boolean containsKey(Object key); //Map是否包含特定键
boolean containsValue(Object value); //Map是否包含特定值
V get(Object key); //获取Map中特定key的值
V put(K key, V value); //插入特定键值到Map中。若Map已存在相同键，则为更新操作。
V remove(Object key); //移除特定键的映射
void putAll(Map<? extends K, ? extends V> m); //将相同键值类型的特定Map数据，存储到当前Map中。
void clear(); //清除Map所有数据。
Set keySet(); //返回存放在Set中的所有键
Collection values();//返回存放在Collection中的所有值
Set<Map.Entry<K, V>> entrySet();//返回存放在Collection中的所有值
boolean equals(Object o);//比较对象是否相等
int hashCode();//哈希值

以下是JDK1.8新加的特性，即接口可以有默认实现方法

default V getOrDefault(Object key, V defaultValue){...} // 获取Map中特定key的值。若没有，则返回预设的默认值。
default void forEach(BiConsumer<? super K, ? super V> action) {...} // BiConsumer功能接口，也就是传入该对象，forEach方法会循环调用action.accept(k, v)。输出每一个映射的数据;
default void replaceAll(BiFunction<? super K, ? super V, ? extends V> function) {...} // 支持以自定义算法修改Map里的值。
default V putIfAbsent(K key, V value) {...} //Map中指定键不存在则存入。最终返回值。
default boolean remove(Object key, Object value) {...} // 移除特定键的映射。
default boolean replace(K key, V oldValue, V newValue) {...}// 使用新值更换旧值。
default V replace(K key, V value) {...}// 替换指定键的值。
default V computeIfAbsent(K key, Function<? super K, ? extends V> mappingFunction) {...} // 如果特定键的值为null, 则支持以自定义算法修改该key的值。
default V computeIfPresent(K key,BiFunction<? super K, ? super V, ? extends V> remappingFunction) {...} // 如果特定键的值存在，则支持自定义函数产生新值，且新值不为null，则替换旧值，若新值为空则移除该映射。
default V compute(K key,BiFunction<? super K, ? super V, ? extends V> remappingFunction) {...}// 可使用指定键与其值，供自定义算法产生新值。若新值为null,且旧值不为null或存在key,则删除该映射。否则，使用新值更换旧值。
default V merge(K key, V value, BiFunction<? super V, ? super V, ? extends V> remappingFunction) {...}//支持自定义函数产生新值，且新值不为null，则替换旧值，若新值为空则移除该映射。

鉴于新特性可能不太容易理解。附示例代码如下：

        //需要修改 Language level 为 Lambdas
        Map<String, String> map = new HashMap();
        map.put("a", "1");
        Map<String, String> map2 = new HashMap();
        map2.put("b", "2");
        map.putAll(map2);

        String c = map.getOrDefault("d", "c");
        BiConsumer<String, String> biConsumer = (String s, String s2) -> System.out.println(s + ":" + s2);
        BiFunction<String, String, String> biFunction = (String s, String s2) -> 2 + s2;
        Function<String, String> function = (String s) -> "aa";
        BiFunction<String, String, String> biFunction2 = (String s, String s2) -> "222";
        BiFunction<String, String, String> biFunction3 = (String s, String s2) -> null;
        BiFunction<String, String, String> biFunction4 = (String s, String s2) -> "aa";
        //map.forEach(biConsumer);
        //map.replaceAll(biFunction);
        //map.computeIfAbsent("aa",function);
        //map.computeIfPresent("a",biFunction2);
        //map.compute("a",biFunction3);
        map.merge("c","xxx2",biFunction4);

        System.out.println(map.toString());

常用实现类有HashMap、Hashtable、TreeMap、ConcurrentHashMap、LinkedHashMap。可点击，查阅源码分析，可知晓其实现流程。

队列(Queue)

一种特殊的线性表，它只允许在表头部进行删除操作，只允许在表尾部进行插入操作。进行插入操作的端称为队尾，进行删除操作的端称为队头。

通常每个元素总是从队列的尾部进入队列，然后等待该元素之前的所有元素出队之后，当前元素才能出队，遵循先进先出（FIFO）原则。

本文由 Administrator 创作，采用知识共享署名4.0 国际许可协议进行许可
本站部分文章采集自互联网，因某些原因未注明出处，如有侵权，请留言告知。

Java - 常见数据结构