Collection,泛型,Map
1.Collection集合
集合和数组的区别?
- 数组的长度是固定的, 集合的长度是可变的
- 数组中存储的数据都是同一类型的数据。集合存储的是对象,而且对象的类型可以不一致
集合框架
单列集合
java.util.Collection
Collection:单列集合的跟接口,用于存储一系列的规则的元素
两个子接口:
- java.util.List: List中元素是有序,元素可重复
- 实现类:java.util.ArrayList, java.util.LinkedList
- Java.util.Set: Set中元素无序,不重复
- 实现类:java.util.HashSet, java.util.TreeSet
Collection集合的常用功能
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()
:把集合的元素存储到数组中import java.util.ArrayList; import java.util.Colleaction; public class Demo{ public static void main(String[] args){ // 创建集合对象,使用多态 Collection<String> coll new ArrayList<String>(); //使用方法 // 添加 coll.add("杨幂").add("刘亦菲").add("唐嫣").add("胡珺"); System.out.println(coll); // 判断是否在集合中 System.out.println("判断胡珺是否在集合中"+coll.contains("胡珺")); // 判断集合是否为空 System.out.println(coll.isEmpty()); // 集合中有多少个元素 System.out.println(coll.sixe()); // 删除指定的元素 coll.remove("胡珺"); // 集合存储到数组中 Object[] object = coll.toArray(); //遍历数组 for(int i=0;i<object.length;i++){ System.out.println(i); } // 清空集合 coll.clean(); } }
2.Iterator迭代器
迭代
- 在集合中获取元素之前进行判断集合中有没有元素,如果有取出来,继续进行判断,继续取出来,知道集合元素全部取出
Iterator的常用方法
public E next()
:返回迭代的下一个元素public boolean hasNext()
:如果有元素可以迭代,则返回True
public class Demo{
public static void main(String[] args){
//使用多肽创建集合
Collection<String> coll = new ArrayList<String>();
// 添加元素
coll.add("杨幂").add("胡珺").add("程锐");
//使用迭代器进行遍历
Iterator<String> it = coll.iterator();
// 泛型值得是: 迭代出来的数据类型
while(it.hasNext()){//判断是否有迭代元素
String s = it.next(); //获取迭代的元素
System.out.println(s);
}
}
}
增强for
格式:
for(元素的数据类型 变量:Collection集合或者数组){
//操作代码
}
它用于变量Collection和数组, 不要在遍历的时候对集合元素进行曾删操作
public class Demo{
public static void main(String[] args){
int[] arr = {1,2,3,4,5};
for(int i:arr){
System.out.println(i);
}
}
}
public class Demo{
public static void main(String[] args){
Collection<String> coll = new ArrayList<String>();
coll.add("112");
coll.add("113");
coll.add("114");
for(String s:coll){
System.out.println(s);
}
}
}
只针对Collection和数组, 用于遍历
3.泛型
在从集合中存取数据,数据将被提升为Object类型,当我们取出一个的对象,进行操作,这个时候需要类型转换
-
泛型:可以再类或者是方法中预支的使用未知的数据类型
一般在创建对象是,当没有指定类型的时候,默认是Object类型
泛型好处
- 将运行售后的ClassCastException,转移到了编译时期变成编译失败
- 避免了类型强转的麻烦
public class Demo{
public static void main(String[] args){
collection<String> coll = new ArrayList<String>();
coll.add("abd");
coll.add("aaa");
//coll.add(5); 当集合明确类型后, 存放类型不一致就会编译错误
// 集合已经明确的具体存放的元素类型,那么在使用迭代器的时候,迭代器也同样知道具体遍历元素类型
Iterator<String> it = coll.iterator();
while(it.hasNext()){
//当使用Iterator控制的元素类型之后,就不要强转了,获取的元素就是String类型
String str = it.next();
System.out.println(str);
}
}
}
泛型是数据泛型的一部分,我们将类名和泛型合并起来一起看做数据类型
泛型的定义与使用
我们在集合中通常使用到了泛型
泛型,用来灵活的将数据类型应用到不同的类,方法,接口当中。将数据类型作为参数进行传递
定义和使用含有泛型的类
定义格式:
修饰符 class 类名<代表泛型的变量>{}
demo
ArrayList集合;
public class ArrayList<E>{
public boolean add(E e){}
public E get(int index){}
....
}
使用泛型:即什么时候确定泛型
在创建对象的时候使用泛型
例如:ArrayList
此时就可以理解变量E的值就是String类型,那么理解为
public class ArrayList<String>{
public boolean add(String e){}
public String get(int index){}
}
再例如,ArrayList
此时理解为E的值就是Integer
public class ArrayList<Integer>{
public boolean add(Integer e){}
public Integer get(int index){}
}
demo
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 main(String[] args){
// 创建一个泛型为Integer的类
MyGenericClass<Integer> myNum = new MyGenericClass<Integer>();
myNum.setMVP(124);
Integer mvpNum = myNum.getMVP();
System.out.println(mvpNum);
//创建一个泛型为String的类
MyGenericClass<String> myStr = new MyGenericClass<String>();
myNum.setMVP("哈哈");
String mvpStr = myStr.getMVP();
System.out.println(mvpStr);
}
}
含有泛型的方法
定义格式:
修饰符 <代表泛型的变量> 返回值类型 方法名(参数){}
例如
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(12);
}
}
含有泛型的接口
定义格式:
修饰符 Interface接口名 <代表泛型的变量>{}
例如
public interface MyGenericInterFace<E>{
public abstract void add(E e);
public abstract E getE();
}
使用格式:
1.定义类是确定泛型的类型
例如
public class MyImpl implements MyGenericInterFace<String>{
@Override
public void add(String e){
//...
}
@Override
public void getE(){
return null;
}
}
//此时泛型E的值就是String类型
2.始终不确定泛型的类型,直接创建对象时,确定泛型的类型
例如
public class MyImpl<E> implements MyGenericInterFace<E>{
@Override
public void add(E e){
//...
}
@Override
public void getE(){
return null;
}
}
确定泛型:
public class GenericInterFace{
public static void main(String[] args){
MyImpl<String> my = new MyImpl<String>();
my.add("aaa");
}
}
泛型通配符
当我们使用泛型或者是接口的时候,传递的数据中,泛型类型不确定,可以通过通配符<?>表示,但是一旦使用泛型的通配符之后,只能使用Object类中的共性方法,集合中元素自身的方法无法使用。
通配符的基本使用
泛型的通配符:不知道使用什么类型来接收的时候,此时可以使用??表示未知通配符
此时只接受数据,不能再集合中存储数据
例子:
public class Demo{
public static void main(String[] args){
Collection<Integer> list1 = new ArrayList<Integer>();
getElement(list1);
Collection<String> list2 = new ArrayList<String>();
getElement(list2);
}
public static void getElement(Collection<?> coll){
// ? 代表可以接受任意类型
}
}
泛型不存在继承关系,Collection