java基础-集合进阶

单列集合：一次只能添加一对数据

双列集合：一次可以添加多对数据

红色表示接口，蓝色表示实现类

Collection类的一些方法：

注意：Collection是顶层类，向下可以分为List和Set两种

复制代码

package com.jdL.day22classwork;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;

public class CollectionTest1 {
    public static void main(String[] args) {
        //Collection是一个接口,我们不能直接创建对象
        //只能创建接口实现类的对象
        //实现类：ArrayList
        Collection<String> co=new ArrayList<>();

        //添加元素
        //返回值为boolean类
        //细节：如果往list集合中添加数据，方法永远返回true,因为list系列集合是支持重复的
        //如果往set集合中添加数据，如果当前添加的数据不存在，方法返回true,如果添加的数据存在了，方法返回false(set系统不允许重复)
        //添加元素add方法
        co.add("aaaa");
        co.add("bbbb");
        co.add("cccc");
        System.out.println(co);
        //清空数据clear方法,执行之后就会清空集合
        //co.clear();
        //System.out.println(co);
        //remove删除
        //注意：因为collection里面定义的是共性的方法，所以这里没有办法按照索引来删
        //remove返回值也是boolean类型的，删除成功返回true,删除失败返回false
        //如果要删除的元素不存在，就会删除失败
        co.remove("cccc");
        System.out.println(co);
        //cotains:判断元素是否包含
        //底层给是依赖equale判断的，
        //返回值也是返回一个布尔类型的值，如果查询的值包含在集合里面，就返回true,如果不包含就返回false
        //注意：如果集合中是自定义的类对象，比如student,teache这些，也想通过contains来判断是否包含，
        //在student,teache这些类中一定要重新equals方法
        boolean result = co.contains("aaaa");
        System.out.println(result);
        //isEmpty,判断集合是否为空，空集合返回true
        boolean empty = co.isEmpty();
        System.out.println(empty);
        //size,返回集合的长度
        int size = co.size();
        System.out.println(size);
    }
}

Collection的遍历方式：

1、迭代器遍历：迭代器遍历是不依赖索引的

迭代器在java中的类是Iterator,是集合专用的遍历方式

迭代器遍历完指针不会复位，如果想要再次遍历集合，就需要重新获取一个迭代器的对象

复制代码

package com.jdL.day22classwork;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class CollectionTest2 {
    public static void main(String[] args) {
        //创建集合对象，并添加元素
        Collection<String> co=new ArrayList<>();
        co.add("a");
        co.add("b");
        co.add("c");
        co.add("d");
        //创建集合的迭代器对象，默认执行0索引处
        Iterator<String> it=co.iterator();
        //hasNext()判断当前指针指向的集合元素是否为空，如果空的就跳出循环了
        while (it.hasNext()){
            //如果非空，next()获取元素并打印
            String next = it.next();
            System.out.print(next);
        }
        //当上面的循环结束后，指针就是指向没有元素的位置
        //System.out.println(it.next());
      
    }
}

2、增强for遍历：

复制代码

package com.jdL.day22classwork;

import java.util.ArrayList;
import java.util.Collection;

public class CollectionTest3 {
    public static void main(String[] args) {
        //创建集合，并添加对象
        Collection<String> co=new ArrayList<>();
        co.add("a");
        co.add("b");
        co.add("c");
        co.add("d");
        //增强for遍历
        //注意点：s就是一个第三方变量，在遍历过程中会依次表示集合中的每一个元素,不会改变集合中的元素
        //快捷键：集合名称.for
        //细节：
        for(String s:co){
            s="eee";
        }
        System.out.print(co);
    }
}

3、

复制代码

package com.jdL.day22classwork;

import java.util.ArrayList;
import java.util.Collection;
import java.util.function.Consumer;

public class CollectionTest4 {
    public static void main(String[] args) {
        //lamdba表达式
        Collection<String> co=new ArrayList<>();
        co.add("a");
        co.add("b");
        co.add("c");
        co.add("d");
        //匿名内部类
//        co.forEach(new Consumer<String>() {
//            @Override
//            //s依次表示集合中的每个元素
//            public void accept(String s) {
//                System.out.println(s);
//            }
//        });
        //lamdba表达式
        co.forEach(s->System.out.println(s));
    }
}

List集合：

特点：有序：存和取的顺序是一致的

有索引：可以通过索引操作元素

可重复：存储的元素可以重复

复制代码

package com.jdL.day22classwork;

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

public class ListTest1 {
    public static void main(String[] args) {
        //创建一个集合
        List<String> list = new ArrayList<>();
        //添加元素
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        //打印集合
        System.out.println(list);
        //add(int index,e element):在指定的索引处添加元素，添加之后原索引处的元素依次向后移动
        list.add(2,"哈");
        System.out.println(list);
        System.out.println("-----------------");
        //remove(int index):删除指定索引删除元素，返回被删除的元素,删除后，原索引之后的元素依次想前移动
        String remove = list.remove(2);
        System.out.println(remove);
        System.out.println(list);
        
    }
}

remove这个方法需要注意一下：

复制代码

package com.jdL.day22classwork;

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

public class ListTest2 {
    public static void main(String[] args) {
        //
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        //
        list.remove(1);
        //这里是表示删除1的值还是删除1索引处的值呢？
        //答案是：索引1，因为在调用方法的时候，如果方法出现了重载，优先调用，实参和形参类型一致的那个方法
        //如果非要删除1值的数据，可以利用索引，也可以手动装箱,如下：
        Integer i=Integer.valueOf(1);
        list.remove(i);
    }
}

List独有的遍历方式

复制代码

package com.jdL.day22classwork;

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

public class ListTest3 {
    public static void main(String[] args) {
        //创建集合
        List<String> list = new ArrayList<String>();
        //添加对象
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        //1、迭代器遍历
        Iterator<String> iterator = list.iterator();
        while(iterator.hasNext()){
            String next = iterator.next();
            System.out.print(next);
        }
        //2、增强for
        for(String s:list){
            System.out.print(s);
        }
        //3、lamdba表达式
        list.forEach(s->System.out.println(s));
        //4、普通的for循环
        for(int i=0;i<list.size();i++){
            System.out.print(list.get(i));
        }
        System.out.println("------------------");
        //5、列表迭代器
        //获取了一个列表迭代器的对象，里面的指针也是默认指向0索引
        //额外添加了一个方法：在遍历过程中，可以添加元素
        ListIterator<String> st = list.listIterator();
        while(st.hasNext()){
            String next = st.next();
            //当遇到a的时候，就在a的后面添加一个字符
            if(next.equals("a")){
                //不能用集合的add,只能用迭代器本身的方法
                st.add("我");
            }
        }
        System.out.println(list);
    }
}