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

泛型通配符:

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

非受限通配符

 1 public class demo09 {
 2 
 3     public static void printArrayList(ArrayList<?> arrayList) {
 4         Iterator<?> iterator = arrayList.iterator();
 5         while (iterator.hasNext()){
 6             System.out.println(iterator.next());
 7         }
 8     }
 9 
10     public static void main(String[] args) {
11         ArrayList<String> arrayList1 = new ArrayList<>();
12         arrayList1.add("arrayList1");
13         arrayList1.add("arrayList11");
14         arrayList1.add("arrayList111");
15 
16         ArrayList<?> arrayList2 = arrayList1;
17         System.out.println(arrayList2);
18         printArrayList(arrayList2);
19     }
20 }

受限通配符

 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 }

 

posted @ 2019-12-29 19:53  All_just_for_fun  阅读(149)  评论(0编辑  收藏  举报