简单聊一下EL表达式与单列集合

1.EL表达式

这里列举一些简单的例子，这个表达式不难理解，过一遍即可

<%
    //请求域
    request.setAttribute("name", "请求域");
    //会话域
    session.setAttribute("name", "会话域");
    //上下文域
    application.setAttribute("name", "上下文域");
%>

${requestScope.name}&nbsp;&nbsp;
${sessionScope.name}&nbsp;&nbsp;
${applicationScope.name}<hr/>
<p>算术表达式</p><br>
1+1=${1+1}&nbsp;&nbsp;10>9是${10>9}&nbsp;&nbsp;
<p>三元表达式：</p><br>
如果我超过18岁，说明我是个${22>18?"成年人":"小孩"}

2.List

1.list的特点

a.数据是有序的

b.每个数据都有索引

c.list的数据允许重复(set的数据不允许重复)

2.list的基本api

  public static void main(String[] args) {
        List food=new ArrayList();
        food.add("玉米");
        food.add("火腿");
        food.add("米饭");
        System.out.println("列表的所有数据是："+food);
        System.out.println("列表的是第三个数据："+food.get(2));
        System.out.println("替换米饭为粥："+food.set(2,"粥"));
        System.out.println("移除粥："+food.remove(2));
        System.out.println("列表的所有数据是："+food);
        System.out.println("开始截取数据0-2:"+food.subList(0,2));
    }

3.ListIterator

这是一个迭代器，有点不同的是，这个迭代器是可以往前、往后双向迭代的

 public static void main(String[] args) {
        List food=new ArrayList();
        food.add("玉米");
        food.add("火腿");
        food.add("米饭");
        System.out.println(food);
        ListIterator<String> iterator=food.listIterator();
        System.out.println("迭代操作");
        while (iterator.hasNext()){
            String f=iterator.next();
            if("火腿".equals(f)){
                System.out.println("这次的数据是火腿："+f);
                iterator.add("鸡腿");
                System.out.println("火腿后面加鸡腿");
            }
            if("米饭".equals(f)){
                iterator.remove();
            }
        }
        System.out.println(food);
        System.out.println("反向迭代");
        while (iterator.hasPrevious()){
            String f=iterator.previous();
            System.out.println(f);
        }
    }

 

4.ArrayList

ArrayList底层是数组，所以查询快，增删慢，而且一般中数据都是读多写少，所以ArrayList非常常用。

默认的数组大小容量是10，超出容量时一般按照1.5倍进行扩容。

5.LinkedList（双向链表）

LinkedList即是List派系下的实现类，也是Queue集合派系下的实现类,底层采用链表实现，查询慢，增删快。

   public static void main(String[] args) {
        LinkedList<String> list= new LinkedList<String>();
        list.add("揭阳");
        list.add("广州");
        list.add("佛山");
        System.out.println(list);
        System.out.println("第二个元素是："+list.get(1));
        list.set(2,"长沙");
        System.out.println("第三个元素换为长沙："+list.get(2));
        list.remove(2);
        System.out.println(list);
    }

[揭阳, 广州, 佛山]
第二个元素是：广州
第三个元素换为长沙：长沙
[揭阳, 广州]

 

   public static void main(String[] args) {
        LinkedList<String> list= new LinkedList<String>();
        list.addFirst("揭阳");
        list.addFirst("广州");
        list.addFirst("佛山");
        System.out.println("第一个元素是："+list.getFirst());
        System.out.println("最后一个元素是："+list.getLast());
        System.out.println(list);
        System.out.println("删除第一个元素："+list.removeFirst());
        System.out.println("删除最后一个元素："+list.removeLast());
        System.out.println(list);
    }

第一个元素是：佛山
最后一个元素是：揭阳
[佛山, 广州, 揭阳]
删除第一个元素：佛山
删除最后一个元素：揭阳
[广州]

6.Vector集合

a.vector底层是list，所以查询快增删慢。

b.初始化容量也是10,，扩容是实现之前的2倍。

c.线程安全，ArrayList线程不安全。

 public static void main(String[] args) {
        Vector<String> vector=new Vector();
        vector.add("num1");
        vector.add("num2");
        vector.addElement("num3");
        vector.addElement("num4");
        ListIterator<String> iterator=vector.listIterator();
        while (iterator.hasNext()){
            String element=iterator.next();
            System.out.println(element);
        }
    }

num1
num2
num3
num4

7.Stack集合

Stack是栈结构的集合，因此具有数据结构中栈的一般特性（后进先出）

   public static void main(String[] args) {
        Stack<String> stack=new Stack<>();
        stack.add("num1");
        stack.add("num2");
        stack.add("num3");
        System.out.println("stack的第二个元素"+stack.get(1));
        System.out.println("压栈操作："+stack.push("num4"));
        for (String s : stack) {
            System.out.println(s);
        }
        System.out.println("出栈操作："+stack.pop());
        System.out.println(stack);
    }

stack的第二个元素num2
压栈操作：num4
num1
num2
num3
num4
出栈操作：num4
[num1, num2, num3]