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()：把集合中的元素，存储到数组中

 1 Collection<String> coll = new ArrayList<>();
 2 System.out.println(coll);   //[]
 3
 4 coll.add("s1");
 5 coll.add("s2");
 6 coll.add("s3");
 7 coll.add("s4");
 8 coll.remove("s1");
 9
10 System.out.println(coll.isEmpty());     //false
11 System.out.println(coll.contains("s2"));    //true
12 System.out.println(coll.size());    //3
13 System.out.println(coll);       //[s2, s3, s4]
14
15 Object[] arr = coll.toArray();
16 for (int i = 0; i < arr.length; i++) {
17     System.out.print(arr[i] + ","); //s2,s3,s4,
18 }
19 System.out.println();
20
21 coll.clear();
22 System.out.println(coll.size());    //0

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

两个常用方法：

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

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

迭代器使用步骤：

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

1 Iterator<String> it = coll.iterator();
2
3 while (it.hasNext()){
4     System.out.println(it.next());
5 }

4.增强for循环

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

格式：

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

　　}

1 for (Object s : arr
2 ) {
3     System.out.println(s);
4 }
5
6 for (String s : coll
7 ) {
8     System.out.println(s);
9 }

5.泛型

泛型类：

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

 1 class TestClass<E>{
 2     private E name;
 3
 4     public E getName(){
 5         return name;
 6     }
 7
 8     public void setName(E name){
 9         this.name = name;
10     }
11 }

泛型方法：

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

 1 class TestMethod{
 2     public <E> void show1(E e){
 3         System.out.println(e.getClass());
 4     }
 5
 6     public <E> E show2(E e){
 7         return e;
 8     }
 9
10 }

泛型接口：

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

1 interface TestInterface<E>{
2
3     public abstract void add(E e);
4
5     public abstract E getE();
6 }

泛型通配符：

• 上界限定：? extends E   代表使用泛型只能是E类型的子类/本身
• 下界限定：? super E　　代表使用泛型只能是E类型的父类/本身

 1 public static void testExtends(Collection<? extends Number> coll) {
 2     System.out.println("coll中的元素只能是Number或Number的子类");
 3 }
 4
 5 public static void testSuper(Collection<? super Number> coll) {
 6     System.out.println("coll中的元素只能是Number或Number的父类");
 7 }
 8
 9
10 public static void main(String[] args) {
11
12     Collection<Integer> coll1 = new ArrayList<>();
13     Collection<Number> coll2 = new ArrayList<>();
14     Collection<Object> coll3 = new ArrayList<>();
15
16     testExtends(coll1);
17     testExtends(coll2);
18     testSuper(coll2);
19     testSuper(coll3);
20
21 }

原文地址：https://www.cnblogs.com/zhihaospace/p/12116159.html