Day12-----集合/泛型

集合

集合数组的区别

集合是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的父类/本身