Day12-----集合/泛型
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 使用泛型只能时E的子类/本身
泛型的下限限定： ？ super E 使用泛型只能时E的父类/本身