码迷,mamicode.com
首页 > 其他好文 > 详细

集合(一)

时间:2020-06-06 21:55:06      阅读:68      评论:0      收藏:0      [点我收藏+]

标签:jdk   方式   通配符   基本数据   loading   linked   需要   oid   灵活   

一、集合

1. 集合概述

数组可以保存多个对象,但数组长度不可变,若在初始化数组时指定了数组长度那就是不可变的。为了保存数量不确定的数据,以及保存具有映射关系的数据,Java提供了集合类。集合类主要负责保存、盛装其它数据,因此集合类也被称为容器类。

  • Java集合类可用于存储数量不等的多个对象,并可以实现常用的数据结构,如栈、队列等。还可以用于保存具有映射关系的关联数组。

  • Java集合类主要由两个接口派生出:Collection和Map。

2. 集合与数组的比较

数组不是面向对象的,存在明显的缺陷,集合弥补了数组的缺点,比数组更灵活更实用,而且不同的集合框架类可适用不同场合

  • 数组能存放基本数据类型和对象,而集合类存放的都是对象,集合类不能存放基本数据类型。数组和集合存放的对象皆为对象的引用地址。
  • 数组容易固定无法动态改变,集合类容量动态改变。
  • 数组无法判断其中实际存有多少元素,length只告诉了数组的容量,而集合的size()可以确切知道元素的个数
  • 集合有多种实现方式和不同适用场合,不像数组仅采用顺序表方式
  • 集合以类的形式存在,具有封装、继承、多态等类的特性,通过简单的方法和属性即可实现各种复杂操作,大大提高了软件的开发效率

3. 集合框架包含的内容

Java集合框架提供了一套性能优良,使用方便的接口和类,他们位于java.util包中,按照其存储结构可以分为两大类:单列集合java.util.Collection和双列集合java.util.Map。接口和具体类如下图所示:
技术图片

注意:

  • Collection 接口存储一组不唯一,无序的对象。定义的是所有单列集合中共性的方法(不带索引的方法)
  • List 接口存储一组有序、可重复的对象。List 关注的是索引,拥有一系列和索引相关的方法,查询速度快。因为往 list 集合里插入或删除数据时,会伴随着后面数据的移动,所有插入删除数据速度慢。
  • Set 接口存储一组无序、不能重复的对象,集合中的元素不允许重复,且没有索引(不能用普通for循环遍历),存储与取出元素顺序可能不同。访问集合中的元素只能根据元素本身来访问(集合里元素不允许重复的原因)
  • Map 接口存储一组键值对象,提供key到value的映射。Map 集合中存储的是键值对,键不能重复,值可以重复。根据键得到值,对 map 集合遍历时先得到键的 set 集合,对 set 集合进行遍历,得到相应的值

二、Collection接口【从顶层开始学习】

1. 概述

Collection接口是处理对象集合的单列集合类根接口,其中定义了很多对元素进行操作的方法。Collection接口有两个主要的子接口ListSet,注意Map不是Collection的子接口

其中,List的特点是元素有序、元素可重复。Set的特点是元素无序,而且不可重复。List接口的主要实现类有java.util.ArrayListjava.util.LinkedListSet接口的主要实现类有java.util.HashSetjava.util.TreeSet

重点如图:

技术图片

2. Collection 常用方法

Collection是所有单列集合的父接口,因此在Collection中定义了单列集合(List和Set)通用的一些方法,这些方法可用于操作所有的单列集合。方法如下:

  • 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(): 把集合转为一个数组

方法演示:

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

public class UseCollection {
    public static void main(String[] args) {
		// 创建集合对象 
    	// 使用多态形式
    	Collection<String> cl = new ArrayList<String>();
    	// 使用方法
    	// 添加功能  boolean  add(String s)
		cl.add("你好");
        cl.add("我是");
        cl.add("一个");
        cl.add("好人");
        cl.add("!");
    	System.out.println(cl); //[你好, 我是, 一个, 好人, !]

    	// boolean contains(E e) 判断o是否在集合中存在
    	System.out.println("判断好人是否在集合中"+cl.contains("好人"));  //true

    	//boolean remove(E e) 删除在集合中的o元素
    	System.out.println("删除好人:"+cl.remove("好人"));
    	System.out.println("操作之后集合中元素:"+cl);
    	
    	// size() 集合中有几个元素
		System.out.println("集合中有"+cl.size()+"个元素");
        
		// Object[] toArray()转换成一个Object数组
    	Object[] objects = cl.toArray();
    	// 遍历数组
    	for (int i = 0; i < objects.length; i++) {
			System.out.println(objects[i]);
		}

		// void  clear() 清空集合
		coll.clear();
		System.out.println("集合中内容为:"+cl);
		// boolean  isEmpty()  判断是否为空
		System.out.println(cl.isEmpty());  	
	}
}

注意:有关Collection中的方法并不止上面这些,其他方法可以在API中查看。


三、Iterator接口

1. 概述

所有实现了Collection接口的容器类都有一个iterator方法用以返回一个实现Iterator接口的对象,**Iterator对象称作为迭代器,用于方便的对容器内元素进行遍历操作 **

在程序开发中,经常需要遍历集合中的所有元素。JDK为此提供了一个接口java.util.IteratorIterator接口也属于Java集合,但它与CollectionMap接口有所不同,Collection接口与Map接口主要用于存储元素,而Iterator主要用于迭代访问(即遍历)Collection中的元素。

Iterator迭代器是一个接口,无法直接使用。需要使用接口中的iterator方法。

  • public Iterator iterator(): 获取集合对应的迭代器,用来遍历集合中的元素

Iterator接口的常用方法如下:

  • public E next(): 取出的下一个元素。
  • public boolean hasNext():如果仍有元素可以迭代,则返回 true。

迭代器的使用步骤

  • 使用集合中的方法iterator()获取迭代器的实现类对象,用Iterator接口接收(多态)
  • 使用Iterator接口中的方法hasNext判断有没有下一个元素
  • 使用Iterator接口接口中的方法取出集合中的下一个元素

接下来我们通过案例学习如何使用Iterator迭代集合中的元素:

public class IteratorDemo {
  	public static void main(String[] args) {
        // 使用多态方式 创建对象
        Collection<String> coll = new ArrayList<String>();

        // 添加元素到集合
        coll.add("喵星人");
        coll.add("铲屎官");
        coll.add("汪星人");
        //遍历
        //使用迭代器 遍历   每个集合对象都有自己的迭代器
        Iterator<String> it = coll.iterator();
        //  泛型指的是 迭代出 元素的数据类型
        while(it.hasNext()){ //判断是否有迭代元素
            String s = it.next();//获取迭代出的元素
            System.out.println(s);
        }
  	}
}

tips::在进行集合元素取出时,如果集合中已经没有元素了,还继续使用迭代器的next方法,将会发生java.util.NoSuchElementException没有集合元素的错误。

2. 增强for

增强for循环(也称for each循环),是JDK1.5以后出现的高级for循环,专用来遍历数组和集合。其内部原理是Iterator迭代器,所以在遍历的过程中,不能对集合中的元素进行增删操作。

格式:

for(元素的数据类型 元素变量x  : 数组或集合对象){ 
  	//写操作代码
}

它用于遍历Collection和数组。通常只进行遍历元素,不要在遍历的过程中对集合元素进行增删操作。

注意: 增强for循环必须有被遍历的目标。目标只能是Collection或者是数组。且仅为遍历操作出现

实例:

private static void useFor(){
	int[] arr = {1,2,3,4,5,6};
	for (int i : arr){
		System.out.println(i)
	}
}//1 2 3 4 5 6

四、泛型

1. 概述

泛型是 JDK 5 中引入的一个新特性, 它提供了编译时类型安全检测机制,该机制允许在编译时检测到非法的类型。泛型的本质是参数化类型,也就是说所操作的数据类型被指定为一个参数

泛型是一种位置的数据类型,当我们不知道要用什么数据类型的时候可以用泛型。泛型也可以看成一个变量用来接受数据类型。

E e :Elem元素
T t :Type类型

ArrayList集合在定义的时候不知道集合中都会存储什么类型的数据,所以使用泛型。集合对象在创建的时候才会确定类型。E:未知的类型

2. 使用泛型的好处

若创建集合对象,不使用泛型

  • 好处是默认的类型就是Object类型,可以存储任意类型的数据
  • 弊端是不安全,会引发异常
public class GenericDemo2 {
	public static void main(String[] args) {
        Collection<String> list = new ArrayList<String>();
        list.add("abc");
        list.add("itcast");
        // list.add(5);//当集合明确类型后,存放类型不一致就会编译报错
        // 集合已经明确具体存放的元素类型,那么在使用迭代器的时候,迭代器也同样会知道具体遍历元素类型
        Iterator<String> it = list.iterator();
        while(it.hasNext()){
            String str = it.next();
            //当使用Iterator<String>控制元素类型后,就不需要强转了。获取到的元素直接就是String类型
            System.out.println(str.length());
        }
	}
}

若创建集合对象,使用泛型

  • 优点
    • 避免了类型转换的麻烦,存储与取出的是同种类型
    • 把运行期的异常(运行之后抛出的异常),提升到了编译期(写代码的时候报错)
  • 缺点:泛型是什么类型,就只能存储什么类型的数据

3. 泛型的定义与使用

泛型用来灵活地将数据类型应用到不同的类、方法、接口当中。将数据类型作为参数进行传递

定义和使用含有泛型的类

定义格式:

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

例如 API中的ArrayList集合:

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

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

使用泛型: 即什么时候确定泛型。

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

例如,ArrayList<String> list = new ArrayList<String>();

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

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

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

再例如,ArrayList<Integer> list = new ArrayList<Integer>();

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

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

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

举例自定义泛型类

public class MyGenericClass<MVP> {
	//没有MVP类型,在这里代表 未知的一种数据类型 未来传递什么就是什么类型
	private MVP mvp;
     
    public void setMVP(MVP mvp) {
        this.mvp = mvp;
    }
     
    public MVP getMVP() {
        return mvp;
    }
}

使用:

public class GenericClassDemo {
  	public static void main(String[] args) {		 
         // 创建一个泛型为String的类
         MyGenericClass<String> my = new MyGenericClass<String>();    	
         // 调用setMVP
         my.setMVP("大胡子登登");
         // 调用getMVP
         String mvp = my.getMVP();
         System.out.println(mvp);
         //创建一个泛型为Integer的类
         MyGenericClass<Integer> my2 = new MyGenericClass<Integer>(); 
         my2.setMVP(123);   	  
         Integer mvp2 = my2.getMVP();
    }
}

含有泛型的方法

定义格式:

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

例如,

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);
    }
}

含有泛型的接口

定义格式:

修饰符 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");
    }
}

4. 泛型通配符

当使用泛型类或者接口时,传递的数据中,泛型类型不确定,可以通过通配符<?>表示。但是一旦使用泛型的通配符后,只能使用Object类中的共性方法,集合中元素自身方法无法使用。

通配符基本使用

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

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

举个例子大家理解使用即可:

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){}
//?代表可以接收任意类型

tips:泛型不存在继承关系 Collection list = new ArrayList();这种是错误的。

通配符高级使用----受限泛型

之前设置泛型的时候,实际上是可以任意设置的,只要是类就可以设置。但是在JAVA的泛型中可以指定一个泛型的上限下限

泛型的上限

  • 格式类型名称 <? extends 类 > 对象名称
  • 意义只能接收该类型及其子类

泛型的下限

  • 格式类型名称 <? super 类 > 对象名称
  • 意义只能接收该类型及其父类型

比如:现已知Object类,String 类,Number类,Integer类,其中Number是Integer的父类

public static void main(String[] args) {
    Collection<Integer> list1 = new ArrayList<Integer>();
    Collection<String> list2 = new ArrayList<String>();
    Collection<Number> list3 = new ArrayList<Number>();
    Collection<Object> list4 = new ArrayList<Object>();
    
    getElement(list1);
    getElement(list2);//报错
    getElement(list3);
    getElement(list4);//报错
  
    getElement2(list1);//报错
    getElement2(list2);//报错
    getElement2(list3);
    getElement2(list4);
  
}
// 泛型的上限:此时的泛型?,必须是Number类型或者Number类型的子类
public static void getElement1(Collection<? extends Number> coll){}
// 泛型的下限:此时的泛型?,必须是Number类型或者Number类型的父类
public static void getElement2(Collection<? super Number> coll){}

集合(一)

标签:jdk   方式   通配符   基本数据   loading   linked   需要   oid   灵活   

原文地址:https://www.cnblogs.com/lf-637/p/13056347.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!