数组与集合的对比-CSDN博客

数组声明了它容纳的元素的类型
集合不声明。

数组是静态的，一个数组实例具有固定的大小，一旦创建了就无法改变容量了
集合是可以动态扩展容量，可以根据需要动态改变大小，集合提供更多的成员方法，能满足更多的需求。

数组的存放的类型只能是一种（基本类型/引用类型）
集合存放的类型可以不是一种(不加泛型时添加的类型是Object)。

数组是java语言中内置的数据类型,是线性排列的,执行效率或者类型检查都是最快的。
ArrayList就是基于数组创建的容器类.

List的元素有序是因为它的底层是线性结构的数组（或者链表），元素的存取是和add的先后(时间)次序有关的——本质上与时间相关
Set的元素无序是因为它的底层是非线性结构的哈希表/二叉树，元素的存取是和add的先后(时间)顺序无关的——你先add还是后add，都是存在Hash表中的同一个位置/在二叉树中，无论你先add还是后add，最后都输出的是排序（默认自然排序）后的数组——本质上和时间无关

package com.example.demo.studytwo.shuzujihe;

import javax.print.DocFlavor;
import java.util.*;

public class shuzulihe {
    public static void main(String[] args) {
        /**
         * 数组是定长的
         * 集合是不定长，可以随便往里面加减数据
         * 集合可以删除数据，数组不行
         * 集合：  有序集合、无序集合
         * list是有序集合
         */
        int[] arr = {1,2,3,5,6,7,8,0};
        ArrayList<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        System.out.println(arr[4]);
        System.out.println(list.get(2));
        /**
         * 6
         * 3
         */
        list.remove(0);
        list.forEach(x -> System.out.println(x));
        System.out.println();
        /**
         * 2
         * 3
         * 4
         */

        /**
         *数组
         * map<K,V>
         * K : key
         * V : Value
         */
        HashMap<String, String> map = new HashMap<>();
        map.put("name","lili");
        map.put("age","23");
        map.put("gender","女");
        String name = map.get("name");
        System.out.println(name);
        //把map中的数据都拿出来放到Set中
        Set<Map.Entry<String, String>> entries = map.entrySet();
        System.out.println(entries);
        //set中有迭代器这个功能
        Iterator<Map.Entry<String, String>> iterator = entries.iterator();
        //通过迭代器的功能拿出set中所有的元素（遍历）
        while (iterator.hasNext()){
            //取出这个元素
            Map.Entry<String, String> next = iterator.next();
            //[gender=女, name=lili, age=23]
            //从元素中拿出Value，也可以拿出key
            System.out.println(next.getValue());
            /**
             * 女
             * lili
             * 23
             */
            System.out.println(next.getKey());
            /**
             * gender
             * name
             * age
             */
            System.out.println(next.getClass());
            /**
             * class java.util.HashMap$Node
             * class java.util.HashMap$Node
             * class java.util.HashMap$Node
             */
        }
/**
 * [gender=女, name=lili, age=23]
 * 女
 * gender
 * class java.util.HashMap$Node
 * lili
 * name
 * class java.util.HashMap$Node
 * 23
 * age
 * class java.util.HashMap$Node
 */
 //set是无序集合
 Set<Integer> set = new HashSet<>();
        set.add(123);
        set.add(345);
        set.add(12);
        set.add(876);
        for (Integer s:set){
            System.out.println(s + "" + s.hashCode());
            /**
             * 345345
             * 123123
             * 1212
             * 876876
             */
        }
}
}

一.集合的体系结构：
List、Set、Map是这个集合体系中最主要的三个接口。 List和Set继承自Collection接口。 Map也属于集合系统，但和Collection接口不同。
Set不允许元素重复。HashSet和TreeSet是两个主要的实现类。Set 只能通过游标来取值，并且值是不能重复的。
List有序且允许元素重复。ArrayList、LinkedList和Vector是三个主要的实现类。 ArrayList 是线程不安全的， Vector 是线程安全的，这两个类底层都是由数组实现的 LinkedList 是线程不安全的，底层是由链表实现的
Map 是键值对集合。其中key列就是一个集合，key不能重复，但是value可以重复。 HashMap、TreeMap和Hashtable是Map的三个主要的实现类。 HashTable 是线程安全的，不能存储 null 值 HashMap 不是线程安全的，可以存储 null 值

二.List和ArrayList的区别
1.List是接口，List特性就是有序,会确保以一定的顺序保存元素.
ArrayList是它的实现类,是一个用数组实现的List.
Map是接口,Map特性就是根据一个对象查找对象.
HashMap是它的实现类,HashMap用hash表实现的Map,就是利用对象的hashcode(hashcode()是Object的方法)进行快速散列查找.(关于散列查找,可以参看<<数据结构>>)
2.一般情况下,如果没有必要,推荐代码只同List,Map接口打交道.
比如:List list = new ArrayList();
这样做的原因是list就相当于是一个泛型的实现,如果想改变list的类型,只需要:
List list = new LinkedList();//LinkedList也是List的实现类,也是ArrayList的兄弟类
这样,就不需要修改其它代码,这就是接口编程的优雅之处.
另外的例子就是,在类的方法中,如下声明:
private void doMyAction(List list){}
这样这个方法能处理所有实现了List接口的类,一定程度上实现了泛型函数.
3.如果开发的时候觉得ArrayList,HashMap的性能不能满足你的需要,可以通过实现List,Map(或者Collection)来定制你的自定义类.
数组与集合之间的转换：
。。。。。。。。。。！