2.java基础回顾集合1

1.Collection集合

概念：集合是java中提供的一种容器，可以用来存储多个数据。

集合和数组有什么区别：

• 集合的长度是可变的，数组长度是不可变的
• 集合中只能存储对象类型，数组可以是基本类型（8种）还可以是对象类型

Collection接口：定义的是所有单列集合中共性的方法，所有单列集合都可以使用共性方法，没有带索引的方法

• List接口：有序的集合，允许存储重复的元素，有索引可以使用for循环遍历
  • Vector集合
  • ArrayList集合
  • LinkedList集合
• Set接口：不允许存储重复元素，没有索引不能通过普通for循环遍历，但可以使用foreach遍历
  • TreeSet集合
  • HashSet集合：
    • LinkedHashSet集合

2.Collection接口常用功能

• public boolean add(E e)：把给定的对象添加到当前集合中
• public void clear()：清空集合中所有元素
• public boolean remove(E e)：把给定的对象在当前集合中删除
• public boolean contains(E e)：判断当前集合中是否包含给定的对象
• public boolean isEmpty()：判断当前集合是否为空
• public int size()：返回集合中元素的个数
• public Object[] toArray()：把集合中的元素，存储到数组中

Collection<String> coll = new ArrayList<>();
System.out.println(coll);   //[]

coll.add("s1");
coll.add("s2");
coll.add("s3");
coll.add("s4");
coll.remove("s1");

System.out.println(coll.isEmpty());     //false
System.out.println(coll.contains("s2"));    //true
System.out.println(coll.size());    //3
System.out.println(coll);       //[s2, s3, s4]

Object[] arr = coll.toArray();
for (int i = 0; i < arr.length; i++) {
    System.out.print(arr[i] + ","); //s2,s3,s4,
}
System.out.println();

coll.clear();
System.out.println(coll.size());    //0

3.Iterator接口：迭代器（对集合进行遍历）

两个常用方法：

• boolean hasNext()：如果仍有元素可以迭代返回true
• E next()：返回下一个元素

Iterator迭代器我们无法正常使用，需要使用Iterator接口的实现类，Collection接口中iterator()方法返回迭代器对象的实现类Iterator<E> iterator()。

迭代器使用步骤：

1. 获取迭代器
2. 判断是否还有元素
3. 获取下一个元素

Iterator<String> it = coll.iterator();

while (it.hasNext()){
    System.out.println(it.next());  
}

4.增强for循环

JDK1.5之后出现的新特性，所有的单列集合都可以使用增强for循环

格式：

　　for(集合/数组的数据类型 变量名：集合名/数组名){

　　}

for (Object s : arr
) {
    System.out.println(s);
}

for (String s : coll
) {
    System.out.println(s);
}

5.泛型

泛型类：

　　语法：修饰符 class 类名<代表泛型的变量>{ }

class TestClass<E>{
    private E name;
    
    public E getName(){
        return name;
    }
    
    public void setName(E name){
        this.name = name;
    }
}

泛型方法：

　　语法：修饰符 <代表泛型的变量> 返回值类型 方法名(参数){ }

class TestMethod{
    public <E> void show1(E e){
        System.out.println(e.getClass());
    }
    
    public <E> E show2(E e){
        return e;
    }
    
}

泛型接口： 

　　语法：修饰符 interface 接口名<代表泛型的变量>{ }

interface TestInterface<E>{
    
    public abstract void add(E e);
    
    public abstract E getE();
}

泛型通配符：

• 非受限通配符：?  代表任意的对象的数据类型
  • 不能在使用new创建对象中使用
  • 只能作为方法传递或接收返回数据使用
• 受限通配符：
  • 上界限定：? extends E   代表使用泛型只能是E类型的子类/本身
  • 下界限定：? super E　　代表使用泛型只能是E类型的父类/本身

非受限通配符

public class demo09 {

    public static void printArrayList(ArrayList<?> arrayList) {
        Iterator<?> iterator = arrayList.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }

    public static void main(String[] args) {
        ArrayList<String> arrayList1 = new ArrayList<>();
        arrayList1.add("arrayList1");
        arrayList1.add("arrayList11");
        arrayList1.add("arrayList111");

        ArrayList<?> arrayList2 = arrayList1;
        System.out.println(arrayList2);
        printArrayList(arrayList2);
    }
}

受限通配符

public static void testExtends(Collection<? extends Number> coll) {
    System.out.println("coll中的元素只能是Number或Number的子类");
}

public static void testSuper(Collection<? super Number> coll) {
    System.out.println("coll中的元素只能是Number或Number的父类");
}


public static void main(String[] args) {

    Collection<Integer> coll1 = new ArrayList<>();
    Collection<Number> coll2 = new ArrayList<>();
    Collection<Object> coll3 = new ArrayList<>();

    testExtends(coll1);
    testExtends(coll2);
    testSuper(coll2);
    testSuper(coll3);

}