【JAVA CORE_API】Day14 Collection、Iterator、增强for、泛型、List、Set

Collection接口及常用方法

• Collection<Object> collection = new ArrayList();：实例化ArrayList集合对象；

• collectionName.add(Object obj);：在集合中增加元素；

• int sizeName = collectionName.size();：获取集合的长度；

• collectionName.clear();：清空集合；

• boolean isEmptyName = collectionName.isEmpty();：检查集合是否为空；

• collectionName.remove(Object obj);：清除集合中符合参数的值；

• boolean containsName = new contains();：判断集合元素中是否有符合参数的值（子字符串匹配）；

• collectionName1.addAll(collectionName2);：取两个集合的并集给前面的集合；

• collectionName1.retainAll(collectionName2);：取两个集合的交集给前面的集合；

• collectionName1.removeAll(collectionName2);：删除交集元素后赋给前面的集合；

• boolean containsAllName = containsName1.containAll(containsName2);：检查当前集合是否包含所有参数集合的元素；

Iterator遍历迭代器接口

• Iterator<Object> iteratorName = collectionName.Iterator();：为Collection创建迭代器；

• iteratorName.hasNext();：判断集合是否还有元素可以遍历；

• <E> nextName = iterationName.next();：返回迭代的下一个泛型指定的元素；

• iterationName.remove();：删除当前元素，一般结合next()方法使用；

增强for循环

• 只用于遍历集合或数组，语法如下：

for (元素类型<E> : 集合或数组) {
    循环体
}

• 例如：

ArrayList<String> list = new ArrayList<>();
list.add(...);
...
  
for (String e : list) {    // 增强型for循环可以使用泛型指定类型接收元素
    System.out.println(e);
}

泛型在集合中的应用

• ArrayList类的定义中，<E>中的E为泛型参数，在创建对象时可以将类型作为参数传递，此时，类定义所有的E将被替换成传入的参数；

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

public class GenericExample {
    public static void main(String[] args) {
        // 使用泛型创建一个只包含字符串的List
        List<String> stringList = new ArrayList<>();

        // 向List中添加元素
        stringList.add("Hello");
        stringList.add("World");

        // 取出元素时不需要进行类型转换，类型安全
        for (String s : stringList) {
            System.out.println(s);
        }

        // 尝试添加其他类型的数据会在编译时报错
        // stringList.add(123); // 编译错误：不兼容的类型

        // 使用泛型创建一个只包含整数的List
        List<Integer> intList = new ArrayList<>();
        intList.add(1);
        intList.add(2);
        intList.add(3);

        // 使用泛型方法进行求和操作
        int sum = sumOfList(intList);
        System.out.println("Sum of integers: " + sum);
    }

    // 使用泛型方法来计算List中所有元素的和
    public static <T extends Number> int sumOfList(List<T> list) {
        int sum = 0;
        for (T number : list) {
            sum += number.intValue(); // 使用Number类的方法来处理泛型
        }
        return sum;
    }
}

List集合

• 层级关系：Collection（集合接口，无序） → List（子接口，有序）→ ArrayList、LinkedList（List的实现类）；

• ArrayList和LinkedList（链表）的方法在逻辑上完全相同，ArrayList更适合随机访问，LinkedList更适合插入和删除数据或业务中只在两端进行操作数据，只在性能上有差别。

get和set

• listName.get(int index);：获取index对应的下标的元素，下标由0开始；

• listName.set(int index, <E> element);：将elment值放在下标为index的位置；

public void testGetAndSet() {
    List<String> list = new ArrayList<String>();
    list.add("java");
    list.add("php");
    list.add("c#");
    list.add("cpp");
    list.add("objective-c");
    
    // get方法遍历List
    for (int i = 0; i < list.size(); i++) {
        System.out.println(list.get(i).toUpperCase());
    }
  
    String value = list.set(1, "c++");
    System.out.println(value);    // cpp
    System.out.println(list);    // [java, c++, php, c#, objective-c]
    list.set(1, list.set(3, list.get(1)));    // 交换位置1和3的元素
    System.out.println(list);    // [java, c#, php, c++, objective-c]
}

• listName.add(<E> element);：插入数据elment；

  • listName.add(int index, <E> element);：将数据element插入在index位置；

• listName.remove(int index);：删除下表为index的元素；

subList()：获取子集方法

• List<E> subListName = listName.subList(int start, int end);：获得下标为start到end的子集（含头不含尾）；

  • listName.subList(int start, int end).clear();：删除连续元素；

集合与数组的转换

• String[] arrayName = collectionName.toArray(new String[collectionName.size()]);：将集合转换为数组。

package day14;

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

public class CollectionToArray {
    public static void main(String[] args) {
        Collection<String> c = new ArrayList<>();
        c.add("one");
        c.add("two");
        c.add("three");
        c.add("four");
        c.add("five");
        System.out.println(c);      // [one, two, three, four, five]

        /**
         * 1) 若参数数组元素个数==集合元素个数，那就正常转换
         * 2) 若参数数组元素个数>集合元素个数，那也正常转换（按照集合大小给数组）
         * 3) 若参数数组元素个数<集合元素个数，那也正常转换，同时在末尾补默认值
         */
        String[] array = c.toArray(new String[5]);
        System.out.println(Arrays.toString(array));  // [one, two, three, four, five]
    }
}

• List<E> listName = Arrays.asList(arrayName);：将数组转换为集合，注意：数组只能转为有序数组，是因为数组是有序的，而且不支持增删，因为数组是定长的。

package day14;

import java.util.Arrays;
import java.util.List;

/**
 * 数组转集合
 */
public class ArrayToList {
    public static void main(String[] args) {
        String[] array = {"one","two","three","four","five"};
        System.out.println("array:" + Arrays.toString(array));  // [one, two, three, four, five]

        // asList() 方法将数组转换为集合，会返回内部的ArrayList对象，内部直接引用了数组Array
        List<String> list = Arrays.asList(array);
        System.out.println("list:" + list);  // [one, two, three, four, five]

        // 修改数组中元素数据后，集合也会相应的改变
        array[1] = "six";
        System.out.println("array:" + Arrays.toString(array));  // [one, six, three, four, five]
        System.out.println("list:" + list);  // [one, six, three, four, five]

        // 修改集合中元素数据后，数组也会相应的改变
        list.set(2, "seven");
        System.out.println("array:" + Arrays.toString(array));  // [one, six, seven, four, five]
        System.out.println("list:" + list);  // [one, six, seven, four, five]

        // 给集合添加/删除元素相当于给数组添加/删除元素
        // 所以，集合与数组不支持添加/删除元素，是因为数组是定长的
        // 如果修改，则会抛出UnsupportedOperationException（不支持的操作）异常
        list.add("eight");
        System.out.println("array:" + Arrays.toString(array));
        System.out.println("list:" + list);
    }
}