标签：map set 15 List list System add println out

1.List接口

List接口继承与collection接口，实现类为ArrayList和LinkedList

List接口特点

1. List集合有下标
2. List集合是有序的
3. List集合可以存重复的元素

List接口常用方法

/**本类用于List接口练习*/
public class TestList {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("大力娃");//向list集合中存入数据
        list.add("千顺娃");
        list.add("头铁娃");
        list.add("喷火娃");
        list.add("喷水娃");
        list.add("隐身娃");
        list.add("小紫娃");
        System.out.println(list.contains("喷火娃"));
        System.out.println(list.equals("喷水娃"));
        System.out.println(list.isEmpty());
        System.out.println(list.remove("小蝴蝶"));
        System.out.println(list.size());
        System.out.println(Arrays.toString(list.toArray()));//集合转数组，并打印

        list.add("小蝴蝶");
        System.out.println(list);
        list.add(1,"蛇精");//指定索引处添加元素
        list.add(3,"小蝴蝶");
        System.out.println(list);

        System.out.println(list.indexOf("小蝴蝶"));
        System.out.println(list.lastIndexOf("小蝴蝶"));

        System.out.println(list.remove(2));//根据索引删除集合中的元素,并将删除的元素返回
        System.out.println(list.get(8));//获取指定下标处的元素
        System.out.println(list);
        System.out.println(list.set(5,"蝎子精"));//修改集合中指定索引处的值
        System.out.println(list);

        List<String> list2 = new ArrayList<>();
        list2.add("1");
        list2.add("2");
        list2.add("3");
        list2.add("4");
        System.out.println(list2);
        System.out.println(list.addAll(list2));//将list2中的所有元素追加到list集合的末尾
        System.out.println(list);
        System.out.println(list.addAll(1,list2));//在list集合的指定索引处，添加list2集合的所有元素
    }
}

List接口的四种迭代方式

/**本类用于进一步测试list接口*/
public class TestList2 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("喜羊羊");
        list.add("美羊羊");
        list.add("懒羊羊");
        list.add("沸羊羊");
        list.add("小肥羊");
        list.add("肥羊卷");
        System.out.println(list);

        /*集合的迭代方式：
        1.for循环
        2.foreach 高效for循环
        3.iterator
        * */
        /*方式一迭代：因为list集合是有序的，元素是有下标值的*/
        System.out.println("方式一 ：：*************************************");
        for(int i=0; i<list.size(); i++){
            System.out.println(list.get(i));
        }
        /*方式二迭代：
        * 格式： for(本轮遍历得到的元素的类型  元素名： 要遍历的元素) { 循环体 }*/
        System.out.println("方式二 ：：**************************************");
        for(String s : list){
            System.out.println(s);
        }
        /*方式三迭代：iterator*/
        System.out.println("方式三 ：：*************************************** ");
        Iterator<String> it = list.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }
        /*方式四迭代：listIterator 属于list接口特有的迭代器
        * iterator<E> 父接口 hasNext() next()
        * ListIterator<E> 子接口--除了从父接口处继承的功能以外
          还有自己特有的功能，比如逆序遍历 添加元素等等， 但是不常用
          public interface ListIterator<E extends Iterator<E>
          * */
        System.out.println("方式四 ：：*************************************** ");
        //获取迭代器对象
        ListIterator<String> it2 = list.listIterator();
        while(it2.hasNext()){
            System.out.println(it2.nextIndex());
        }
        System.out.println("方式五，逆序迭代 ：：*************************************** ");
        ListIterator<String> it3 = list.listIterator();
        while(it3.hasNext()){//判断后面是否有元素可以迭代
            System.out.println(it3.next());//打印获取到的后面的元素
            if(!it3.hasNext()){//直到迭代器没有下一个元素可以迭代了
                System.out.println("开始逆序遍历");
                while(it3.hasPrevious()){//判断前面是否有元素可以迭代
                    System.out.println(it3.previous());//打印获取到的前面的元素
                }
                break; //终止循环，不然会一直从头到尾，再从头到尾遍历
            }
        }
    }
}

2.List集合的两个常用实现类

2.1 ArrayList

1. List接口的实现类
2. 底层的数据结构是数组，内存空间是连续的
3. 元素有下标，有序，允许存放重复的操作
4. 通常可以根据下标进行操作
5. 增删操作比较慢，查询操作比较快【数据量大时】
6. 内部数组默认的初始容量是10,如果不够会以1.5倍的容量增长

/**本类用于测试ArrayList实现类*/
public class TestArrayList {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        list.add(100);
        list.add(200);
        list.add(300);
        list.add(400);
        list.add(400);
        list.add(300);
        System.out.println(list);

//        list.clear();
        System.out.println(list.contains("100"));//false，因为这个100是字符串
        System.out.println(list.get(1));//200,打印下标为1的元素
        System.out.println(list.indexOf(400));//3,指定元素第一次出现的下标
        System.out.println(list.lastIndexOf(400));//4，指定元素最后一次出现的下标
        System.out.println(list.remove(0));//根据下标删除元素
        /*集合中传入的数据是引用类型，不是基本类型
        * 所以如果想根据元素删除数据，需要把int类型参数300转为集合中元素的类型Integer*/
        System.out.println(list.remove(Integer.valueOf(300)));//删除int类型的300
        System.out.println(list);
        System.out.println(list.contains(200));
    }
}

2.2 LinkedList实现类

1. List接口的实现类
2. 底层的数据结构是链表，内存空间是不连续的
3. 元素有下标，有序，允许存放重复的数据
4. 但是通常首尾节点的操作比较多
5. 增删操作比较快，查询操作比较慢【数据量大时】
6. LinkedList查询,首尾操作还是比较快的

/**本类用于测试LinkedList方法的使用*/
public class TestLinkedList {
    public static void main(String[] args) {
        LinkedList<String> list = new LinkedList<>();
        list.add("孙悟空");
        list.add("猪八戒");
        list.add("沙师弟");
        list.add("唐三藏");
        list.add("白龙马");
        System.out.println(list);
        list.addFirst("蜘蛛精");
        list.addLast("玉兔精");
        System.out.println(list);
        System.out.println(list.getFirst()); //获取首元素
        System.out.println(list.getLast()); //获取尾元素

        System.out.println(list.removeFirst());//删除首节点
        System.out.println(list.removeLast());//删除尾结点
        System.out.println(list);

        LinkedList<String> list2 = new LinkedList<>();
        list2.add("西游记");
        list2.add("红楼梦");
        list2.add("水许传");
        list2.add("三国演义");
        System.out.println(list2);
        System.out.println(list2.element());//获取集合中的首元素

        /*别名：查询系列*/
        System.out.println(list2.peek());//获取集合中的首元素
        System.out.println(list2.peekFirst());//获取集合中的首元素
        System.out.println(list2.peekLast());//获取集合中的尾元素

        /*别名：新增系列*/
        System.out.println(list2.offer("斗罗大陆"));//添加尾元素
        System.out.println(list2.offerFirst("盗墓笔记"));//添加首元素
        System.out.println(list2.offerLast("钢铁是怎样练成的"));//添加尾元素
        System.out.println(list2);

        /*别名：移除系列*/
        System.out.println(list2.poll());//移除首元素
        System.out.println(list2.pollFirst());//移除首元素
        System.out.println(list2.pollLast());//移除尾元素
        System.out.println(list2);

        /*以上都是对首位节点做操作*/
    }
}

3.Map接口

1. map集合的结构是：键值对、KEY与VALUE、Map.Entry<K,V>的映射关系
2. map中key值不允许重复，如果重复，对应的value会被覆盖
3. map中的映射关系是无序的
4. map没有自己的迭代器，所以迭代时通常需要转成set集合来迭代

/**本类用于测试map接口*/
public class TestMap {
    public static void main(String[] args) {
        Map<Integer,String> map = new HashMap<>();
//        Map<String,Integer> map2 = new HashMap<>();
//        map2.put("白骨精",1);
        map.put(9527,"白骨精");
        map.put(9528,"黑熊精");
        map.put(9529,"鲤鱼精");
        map.put(9530,"黄毛怪");
        map.put(9531,"黑熊精");
        map.put(9527,"女儿国国王");
        System.out.println(map);
        /*1.map中存放的都是无序的数据
        * 2.map中的value可以重复，比如放入了两个“黑熊精 ”
        * 3.map中的key不可以重复，如果重复，新的value会把旧的value重复掉*/

//        map.clear();
//        System.out.println(map);
        System.out.println(map.hashCode());//获取集合对象的哈希值
        System.out.println(map.equals("黄毛怪"));//集合对象与集合中的元素对比
        System.out.println(map.isEmpty());//false,判断集合是否为空
        System.out.println(map.size());//5,集合的长度

        System.out.println(map.containsKey(9527));//判断集合中是否包含指定的Key(键)
        System.out.println(map.containsValue("黑熊精"));//判断集合中是否包含指定的value(值)
        System.out.println(map);
        System.out.println(map.get(9527));//根据key获取集合中对应的value
        System.out.println(map.remove(9529));//删除指定的键值对
        System.out.println(map.containsValue("鲤鱼精"));//false
        System.out.println(map.containsKey(9529));//false
        /*将map集合中的所有value去除，存入到一个Collection集合中*/
        Collection<String> values = map.values();
        System.out.println(values);
        /*将map集合中的所有key去除，存入到一个Collection集合中*/
//        Collection<Integer> keys = map.keySet();
//        System.out.println(keys);

        //map集合的迭代方式一
        /*方式一：
        想要迭代map中的数据，但是map本身没有迭代器，所以需要先转换成set集合
        Set<KEY>：把map中所有的KEY值存入到Set集合中，用到的方法：keySet()
        */
        Set<Integer> key = map.keySet();
        System.out.println(key);
        Iterator<Integer> it = key.iterator();
        while(it.hasNext()){
            Integer next = it.next();
            String value = map.get(next);
            System.out.println("{"+next+"="+value+"}");
        }
        //map集合的迭代方式二
        /*想要迭代map集合，需要把map集合先转换成set集合
        * 这次是把map中的每一对键值对都看作是一个Entry<K,V>
        一对Key&value就是一对Entry<K,V>*/
        System.out.println("第二种方法*************************");
        Set<Map.Entry<Integer, String>> set = map.entrySet();
        Iterator<Map.Entry<Integer, String>> it2 = set.iterator();
        while(it2.hasNext()){
            Map.Entry<Integer, String> entry = it2.next();
            Integer key1 = entry.getKey();
            String val = entry.getValue();
            System.out.println("{"+key1+"="+val+"}");
        }
    }
}

标签：map,set,15,List,list,System,add,println,out
来源： https://blog.csdn.net/weixin_58828748/article/details/120404073

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。