Java集合框架-Collection01-堆栈

开启掘金成长之旅！这是我参与「掘金日新计划 · 12 月更文挑战」的第2天。[点击查看活动详情] 目录

一：堆栈

二：接口

1.Collection接口

​编辑 集合中只能添加引用类型数据

2. List接口

3. 泛型

4. 装箱、拆箱

5. ArrayList、LinkedList、Vector区别

总结：

一：堆栈 1、堆栈结构有先进后出的特点，就像弹夹一样，先进去的在后进去的低下。

2.在开发时，LinkedList集合也可以作为堆栈，队列的结构使用。 使用的方法是：调用addFirst(E e) 方法和getFirst() 方法 注意不要调用add方法，否则将无法满足堆栈先进后出的特点

package com.zking.Collection.util;

import java.util.LinkedList;

public class MyStack { //以枪中的子弹为例 //弹夹 private LinkedList ls=new LinkedList<>(); //装弹 public void push(Object object) { ls.addFirst(object);//每次都把子弹增加到第一弹，把原来的压到下面去 } //打枪 public Object pop() { Object object=ls.getFirst();//取出第一弹 ls.removeFirst(); return object; } public int size() { return ls.size(); } public static void main(String[] args) {//如果子弹的数目不等于1则一直循环下去 MyStack ms=new MyStack(); ms.push(“a”); ms.push(“b”); ms.push(“c”); ms.push(“m”); while(ms.size()!=0) { System.out.println(ms.pop()); } }

}

二：接口 1.Collection接口 1 集合框架的顶级接口 2 是Set和List的父接口 3 但不是Map的父接口

（如图所示）

集合中只能添加引用类型数据 2. List接口 2.1 特点：有序、对象可以重复

2.2 遍历方式 2.2.1 下标 2.2.2 foreach(>=jdk1.5) 2.2.3 迭代器Iterator（原理）

2.3 List优化 初始容量10,负载因子1.5

  指定初始容量

2.4 List元素删除

public class Demo1 {

/**
 * List优化

package com.zking.Collection.util;

import java.util.ArrayList; import java.util.Iterator; import java.util.List; import java.util.ListIterator;

public class Demo {

public static void main(String[] args) {
    //1.UML：统一建模语言，例如：类图，用例图等等
    //2.Collection接口：是集合框架的顶级接口，是list和set的父级接口，但不是Mep集合的父级接口
    //3.list特点：不唯一、有序
    //1)不唯一：不是唯一、可以添加重复元素
    //2)有序：元素添加顺序与输出顺序一致
    List lst=new ArrayList();
    
    lst.add("hh");
    lst.add("dd");
    lst.add("yy");
    lst.add("mm");
    
    //jbk1.8新特性
    lst.forEach(System.out::println);
    //4.list遍历方式（3种）
    //1)for下标
    /*System.out.println("-------1)for下标-------");
    for (int i = 0; i < lst.size(); i++) {
        System.out.println(lst.get(i));
    }
    //2)foreach
    System.out.println("-------2)foreach-------");
    for (Object object : lst) {
        System.out.println(object);
    }
    //3)iterator(迭代器)
    //获取迭代器
    Iterator it=lst.iterator();
    //hasNext():判断集合中的下一个元素是否存在，不移动下标
    //next()：移动下标并取出当前元素
    //循环遍历
    while(it.hasNext()) {
        System.out.println(it.next());
    }*/
    //5.List删除方式（3种+1）
    //1)for正向删除
    //2)for逆向删除
    //3)iterator(推荐)
    //4)clear 清空
    System.out.println("删除之前的List集合大小："+lst.size());
    //第一次删除：i=0 lst.remove(0) a
    //第二次删除：i=1 lst.remove(1) c
    //第三次删除：i=2 2<2
    /*int len=lst.size();
    for (int i = 0; i <len ; i++) {
        lst.remove(0);
    }*/
    /*int len=lst.size()-1;
    for (int i = len; i >= 0; i--) {
        lst.remove(i);
    }*/
    ListIterator it=lst.listIterator();
    while(it.hasNext()) {
        //先移动下标在删除元素
        it.next();
        it.remove();
    }
    System.out.println("删除之前的List集合大小："+lst.size());
    
}

}

3. 泛型 JDK1.5之后 以类型作为参数的类就叫泛型 作用：提高程序健壮性，简化代码 泛型的默认值是Object

package com.zking.Collection.util;

import java.io.File; import java.lang.reflect.Field; import java.util.ArrayList; import java.util.List;

 * 核心概念：
 * 1）初始化容量：10
 * 2）负载因子（扩容比例）：1.5
 * 3）计算公式：当前容器大小*负载因子
 * 第一次：10*1.5（以此类推）
 * @param args
 */
public static void main(String[] args) {
    List lst=new ArrayList(90);
    for (int i = 0; i < 90; i++) {
        lst.add(i);
        System.out.println(i);
        getLen(lst);
    }
}
public static void getLen(List lst) {
    try {
        //获取类对象
        Class<? extends List> cal=lst.getClass();
        //获取类中相应属性；
        Field filed=cal.getDeclaredField("elementData");
        filed.setAccessible(true);
        //获取属性
        Object[] object=(Object[]) filed.get(lst);
        //获取数组的长度
        System.out.println("当前List集合的大小为："+object.length);
    } catch (Exception e) {
        // TODO: handle exception
        e.printStackTrace();
    }
}

}

4. 装箱、拆箱 值类型->引用类型 装箱 引用类型->值类型 拆箱 jdk1.5之后引入了自动装箱及自动拆箱功能

public static void main(String[] args) { //泛型：以类型作为参数的类叫做泛型 //作用：提高程序的健壮性、简化代码 //泛型的默认类型：object //JDK1.5之后 List lst=new ArrayList(); lst.add(2); lst.add(4); lst.add(6); lst.add(9); //获取迭代器 //Iterator it=lst.iterator(); ListIterator it=lst.listIterator(); while(it.hasNext()) { //获取元素 Object val=it.next(); //类型转换 int unm=Integer.valueOf(val.toString()); //获取偶数 if(unm%2==0) { System.out.println(unm); } } //装箱、拆箱jdk1.5之前需要手动转拆箱（之后自动转拆箱） //装箱：值类型->引用类型 int a=1; Integer a1=new Integer(a); //拆箱：引用类型->值类型 Float f=new Float(1.5f); float floatValue=f.floatValue(); }

5. ArrayList、LinkedList、Vector区别 ArrayList：以连续的数组结构存储数据，查询快（下标）、增删改慢 LinkedList：以链表的结构存储数据，查询慢、增删改快 Vector：增删改查都慢，已过时

总结： LinkedList是以链表的结构存储数据，查询慢、增删改快 LinkedList的特有方法： ①addFirst(E e) : 向集合中的开头添加元素 ②addLast(E e)：向集合的末尾添加元素 ③getFirst()：得到集合中的第一个元素 ④getLast()：得到集合中的最后一个元素 ⑤removeFirst()：删除集合中的第一个元素 ⑥removeLast()：删除集合中的最后一个元素 ⑦pop(E e) : 从集合的最上面弹出一个元素 ⑧push()：向集合的最上面添加元素 ⑨isEmpty() : 判断集合中是否有为空

以上就是今天的分享，感谢阅读