标签：style 转换 泛型使用 read 接收 抽象类 icc hash 自动
Collection（接口）
所有超级接口：
Iterable<E>
一.集合
1.集合的介绍&集合和数组的区别
什么是集合：java中的一种容器
什么是数组：java中的一种容器
区别：
数组的长度是固定的，如果增加长度，只能创建另一个数组
集合的长度是可变的，数据可以理论无限调价，自动扩容
小区别：
数组的元素必须是同一种类型。例子：int[] nums=new int[10];
集合的元素可以不同类型。例子：ArrayList<Obiect> nums=new ArrayList<Interfger>();
2.集合框架的介绍
在JDK1.1的时候，只有一种集合Vector<泛型>
在JDK1.5的时候，出现集合框架（一大堆类在一起）
集合框架顶层接口：Collection<E>
子接口： List<E> ：列表 Set<E>集 Queue<E>
有序，有下标，可重复 无序(LinkedHashSet除外)，无下标，不可重复
实现类：ArrayList,LinkedList,Vector HashSet TreeSet
数组列表，链式列表， 哈希集 linkedHashSet
链式哈希集
3.collection中的通用方法：
增：public boolean add（E e）；------E的意思是泛型
删：public void remove（E e）；
改：无（需要下标）
查：无
其他：
public void clear();//清空，删除集合中的所有元素
public int size();//获取集合的长度（元素个数）
public boolean contains(E e);//判断当前集合中是否包含了给定的对象
public boolean isEmpty();//判断当前集合是否有元素
public Object[] toArray();//转成数组
注：
集合直接打印为数组。
数组直接打印为地址值
三.集合的通用遍历方式--------迭代器
1.集合迭代器的原理：
仓库管理员（迭代器对象）-----Iterator
获取迭代器对象:调用集合.iterator()
/*
public static void main(String[] args) {
Collection<String> collection=new ArrayList<String>();
collection.add("a");
collection.add("b");
collection.add("c");
collection.add("d");
//迭代器遍历集合
//1.找到迭代器
Iterator<String> iterator = collection.iterator();
while (iterator.hasNext()) {
String next = iterator.next();
System.out.println(next);
}
// //2.判断是否有下一个元素
// boolean b = iterator.hasNext();
// if (b){
// String next = iterator.next();
// System.out.println(next);
// }
}
*/
借助了指针，只有next会让指针动。
hasNext只是用来判断
注意：
必须先判断，元素存在，再取出元素
2.集合迭代器的介绍和使用
所谓的集合迭代器就是用来遍历集合的
标准遍历代码：
Iterator<集合的泛型> iterator=集合.iterator();
while (iterator.hasNext()) {
集合的泛型 next = iterator.next();
System.out.println(next);
}
3.增强for循环：
语法糖：格式的省略版本，但是底层原理不变
例子：
int[] nums=new int[]{1,2,3,4,5};
存在栈中 存在堆（new）中
int[] nums={1,2,3,4,5};
迭代器的语法糖：是增强for循环：
格式：
for（数据类型 变量名：数组/集合）{
System.out.println(变量名);
}
快捷键：
集合/数组.for 回车
三.泛型
1.什么是泛型
ArrayList<Integer> nums=new ArrayList<Integer>();
可以消除代码中的强制类型转换，同时获得一个附加的类型检查层，该检查层可以防止有人将错误类型的键或值保存在集合中。这就是泛型所做的工作。
泛型：
一种不确定的类型
格式;
一个泛型：<E>
两个泛型：<K,V>
2.泛型的好处：
a.不使用泛型（前提想要取相同的类型，进行遍历）
1.需要手动的向下转型
2.编译时不报错，运行时直接崩溃，并出现类型转换异常
Exception in thread "main" java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String
例子：
ArrayList arrayList=new ArrayList();
arrayList.add("dad");
arrayList.add(11);
arrayList.add(3.14F);
arrayList.add(true);
for (Object o : arrayList) {
String s =(String) o;
System.out.println(s);
}
}
运行结果：
dad
Exception in thread "main" java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String
at day02.demo04.main(demo04.java:13)
Process finished with exit code 1
b.使用泛型
1.不需要手动向下转型
2.把运行时异常 转译到 编译时报错
JDK1.5之后强烈建议使用泛型。
3.泛型的定义和使用：
a.泛型类
格式：
public class 类名<E>{
既可以使用E:E e
public void setE(E newE){
this.e=new E;
}
}
例子：
public class GenericClass <E>{
private E a;
public E getA() {
return a;
}
public void setA(E a) {
this.a = a;
}
}
使用：
类名<Interger> 对象名=new 类名<Interger>();
2.泛型方法:泛型使用在方法上
格式：
public <T> void 方法名（F f）{
}
例子：
public <String> void Generic(String s){
}
使用：
对象.方法名（具体的参数）
此时泛型方法中泛型确定了，是我们传入具体参数的类型
3.泛型接口
格式：
public interface 接口名<E>{
public abstract void show(E e)
}
注意：
public abstract（抽象类中不能省略）
使用：
a.实现类在实现接口时，直接确定泛型
public class 类名 implements 接口名<String>{
public abstract void show(String e);
}
b.实现类在实现接口时，不确定泛型，而是继续保留
public class 类名 implements 接口名<E>{
public abstract void show(E e);
}
使用实现类创建对象时，再去确认泛型
类名<String> 对象名=new 类名<String>();
4.泛型的优点：
安全简单，在编译的时候检查类型安全，并且所有的强制转换都是自动和隐式的
提高代码的重用率
5.泛型的通配符：
泛型通配符：？
例子：
当泛型有多种时：
ArrayList<Interger> arr1;
ArrayList<String> arr2;
定义方法。接收这两个集合，需要用到泛型通配符"?"
public static void show（ArrayList<?> arr）{
}
6.泛型的上下限：
上限：<? extends Animal>:表示 必须泛型必须是Animal 或者Animal的子类
下限：<? super Dog>:表示泛型必须是Dog或者Dog的父类
否则会报错
注意：
Number是所有包装类的父类
Integer extends Number extends Obiect
String extends Obiect
四，集合的案例
斗地主
实现步骤：
1.产生一副牌（54）
2.洗牌（打乱集合元素的顺序）
3.发牌（剩余3张，作为底牌）
4.看牌（遍历集合）
代码实现：
public static void main(String[] args) {
// 1.产生一副牌（54）
ArrayList<String> cardsBox=new ArrayList<String>();
String [] colars={"?","?","?","?"};
String [] Licensing={"A","2","3","4","5","6","7","8","9","10","j","Q","K"};
for (String colar : colars) {
for (String s : Licensing) {
cardsBox.add(colar+s);
}
}
cardsBox.add("小s");
cardsBox.add("大s");
System.out.println(cardsBox);
// 2.洗牌（打乱集合元素的顺序）
Collections.shuffle(cardsBox);
// 3.发牌（剩余3张，作为底牌）
ArrayList p1=new ArrayList();
ArrayList p2=new ArrayList();
ArrayList p3=new ArrayList();
ArrayList ps=new ArrayList();
for (int i = 0; i < cardsBox.size(); i++) {
String s = cardsBox.get(i);
if(i>=51){
ps.add(s);
}else {
if (i%3==0){
p1.add(s);
}else if (i%3==1){
p2.add(s);
}else {
p3.add(s);
}
}
}
// 4.看牌（遍历集合）
System.out.println(p1);
System.out.println(p2);
System.out.println(p3);
System.out.println(ps);
}
小知识点：
Collections（工具类）
方法：
public static shuffle(List<?> list)
使用默认随机源对指定列表进行置换。
标签：style 转换 泛型使用 read 接收 抽象类 icc hash 自动
原文地址：https://www.cnblogs.com/linlin1211/p/10226071.html
