集合的使用

集合的使用,第1张

集合的使用

ArrayList

package 集合;

import java.util.List;
import java.util.ArrayList;

public class ArrayListTest {
    public static void main(String[] args) {
        //实例化ArrayList容器
        List 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));
        }
        
        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 a = new ArrayList<>();
        a.add("a");
        a.add("b");
        a.add("c");

        List 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 a1 = new ArrayList<>();
        a1.add("a");
        a1.add("b");
        a1.add("c");

        List 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 a2 = new ArrayList<>();
        a2.add("a");
        a2.add("b");
        a2.add("c");

        List 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 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 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;


public class StackTest {
    public static void main(String[] args) {
        //实例化栈容器
        Stack 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 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()){
            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 map=new HashMap<>();

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


        }
        Set> entrySet = map.entrySet();
        Iterator> it2 = entrySet.iterator();
        while (it2.hasNext()){
//            Map.Entry 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 map=new HashMap<>();

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

        System.out.println(map);
        

        //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取出放入数组中
    }
}

欢迎分享,转载请注明来源:内存溢出

原文地址: http://outofmemory.cn/zaji/5708243.html

(0)
打赏 微信扫一扫 微信扫一扫 支付宝扫一扫 支付宝扫一扫
上一篇 2022-12-17
下一篇 2022-12-17

发表评论

登录后才能评论

评论列表(0条)