单列集合、多列集合

#博学谷IT学习技术支持#

个人笔记后续会进行内容改进

Arraylist：

Linkelist：

Hashset：

Threeset：

Hashmap：

数组和集合的区别：

数组固定长度；集合不固定

数组可以存基本数据类型和引用数据类型，集合只能存引用数据类型数据，基本数据的话需要封装成包装类

Collection：

是单例集合的顶层接口,它表示一组对象,这些对象也称为Collection的元素

常用方法：

| 方法名                     | 说明                               |

| boolean add(E e)           | 添加元素                           |

| boolean remove(Object o)   | 从集合中移除指定的元素             |

| boolean removeIf(Object o) | 根据条件进行移除                   |

| void   clear()             | 清空集合中的元素                   |

| boolean contains(Object o) | 判断集合中是否存在指定的元素       |

| boolean isEmpty()          | 判断集合是否为空                   |

| int   size()               | 集合的长度，也就是集合中元素的个数 |

迭代器：（遍历）

集合的专用遍历方式

Iterator<E> iterator(): 返回此集合中元素的迭代器,通过集合对象的iterator()方法得到

常用方法两个：

boolean hasNext(): 判断当前位置是否有元素可以被取出

​ E next(): 获取当前位置的元素,将迭代器对象移向下一个索引位置

代码实例：

public class IteratorDemo1 {

    public static void main(String[] args) {

        //创建集合对象

        Collection<String> c = new ArrayList<>();

        //添加元素

        c.add("hello");

        c.add("world");

        c.add("java");

        c.add("javaee");

        //Iterator<E> iterator()：返回此集合中元素的迭代器，通过集合的iterator()方法得到

        Iterator<String> it = c.iterator();

        //用while循环改进元素的判断和获取

        while (it.hasNext()) {

            String s = it.next();

            System.out.println(s);

        }

    }

}

增强for：（遍历）

快捷方式：对象名。For

for(集合/数组中元素的数据类型 变量名 :  集合/数组名) {

​ // 已经将当前遍历到的元素封装到变量中了,直接使用变量即可

​ }

List

- List

  - 有序集合,这里的有序指的是存取顺序

  - 用户可以精确控制列表中每个元素的插入位置,用户可以通过整数索引访问元素,并搜索列表中的元素

  - 与Set集合不同,列表通常允许重复的元素

List集合的特点

  - 存取有序

  - 可以重复

  - 有索引

List集合常用方法：

| 方法名                          | 描述                                   |

| void add(int index,E   element)    | 在此集合中的指定位置插入指定的元素     |

| E remove(int   index)           | 删除指定索引处的元素，返回被删除的元素 |

| E set(int index,E   element)      | 修改指定索引处的元素，返回被修改的元素 |

| E get(int   index)              | 返回指定索引处的元素                   |

List集合实现类：

- ArrayList集合

  ​ 底层是数组结构实现，查询快、增删慢

- LinkedList集合

  ​ 底层是链表结构实现，查询慢、增删快

Arraylist：

构造：

| public ArrayList()                   | 创建一个空的集合对象               |

| public boolean add(E e)              | 将指定的元素追加到此集合的末尾     |

| public void add(int index,E element) | 在此集合中的指定位置插入指定的元素 |

方法：

| public boolean remove(Object o)   | 删除指定的元素，返回删除是否成功       |

| public E remove(int index)        | 删除指定索引处的元素，返回被删除的元素 |

| public E set(int index,E element) | 修改指定索引处的元素，返回被修改的元素 |

| public E get(int index)           | 返回指定索引处的元素                   |

| public int size()                 | 返回集合中的元素的个数                 |

代码：

public class ArrayListDemo02 {

    public static void main(String[] args) {

        //创建集合

        ArrayList<String> array = new ArrayList<String>();

        //添加元素

        array.add("hello");

        array.add("world");

        array.add("java");

        //public boolean remove(Object o)：删除指定的元素，返回删除是否成功

//        System.out.println(array.remove("world"));

//        System.out.println(array.remove("javaee"));

        //public E remove(int index)：删除指定索引处的元素，返回被删除的元素

//        System.out.println(array.remove(1));

        //IndexOutOfBoundsException

//        System.out.println(array.remove(3));

        //public E set(int index,E element)：修改指定索引处的元素，返回被修改的元素

//        System.out.println(array.set(1,"javaee"));

        //IndexOutOfBoundsException

//        System.out.println(array.set(3,"javaee"));

        //public E get(int index)：返回指定索引处的元素

//        System.out.println(array.get(0));

//        System.out.println(array.get(1));

//        System.out.println(array.get(2));

        //System.out.println(array.get(3)); //？？？？？？ 自己测试

        //public int size()：返回集合中的元素的个数

        System.out.println(array.size());

        //输出集合

        System.out.println("array:" + array);

    }

}

Linkelist：

方法：

| 方法名                    | 说明                             |

| public void addFirst(E e)     | 在该列表开头插入指定的元素       |

| public void addLast(E e)     | 将指定的元素追加到此列表的末尾   |

| public E getFirst()          | 返回此列表中的第一个元素         |

| public   E getLast()        | 返回此列表中的最后一个元素       |

| public E removeFirst()      | 从此列表中删除并返回第一个元素   |

| public   E removeLast()     | 从此列表中删除并返回最后一个元素 |

代码：

public class MyLinkedListDemo4 {

    public static void main(String[] args) {

        LinkedList<String> list = new LinkedList<>();

        list.add("aaa");

        list.add("bbb");

        list.add("ccc");

//        public void addFirst(E e) 在该列表开头插入指定的元素

        //method1(list);

//        public void addLast(E e) 将指定的元素追加到此列表的末尾

        //method2(list);

//        public E getFirst() 返回此列表中的第一个元素

//        public E getLast() 返回此列表中的最后一个元素

        //method3(list);

//        public E removeFirst() 从此列表中删除并返回第一个元素

//        public E removeLast() 从此列表中删除并返回最后一个元素

        //method4(list);

      

    }

    private static void method4(LinkedList<String> list) {

        String first = list.removeFirst();

        System.out.println(first);

        String last = list.removeLast();

        System.out.println(last);

        System.out.println(list);

    }

    private static void method3(LinkedList<String> list) {

        String first = list.getFirst();

        String last = list.getLast();

        System.out.println(first);

        System.out.println(last);

    }

    private static void method2(LinkedList<String> list) {

        list.addLast("www");

        System.out.println(list);

    }

    private static void method1(LinkedList<String> list) {

        list.addFirst("qqq");

        System.out.println(list);

    }

}

泛型：

定义格式

- <类型>: 指定一种类型的格式.尖括号里面可以任意书写,一般只写一个字母.例如: <E> <T>

- <类型1,类型2…>: 指定多种类型的格式,多种类型之间用逗号隔开.例如: <E,T> <K,V>

Set

特点：

+ 不可以存储重复元素

+ 没有索引,不能使用普通for循环遍历

TreeSet集合：

+ 不可以存储重复元素

+ 没有索引

+ 可以将元素按照规则进行排序

  + TreeSet()：根据其元素的自然排序进行排序

  + TreeSet(Comparator comparator) ：根据指定的比较器进行排序

HashSet集合：

- 底层数据结构是哈希表

- 存取无序

- 不可以存储重复元素

- 没有索引,不能使用普通for循环遍历

- 哈希值：

  ​ 是JDK根据对象的地址或者字符串或者数字算出来的int类型的数值

- 如何获取哈希值

  ​ Object类中的public int hashCode()：返回对象的哈希码值

- 哈希值的特点

  - 同一个对象多次调用hashCode()方法返回的哈希值是相同的

  - 默认情况下，不同对象的哈希值是不同的。而重写hashCode()方法，可以实现让不同对象的哈希值相同

哈希表（jdk1.8之前）

数组+链表

（创建一个默认长度16的数组，加载因子0.75【当数组的长度超过当前数组长度的0.75后扩容一倍】）

哈希表（jdk1.8之后）

数组+链表+红黑树

当节点上的个数>8转换成红黑树

当节点上的个数<=8数组

数据结构：