集合
集合的概念
集合:就是一个存储数据的容器。
集合与数组一样,也是一个容器,与数组的区别:
1 数组长度固定,集合的长度不固定。
2 数组可以存储基本类型和引用类型,集合中存储的元素类型只能是引用类型。
集合的框架结构介绍
集合与数组的对比
相同点:
都是数据的容器,在一个数组或集合中可以存储多个数据
不同点:
元素:数组中的元素只能是相同,集合中的元素是任意的(泛型)
数组中可以存储基本类型和引用类型,集合只能存储引用类型
长度(元素个数):
数组是定长的,一旦初始化长度就不可以修改
集合长度可以修改,可以删除元素和添加元素
Collection接口
Collection中常用的方法
//1创建Collection对象
Collection collection=new ArrayList();
//2操作
//2.1添加
collection.add("张三");
collection.add("李四");
collection.add("他二大爷");
collection.add("他老爷");
collection.add("七大妈");
collection.add("张三");
System.out.println("集合的元素个数:"+collection.size());
//2.2删除
//2.2.1删除一个
// collection.remove("张三");
// System.out.println("删除之后的数据个数:"+collection.size());
//2.2.2清空
// collection.clear();
// System.out.println("清空之后:"+collection.size());
//4判断
//4.1判断是否存在
boolean b=collection.contains("王五");
boolean b2=collection.contains("他老爷");
System.out.println(b);
System.out.println(b2);
//4.2判断是否为空
System.out.println(collection.isEmpty());
//5查找
//6其他方法
Collection c1=new ArrayList();
c1.add("中国");
c1.add("朝鲜");
Collection c2=new ArrayList();
c2.add("中国");
c2.add("朝鲜");
System.out.println("c1.equals(c2):"+c1.equals(c2));
System.out.println("c1==c2:"+(c1==c2));
Collection collection=new ArrayList();
//1添加
collection.add(111);//111自动装箱 new Integer(111)
collection.add(222);
collection.add("111");
collection.add("222");
//2删除
System.out.println("元素的个数:"+collection.size());
System.out.println("删除之前:"+collection);
collection.remove("111");
System.out.println("删除之后:"+collection.size());
System.out.println("删除之后:"+collection);
泛型
什么是泛型
泛型就是可以表示一个广泛数据类型的类型参数(泛型只能表示引用类型),把数据类型作为参数来传递。
形式参数:声明方法时,在方法的参数列表中声明,而且在方法体中会使用到,是一个未知的数据。
实际参数:调用方法时,实际传递的参数。
类型参数:在一个类中声明一个未知的数据类型,在类中可以使用这个类型,但是具体类型取决于实例化时传入的实际类型。
泛型的声明
1)泛型可以声明在类中:(泛型类)
注意:
1 :<>表示泛型,E(Element)表示占位符代替一个数据类型 ,其他的名称T(Type) V(Value) K(Key)
2 可以写多个泛型参数,如果写多个中间用逗号隔开
public class 类名<标识符>{
//类体
//泛型可以在类中充当成员变量
//泛型可以再类中充当方法的返回值
//泛型可以在类中充当方法的参数
}
2)泛型可以声明在方法中:(泛型方法)
public static <标识符> void fun(){}
3)泛型可以声明在接口中:(泛型接口)
public interface 接口名<标识符>{
//泛型可以充当接口中方法的返回值
//泛型可以充当接口中方法的参数
}
案例1:
package com.qf.day15_2;
/**
* 老师类
* 泛型类
* T 占位符:表示未知的数据类型
* @author wgy
*
*/
public class Teacher<T>{
String name;
int age;
int workyear;
T t;
public void show() {
System.out.println("姓名:"+name+" 年龄:"+age+" 工作年限:"+workyear+" t:"+t);
}
}
案例2:
package com.qf.day15_2;
/**
* 学生类
* @author wgy
*
*/
public class Student {
String name;
int age;
public void show(String s) {
System.out.println("姓名:"+name+" 年龄:"+age+" "+s);
}
/**
* 泛型方法
* T 占位符 表示一种未知的数据类型
* T type
* E
* K
* V
*/
public <T> void fun(T t) {
System.out.println(t);
}
}
案例3:
package com.qf.day15_2;
/**
* 接口
* 泛型的
* @author wgy
*
*/
public interface MyCollection<T> {
void add(T t);
void remove(T t);
T get();
}
package com.qf.day15_2;
public class MyArray<T> implements MyCollection<T>{
@Override
public void add(T t) {
// TODO Auto-generated method stub
System.out.println("添加了:"+t);
}
@Override
public void remove(T t) {
// TODO Auto-generated method stub
System.out.println("删除了:"+t);
}
@Override
public T get() {
// TODO Auto-generated method stub
return null;
}
}
案例4
package com.qf.day15_3;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import javax.net.ssl.SSLContext;
public class Demo1 {
public static void main(String[] args) {
//创建泛型对象 元素类型String
Collection<String> coll=new ArrayList<String>();
//1添加
coll.add("苹果");
coll.add("桔子");
coll.add("芒果");
coll.add("西瓜");
System.out.println("元素个数:"+coll.size());
System.out.println(coll);
//2删除
// coll.remove("苹果");
// System.out.println("删除之后");
// System.out.println(coll);
//3遍历
//3.1增强for
System.out.println("---------增强for--------");
for(String s:coll) {
System.out.println(s);
}
System.out.println("---------迭代器--------");
Iterator<String> it=coll.iterator();
while(it.hasNext()) {
System.out.println(it.next());
}
}
}
说明
1)标识符(占位符):只要是一个合法的标识符即可,一般情况下,只使用一个大写字母表示泛型
例:public class Person{} E(Element) K(key) V(value)
2)泛型的类型与声明的类或接口不需要有任何的关系
3)泛型可以在类中充当任何的成员
4)泛型具体类型取决于实例化对象时传入的实际类型
泛型使用时的注意事项
1)泛型不能在类中声明静态属性、常量
final修饰的属性必须在声明的同时初始化,所以泛型不能声明常量。
static修饰的属性是静态属性,先于对象,泛型类型取决于创建对象时传入的实际类型,所以泛型不能声明静态属性
综上所述:不能使用泛型声明静态属性、常量
2)泛型不能在类中初始化数组,但是可以声明数组
初始化数组时需要给元素进行分配空间,但是泛型类型不确定无法分配空间
3)在类中不能使用泛型声明参数个数相同的重载方法
当一个类中有两个泛型时,创建对象时,两个泛型使用相同类型替换,那么重载方法就是相同的方法(同名,参数列表也相同)
4)使用不同实际类型创建出的泛型类对象的引用不可以相互赋值
受限泛型
1)<?>:表示任意类型
2)<? extends T>:表示T类或者T类的子类
3)<? super T>:表示T类或者T类的父类
泛型应用在集合上
泛型在集合中应用,表示的是集合中元素的类型
迭代器
迭代器的工作原理
迭代器相当于一个游标,最初获取迭代器时,迭代器的位置在所有元素的前面,每迭代一个元素,迭代器向后移动一个位置
迭代器的使用
//第三种遍历的方法
Iterator<Student> i=list.iterator();
//hasNext,有没有下一个值
while(i.hasNext()){
//i.next()返回的是对象,而且没执行一次,指针就会向下走一次
System.out.println(i.next().toString());
}
注意点:
1.每次迭代获取前(调用next()),应该判断是否有这个元素(hasNext()),如果有再获取,如果没有救不要获取,如果强行获取,就报错:java.util.NoSuchElementException
2.迭代器在工作期间,集合本身就不要去更改集合的结构。但是迭代器对象自己可以删除。(功能慎用)