Java入门(十一)

集合类

为了方便对多个对象进行操作，我们就必须把多个对象进行存储，但是存储多个对象就不能是基本的变量了，应该是一个容器类型的变量。学过的StringBuilder，他的结果是一个字符串，不一定满足需求，而数组的长度固定，不能适应变化的需求，这种情况下，Java提供了集合类供我们使用，集合类的长度是可变的

 

Collection接口类

是单列集合中的顶层接口，JDK不提供此接口的任何直接实现，它提供更具体的子接口实现

创建Collection集合的对象，我们采用的是多态的方式，使用的是具体的ArrayList类，这是最常用的集合类

使用示例：

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

public class InterfaceDemo {
    public static void main(String[] args){
        Collection<String> c = new ArrayList<String>();
        c.add("hello");
        c.add("world");
        System.out.print(c);
    }
}

成员方法

public class InterfaceDemo {
    public static void main(String[] args){
        Collection<String> c = new ArrayList<String>();
        c.add("hello");
        c.add("world");
        c.add("2020");
        c.remove("2020");
        System.out.println(c.contains("world"));
        System.out.println(c.contains("2020"));
        System.out.println(c.isEmpty());
        System.out.println(c.size());
        c.clear();
        System.out.println(c.isEmpty());
    }
}

Collection集合遍历

⚠️  重点是通过集合对象创建迭代器对象，和迭代器对象 hasNext(), next() 方法的使用

public class InterfaceDemo {
    public static void main(String[] args){
        Collection<String> c = new ArrayList<String>();
        c.add("hello");
        c.add("world");
        c.add("2020");
        //通过集合对象调用iterator()方法得到迭代器对象
        Iterator<String> it = c.iterator();//返回的是迭代器接口的实现类对象
        while(it.hasNext()){
            String s = it.next();
            System.out.println(s);
        }
    }
}

存储自定义对象并遍历

public static void main(String[] args){
        //创建集合对象
        Collection<Animal> a = new ArrayList<Animal>();
        //创建元素对象
        Animal s0 = new Animal("TIM",1);
        Animal s1 = new Animal("TOM",2);
        Animal s2 = new Animal("JOY",3);
        //把元素添加到集合
        a.add(s0);
        a.add(s1);
        a.add(s2);
        //遍历集合
        Iterator<Animal> it = a.iterator();
        while(it.hasNext()){
            Animal ani = it.next();
            System.out.println(ani.getAge()+" "+ani.getName());
        }
    }

List集合

有序的 Collection ，用户可以根据元素的整数索引访问元素，和set不同，列表允许重复元素

List<String> list = new ArrayList<String>();

 

list集合成员方法

list.add(1,"java") 在索引为1的位置插入 “java”，原本在该位置的元素以及后面的所有元素统一向后移动，⚠️  添加元素的时候不可以索引越界

public static void main(String[] args){
        List<String> l = new ArrayList<String>();
        l.add("hello");
        l.add("world");
        l.add("2020");
        l.add(1,"java");
        l.remove(0);
        System.out.println(l);
        System.out.println(l.get(0));
        l.add("2020");
        System.out.println(l);
        System.out.println(l.set(1, "TIM"));
        System.out.println(l);
    }

ListIterator列表迭代器

特点可以逆向遍历，⚠️  但是要求先正向遍历才能逆向遍历，所以没有意义，一般不用

 

集合中并发修改异常的原因以及解决方案

产生的原因：迭代器依赖集合而存在，在判断成功后，集合中添加了新的元素，而迭代器不知道，所以报错了，其实这个问题说的是，迭代器遍历集合中的元素的时候，不要使用集合对象去修改集合中的元素

解决方案：

1. 迭代器遍历(使用ListIterator, 因为他有add方法)的时候，可以通过迭代器修改集合中的元素，元素是跟在刚才迭代的元素后面
2. 集合遍历的时候，可以通过集合对象修改集合中的元素，元素是加在最后面的

⚠️  错误代码：

public static void main(String[] args){
        List<String> list = new ArrayList<String>();
        Iterator<String> it = list.iterator();
        while(it.hasNext()){
            String s = it.next();
            if(s.equals("Tim")){
                list.add("TOM");
            }
        }
    }

正确代码：

public static void main(String[] args){
        List<String> list = new ArrayList<String>();
        ListIterator<String> lit = list.ListIterator();
        while(it.hasNext()){
            String s = lit.next();
            if(s.equals("Tim")){
                lit.add("TOM");
            }
        }
    }

public static void main(String[] args){
        List<String> list = new ArrayList<String>();
        Iterator<String> it = list.iterator();
        for(int x = 0; x < list.size(); x++){
            String s = list.get(x);
            if(s.equals("TIM")){
                list.add("TOM");
            }
        }
    }

增强For

是for循环的一种，其实是用来替代迭代器的，格式：

for(元素数据类型变量名: 数组名或者Collection集合对象名){}

int[] arr = {1, 2, 3};
for(int x: arr){
    System.out.println(x);
}

⚠️  增强for目标不能为null，在判断前要进行判断

List类

ArrayList: 底层数据结构是数组，查询快，增删慢

LinkedList: 底层数据结构是链表，查询慢，增删快

三种方法遍历ArrayList：

public static void main(String[] args){
        ArrayList<String> list = new ArrayList<String>();
        list.add("TIM");
        list.add("Loves");
        list.add("Money");
        for(String x: list){
            System.out.println(x);
        }
        Iterator<String> it = list.iterator();
        while(it.hasNext()){
            String s = it.next();
            System.out.println(s);
        }
        for(int x = 0; x < list.size(); x++){
            System.out.println(list.get(x));
        }
    }