DAY12

• 集合
• 集合数组的区别
• 集合框架
• Collection接口----java.util
• 常用功能

• Iterator迭代器
• 增强For循环

• 自定义含有泛型的类
• 含有泛型的方法
• 含有泛型的接口
• 泛型通配符----？
• 高级使用----受限泛型

集合

集合数组的区别

集合是Java的容器，可以用来存储多个数据

• 数组长度数固定的，集合是可变的
• 数组存储的是同类型元素。，集合存储对象且类型可以不一致

集合框架

Collection接口----java.util

常用功能

添加----删除----判断----计数----清空----得到数组

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

public class CollectionMain {

public static void main(String[] args) {
//Collection接口方法

//创建集合对象---可以使用多态
Collection<String> c=new ArrayList<String>();
System.out.println(c);

//add---添加元素--返回值Boolean
c.add("ace");
System.out.println(c);	//[ace]
c.add("李四");
c.add("张三");
c.add("王五");
System.out.println(c);	//[ace, 李四, 张三, 王五]

//remove--删除元素--返回值Boolean 存在且删除返回true 否则false

Boolean b1=c.remove("张三");
Boolean b2=c.remove("123");
System.out.println(b1);//true
System.out.println(b2);//false
System.out.println(c);//[ace, 李四, 王五]

//contains(Object)--判断集合中是否又这个元素
Boolean b3=c.contains("张三");
Boolean b4=c.contains("李四");
System.out.println(b3); 	//false
System.out.println(b4); 	//true
System.out.println(c);	 	 //[ace, 李四, 王五]

//isEmpty() 	判断是否为空
Boolean b6=c.isEmpty();
System.out.println(b6); 	//false

//size()    返回集合元素个数
int i = c.size();
System.out.println(i); 	 	//3

//toArray()		 集合中的元素存储到数组中
Object[] array = c.toArray();
System.out.println(array); 	//[Ljava.lang.Object;@15db9742
for (int j = 0; j < array.length; j++) {
System.out.println(array[j]);//ace			李四			王五
}

//clear 清空所有元素，集合还存在
c.clear();
System.out.println(c); 		//[]
System.out.println(c.isEmpty()); 	//true
}

}

集合遍历方法

Iterator迭代器

迭代：先判断集合中有没有元素，如果有就取出，在判断，一直到把集合中所有的元素全部取出

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

public class IteratorMain {

public static void main(String[] args) {
Collection<String> d=new ArrayList<String>();//建立一个集合

d.add("123");
d.add("456");
d.add("789");
d.add("45679");

Iterator<String> i = d.iterator();//通过集合建立一个迭代器对象
//Iterator是一个接口，得用实现类对象， 他的实现类对象方法是 "Collection里面的方法iterator-------返回值为Iterator"

//普通遍历
//		//hasNext判断下一个还有没有元素
//		boolean b = i.hasNext();
//		System.out.println(b); 		//true
//
//		//next取出下一个方法
//		String a = i.next();
//		System.out.println(a);

//遍历循环写出
while(i.hasNext()) {
String s=i.next();
System.out.println(s);
}
}

}

增强For循环

利用for的格式（但是底层还是迭代器），来实现迭代器的功能
遍历集合和数组
格式：

for(集合/数组类型 变量名 ： 集合名/数组名){sysou（变量名）； }

import java.util.ArrayList;

public class ForMain {

public static void main(String[] args) {
//增强for循环 使用for格式来实现迭代器功能
//遍历数组
int[] arr= {1,2,3,4,5,6};
for(int i:arr) {
System.out.println(i);
}

//遍历集合
ArrayList<String> a=new ArrayList<String>();
a.add("123");
a.add("456");
a.add("79");
for(String s:a) {
System.out.println(s);
}
}

}

泛型

泛型是一种未知的数据类型，当不知道使用什么数据类型的时候使用泛型
可以看作一种变量，来接受数据类型

public class ArraayList< E e>{
public Boolean add(E e){}			//这里的E都是泛型
public E get(int index){}			}

当创建集合元素的时候，会确定泛型的数据类型，ArrayList < String> list=new ArrayList< String>() ;
此时 E 确定为 String （赋值）

package java12;

import java.util.ArrayList;
import java.util.Iterator;

public class ArrayListMain {

public static void main(String[] args) {
//不使用泛型
/*好处
* 		可以输入任何类型数据，obj
* 弊端
* 		会发生异常
*/
method1();		//异常

//使用泛型
/*
* 好处
* 		避免类型转换异常
* 		把运行异常提升到编译阶段，意思就是写上就会报错
* 弊端
* 		固定了数据类型
*/
method2();		//	abcd		4		123		3

}

private static void method2() {
//使用泛型定义
ArrayList<String> list=new ArrayList<String>();
list.add("abcd");
//		list.add(1);		//报错，不能输入整形
list.add("123");

//使用迭代器
Iterator<String> i = list.iterator();
while(i.hasNext()) {
String str = i.next();
System.out.println(str);

System.out.println(str.length());
}
}

private static void method1() {
//不使用泛型定义
ArrayList list=new ArrayList();
//可以存储任意类型
list.add("abcd");
list.add(1);

//使用迭代器迭代
Iterator i = list.iterator();
while(i.hasNext()) {
Object obj = i.next();
System.out.println(obj);

//当使用子类方法String时要向下转型
String str=(String) obj;
System.out.println(str.length());
//此时由于第二个输入 1 不是String 所以会发生错误
}
}

}

自定义含有泛型的类

//泛型类
public class Generic<E> {
private String name;
private E age;
public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public E getAge() {
return age;
}

public void setAge(E age) {
this.age = age;
}

}

//主方法
public class GenericMain {

public static void main(String[] args) {
//自定义含有泛型类

Generic g=new Generic();
g.setName("字符串");

String name=g.getName();
System.out.println(name); 	//字符串

System.out.println("-------------");

Generic<Integer> a=new Generic<Integer>();
a.setAge(12);

Integer b = a.getAge();
System.out.println(b); 		//12 自动拆箱
}

}

含有泛型的方法

格式：

修饰符 <泛型> 返回值类型 方法名 （参数列表（使用泛型））{方法体；}

//定义
public class GenericMethod {
//定义一个含有泛型的方法
public <E> void method (E e) {
System.out.println(e);
}

//定义一个泛型的静态方法
public static <E> void method1(E e) {
System.out.println(e);
}
}

//主方法
public class GenericMethodMain {

public static void main(String[] args) {
GenericMethod gm=new GenericMethod();
gm.method(12);
gm.method("123");
gm.method('a');

//静态方法
GenericMethod.method1("静态方法");

}

}

含有泛型的接口

接口

public interface GenericInterface<E> {
public abstract void method(E e);
}

使用方法1：实现接口时就定义好泛型属于啥类型，直接调用

public class GenericInterface1 implements GenericInterface<Integer> {
@Override
public void method(Integer e) {
System.out.println(e);
}

}

使用方法2：实现接口时不确定泛型类型，在创建对象时确定

public class GenericInterface2<E> implements GenericInterface<E> {
@Override
public void method(E e) {
System.out.println(e);
}
}

主方法

public class GenericInterfaceMain {

public static void main(String[] args) {
GenericInterface1 g=new GenericInterface1();
g.method(12);

GenericInterface2<Integer> g2=new GenericInterface2<Integer>();
g2.method(12);

GenericInterface2<String> g3=new GenericInterface2<String>();
g3.method("字符串");
}
}

泛型通配符----？

不知道用啥时，可以用< ？>
此时只能接受数据，不能在集合中存储数据-----不能创建对象，只能作为参数使用

import java.util.ArrayList;
import java.util.Iterator;

public class GenericMain1 {

public static void main(String[] args) {
ArrayList<String> a=new ArrayList<String>();
a.add("a");
a.add("b");

ArrayList<Integer> b=new ArrayList<Integer>();
b.add(1);
b.add(2);

print(a);
print(b);
}

//定义一个方法输出所有ArrayList
public static void print(ArrayList<?> a) {
Iterator<?> i = a.iterator();

//迭代器输出
while(i.hasNext()) {
System.out.println(i.next());
}
}
}

高级使用----受限泛型

泛型的上限限定：

？ extends E

？ super E