Java面向对象基础—Collection、泛型、list

一、Collection

1. 集合体系结构［记忆］

・集合类的特点
提供一种存储空间可变的存储模型，存储的瓣容量可以随时发生改变

• 集合类的体系图

2. Collection集合概述和基本使用

• Collection集合概述

  • 是单例集合的顶层接口 ,它表示一组对象,这些对象也称为Col lection的元素
  • JDK不提供此接口的任何直接实现,它提供更具体的子接口(如Set和List)实现

Collection集合基本使用

public class col1ectionDemoOl ( public static vold main(string[] args) {
	//创建co】】ecti on集合的对象
	Col1ection<Stri ng> c = new ArrayList<Stri ng>();

		//添加元素：boolean add(E e)
		c.add(”hello”)；
		c.add("worid");
		c.add("java");

	//输出集合对象
		System.out.pri ntln(c);
	}
}

3. Collection 常用方法

方法名	说明
boolean add(E e)	添加元素
boolean remove(Object o)	从集合中移除指定的元素
void clear()	清空集合中的元素
boolean contains(Object o)	判断集合中是否 g 旨定的元素
boolean isEmptyO	判断集合是否为空
int size()	集合的长度

• 示例代码

public class Demo {
    public static void main(String[] args) {
        /*
            Collection接口 常用功能:
                - public boolean add(E e)：  把给定的对象添加到当前集合中 。
                - public void clear() :清空集合中所有的元素。
                - public int size(): 返回集合中元素的个数。
                - public boolean remove(E e): 把给定的对象在当前集合中删除。
                - public boolean contains(Object obj): 判断当前集合中是否包含给定的对象。
                - public boolean isEmpty(): 判断当前集合是否为空。
                - public Object[] toArray(): 把集合中的元素，存储到数组中
         */
        // 创建一个Collection集合对象,指定集合中元素的类型为String
        Collection<String> coll = new ArrayList<>();

        // 往集合中添加元素: public boolean add(E e)
         coll.add("张三");
        coll.add("李四");
        coll.add("王二");
        coll.add("赵六");
        System.out.println("添加元素后的集合:"+coll);


        boolean flag1 = coll.remove("张三");
        System.out.println("flag1:"+flag1);// flag1:true
        System.out.println("删除张三元素后的集合:"+coll);

   
        boolean flag2 = coll.contains("张三");
        System.out.println("张三这个元素是否存在:"+flag2);// false

      
        boolean flag3 = coll.contains("赵四");
        System.out.println("赵四这个元素是否存在:"+flag3);// true

        // 判断集合中是否还有元素:public boolean isEmpty()
        boolean flag4 = coll.isEmpty();
        System.out.println("集合中是否还有元素:"+flag4);// false
        /*coll.clear();
        boolean flag5 = coll.isEmpty();
        System.out.println("集合中是否还有元素:"+flag5);// true*/

        // 把集合转换为数组:public Object[] toArray()  本质是:把该集合中的元素存储到一个数组中
        Object[] arr = coll.toArray();
        System.out.println("数组:"+ Arrays.toString(arr));

    }
}

4.Collection集合的遍历

• 迭代器的介绍

  • 迭代器,集合的专用

  • Iterator iterator():返回此集合中元素的迭代器,通过集合的iterator方法得到

  • 迭代器是通过集合的iterator。方法得到的,所以我们说它是依赖于集合而存在的

  • Collection集合的遍历

public static void main(String[] args) throws Exception{
        Collection<String> coll = new ArrayList<>();
         coll.add("张三");
        coll.add("李四");
        coll.add("王二");
        coll.add("赵六");

        Iterator<String> it = coll.iterator();
        while (it.hasNext()) {
            String s = it.next();
            System.out.println(s);
            //coll.add("章子怡");// 报异常
            //coll.remove(s);// 报异常
            it.remove();
        }
  

二、泛型

1. 集合不使用泛型

集合不使用泛型的时候，存的时候什么类型都能存。但是取的时候就懵逼了。取出来啥也不是。

public class Demo_01不使用泛型 {
    public static void main(String[] args) {
        //创建集合对象
        Collection c = new ArrayList();

        //添加元素
        c.add("张三");
        c.add(123);
        c.add(3.14);

        //判断元素的长度是否大于4
        //获取迭代器
        Iterator it = c.iterator();

        //ClassCastException类型转换异常
        while (it.hasNext()) {
            String s = (String)it.next();
            int len = s.length();
            System.out.println("打印字符串的长度" + len);
        }
    }
}

2. 使用泛型

• 使用泛型在编译期直接对类型作出了控制，只能存储泛型定义的数据

public class Demo02_使用泛型 {
    public static void main(String[] args) {
        //创建集合
        Collection<String> list = new ArrayList<>();
        //添加元素
        list.add("张三");
        //list.add(123);    //在存储的时候就对类型作出了编译判断
        list.add("李四");

        //取出来的也都是字符串
    }
}

3. 定义和使用含有泛型的类

定义含有泛型的类

• 定义格式：

修饰符 class 类名<代表泛型的变量> {  }
代表泛型的变量: 可以是任意字母  例如: T,E...

• 泛型在定义的时候不具体类型，使用的时候才具体类型。在使用的时候确定泛型的具体数据类型。

class ArrayList<E>{ 
    public boolean add(E e){ }

    public E get(int index){ }
   	....
}

确定泛型具体类型

• 在创建对象的时候确定泛型

例如，ArrayList list = new ArrayList();

此时，变量E的值就是String类型,那么我们的类型就可以理解为：

class ArrayList<String>{ 
     public boolean add(String e){ }

     public String get(int index){  }
     ...
}

4. 定义和使用含有泛型的方法

定义含有泛型的方法

• 定义格式：

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

• 例如:

public class MyGenericMethod {	  
    public <MVP> void show(MVP mvp) {
    	System.out.println(mvp.getClass());
    }
    
    public <MVP> MVP show2(MVP mvp) {	
    	return mvp;
    }
}

确定泛型具体类型

• 调用方法时，确定泛型的类型

public class GenericMethodDemo {
    public static void main(String[] args) {
        // 创建对象
        MyGenericMethod mm = new MyGenericMethod();
        // 演示看方法提示
        mm.show("aaa");
        mm.show(123);
        mm.show(12.45);
    }
}

5. 定义和使用含有泛型的接口

定义含有泛型的接口

• 定义格式：

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

• 例如:

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

确定泛型具体类型

1、定义实现类时确定泛型的类型

• 例如

public class MyImp1 implements MyGenericInterface<String> {
	@Override
    public void add(String e) {
        // 省略...
    }

	@Override
	public String getE() {
		return null;
	}
}

此时，泛型E的值就是String类型。
2、始终不确定泛型的类型，直到创建对象时，确定泛型的类型

• 例如

public class MyImp2<E> implements MyGenericInterface<E> {
	@Override
	public void add(E e) {
       	 // 省略...
	}

	@Override
	public E getE() {
		return null;
	}
}
//确定泛型:
/*
 * 使用
 */
public class GenericInterface {
    public static void main(String[] args) {
        MyImp2<String>  my = new MyImp2<String>();  
        my.add("aa");
    }
}

6. 泛型通配符

通配符基本使用

• 泛型的通配符:不知道使用什么类型来接收的时候,此时可以使用?,?表示未知通配符。

• 此时只能接受数据,不能往该集合中存储数据。

例如:

public static void main(String[] args) {
    Collection<Intger> list1 = new ArrayList<Integer>();
    getElement(list1);
    Collection<String> list2 = new ArrayList<String>();
    getElement(list2);
}

public static void getElement(Collection<?> coll){}

//？代表可以接收任意类型
//泛型不存在继承关系 Collection