集合的使用

ArrayList

package 集合;

import java.util.List;
import java.util.ArrayList;
/*底层是数组查询快*/
public class ArrayListTest {
    public static void main(String[] args) {
        //实例化ArrayList容器
        List<String> list = new ArrayList();
        //添加
        boolean xp = list.add("xp");
        System.out.println(xp);
        list.add("wangli");
        list.add("xp");
        //索引的数组不能大于元素的个数
        list.add(0,"oldlu");
        //通过指定索引位置获取元素
        System.out.println(list.get(0));
        System.out.println("------------------");
        //通过循环获取集合中所有元素
        //size（）返回集合中所有个数
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
        /**
         * list.set( 0(索引位置)，"替换的数 aaa")
         * list.clear()清空集合的所有元素
         */
        System.out.println("------------------");
        //判断是否为空  空是true 不空是false
        boolean empty = list.isEmpty();
        System.out.println(empty);
        System.out.println("------------------");
        //如果容器中有则返回true没有false
        boolean xp1 = list.contains("xp");
        System.out.println(xp1);

        System.out.println("----------查找元素在容器中的位置（索引）--------");
        //indexOf返回元素第一次出现的位置，如果元素不存在则返回-1
        int ii = list.indexOf("xp");
        System.out.println(ii);

        System.out.println("----------元素在容器中最后一次的位置--------");
        //lastIndexOf返回元素最后一次出现的位置，如果元素不存在则返回-1
        int i1 = list.lastIndexOf("xp");
        System.out.println(i1);

        System.out.println("---------遍历容器--------------");
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
        System.out.println("---------将单利集合转为数组--------------");
        //将list转Object[]
        //但是不能将转换的数组做强制类型转换
        Object[] arr = list.toArray();
        for (int i = 0; i < arr.length; i++) {
            String str = (String) arr[i];
            System.out.println(str);
        }

        System.out.println("---------将单利集合转为指定类型--------------");
        //可以将单例集合转换为指定类型数组。
        //但是类型需要参考泛型中的类型
        String[] arr2 = list.toArray(new String[list.size()/*长度*/]);
        for (int i = 0; i < arr2.length; i++) {
            System.out.println(arr2[i]);
        }

        System.out.println("----容器的并集操作------");
        List<Object> a = new ArrayList<>();
        a.add("a");
        a.add("b");
        a.add("c");

        List<Object> b = new ArrayList<>();
        b.add("b");
        b.add("c");
        b.add("d");
        //a并b
        boolean bb = a.addAll(b);
        System.out.println(bb);
        for (Object o : a) {
            System.out.println(o);
        }

        System.out.println("----容器的交集操作------");
        List<Object> a1 = new ArrayList<>();
        a1.add("a");
        a1.add("b");
        a1.add("c");

        List<Object> b1 = new ArrayList<>();
        b1.add("b");
        b1.add("c");
        b1.add("d");
        boolean bb1 = a1.retainAll(b1);
        System.out.println(bb1);
        for (Object o : a1) {
            System.out.println(o);
        }

        System.out.println("----容器的差集操作------");
        List<Object> a2 = new ArrayList<>();
        a2.add("a");
        a2.add("b");
        a2.add("c");

        List<Object> b2 = new ArrayList<>();
        b2.add("b");
        b2.add("c");
        b2.add("d");
        boolean b3 = a2.removeAll(b2);
        System.out.println(b3);
        for (Object o : a2) {
            System.out.println(o);
        }



    }
}

LinkedList

package 集合;

import java.util.LinkedList;

public class LinkedListTest {
    public static void main(String[] args) {
        LinkedList<Object> list = new LinkedList<>();
        list.addFirst("a");//从后往前
        list.addFirst("b");
        list.addFirst("c");
        list.addFirst("d");
        //获取元素
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
        System.out.println("------------");
        LinkedList<Object> list1 = new LinkedList<>();
        list1.addLast("a");//从前往前
        list1.addLast("b");
        list1.addLast("c");
        list1.addLast("d");
        //获取元素
        for (Object str: list1) {
            System.out.println(str);
        }
        System.out.println("--------------------");
        System.out.println(list.getFirst());//从后取
        System.out.println(list.getLast());//从前取
        System.out.println("--------------------");
        list1.removeFirst();//删除头
        list1.removeLast();//删除尾
        for (Object str: list1) {
            System.out.println(str);
        }
        System.out.println("--------------------");
        System.out.println(list.isEmpty());//为空ture 不为空false
    }
}

Vector

package 集合;

import java.util.Stack;

/**
 * Vector的子类
 */
public class StackTest {
    public static void main(String[] args) {
        //实例化栈容器
        Stack<String> stack = new Stack<>();
        //添加
        stack.push("a");
        stack.push("b");
        stack.push("c");

        System.out.println(stack.empty());//判断栈容器是否为空

        System.out.println(stack.peek());//查看栈顶元素
        //查看位置 栈查看位置是从1开始从上往下取
        System.out.println(stack.search("a"));
        //获取元素   先进后出这样获取
        String p1 = stack.pop();
        System.out.println(p1);
        String p2 = stack.pop();
        System.out.println(p2);
        String p3 = stack.pop();
        System.out.println(p3);
        System.out.println("---------------------------------");
        StackTest stackTest = new StackTest();
        stackTest.symmetry();

    }
    //匹配符号的对称性
    public void symmetry(){
        String str = "...{.....[....(....)...]....}..(....)..[...]...";
        //实例化stack
        Stack<String> stack = new Stack<>();
         //假设修正法
        boolean flag = true;//假设是匹配的
        //拆分字符串获取字符
        for (int i = 0; i < str.length(); i++) {
            char c = str.charAt(i);
            if (c == '{'){
                stack.push("}");
            }
            if (c == '['){
                stack.push("]");
            }
            if (c == '('){
                stack.push(")");
            }
            //判断符号是否匹配
            if (c =='}' || c==']' || c ==')'){
                if (stack.empty()){
                    flag = false;
                    break;
                }
                String x = stack.pop();
                if (x.charAt(0) !=c){
                    flag = false;
                    break;
                }
            }
        }
        if (!/*取反*/stack.empty()/*true*/){
            flag = false;
        }
        System.out.println(flag);
    }
}

Map

package cn.tedu.collection;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

//本类用于测试Map的迭代
public class TestMap {
    public static void main(String[] args) {
        //1.创建Map相关对象
        Map<Integer,String> map=new HashMap<>();

        //2.向集合中存入数据
        map.put(9527,"白骨精");
        map.put(9528,"黄毛怪");
        map.put(9529,"狮子精");
        map.put(9530,"金角大王");
        System.out.println(map);
        //3.对map集合进行迭代
        //前提：map本身没有迭代器，所以需要转换成其他集合进行迭代
        /*方案一：Set（key） kaySet（）将map中的所有key值取出存入set集合
        * 方案二：Set <Map.Entry<k,v> entrySet()>
        把Map中的一对key&value取出，形成一个Entry<k,v>
        * 将entry作为一个个独立的元素存入Set中*/
        //1.将map中的所有key值取出存入Set中，set集合的泛型就是key的类型
        Set<Integer> keySet = map.keySet();
        //2.要想遍历集合，首先创建集合的迭代器
        Iterator<Integer> it = keySet.iterator();
        //3.循环遍历集合中的每一个元素
        while(it.hasNext()){
            Integer key= it.next();
            String value =map.get(key);
            System.out.println("["+key+"="+value+"]");


        }
        Set<Map.Entry<Integer, String>> entrySet = map.entrySet();
        Iterator<Map.Entry<Integer, String>> it2 = entrySet.iterator();
        while (it2.hasNext()){
//            Map.Entry<Integer, String> entry = it2.next();
//            Integer key = entry.getKey();
//            String value = entry.getValue();
//            System.out.println("["+key+"="+value+"]");
            System.out.println("["+it2.next()+"]");

        }
    }
}

package cn.tedu.collection;

import java.util.HashMap;
import java.util.Map;

//本类用于测试Map的接口
public class TestMap {
    public static void main(String[] args) {
        //1.创建map对象
        /*Map中的数据要符合映射规则，一定要注意同时指定k和v的数据类型
        * 至于k和v要指定成什么类型，取决于业务*/
        Map<Integer,String> map=new HashMap<>();

        //2.常用方法测试
        map.put(9527,"白骨精");
        map.put(9528,"玉兔精");
        map.put(9529,"鲤鱼精");

        System.out.println(map);
        /*1.map中存放的数据都是无序的
        * 2.map中的key值不可以重复，如果重复，此key值对应value会被覆盖
        * 打印结果：{9527=白骨精, 9528=玉兔精, 9529=鲤鱼精}，me没有9527=黑熊精*/

        //3.测试常用方法
//        map.clear();
//        System.out.println(map);
        System.out.println(map.containsKey(9527));//true,判断map是否包含指定的key
        System.out.println(map.containsValue("沙师弟"));//false，判断map是否包含指定的value
        System.out.println(map.get(9529));//鲤鱼精 根据key取出对应的value
        System.out.println(map.remove(9528));//玉兔精 删除指定元素，k-v均删除
        System.out.println(map.get(9528));//null
        System.out.println(map.containsKey(9528));//false
        System.out.println(map.size());//2 ,获取map中键值对的个数
        System.out.println(map.hashCode());//70221251
        System.out.println(map.equals("黑熊精"));//false
        System.out.println(map.values());//[白骨精, 鲤鱼精]    把map中的所有value取出放入数组中
    }
}