@TOC# 集合-
第一章、集合框架介绍:
1、学习集合的目标:
1.会使用集合存储数据
2.会遍历集合,把数据提取出来
3.掌握每种集合的特性
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QSDGOIAO-1668256169872)(C:\Users\27343\AppData\Roaming\Typora\typora-user-images\image-20221108202834175.png)]
2、集合常用功能:
import java.util.ArrayList;
import java.util.Collection;
//Collection 接口 顶层集合!!
/* collection的一些方法 :
public boolean add();
public boolean isEmpty();
public boolean contains();
public boolean remove();
public void clear();
public int size();
*/
public class JiHe {
public static void main(String[] args) {
Collection<String> c=new ArrayList<>();
c.add("张三");
c.add("李四");
c.add("王五");
System.out.println(c);
//c.clear();//清空集合内所有元素
//System.out.println(c);
boolean flag =c.contains("张三");
System.out.println(flag);
c.remove("张三");
System.out.println(c);
Object[] objs=c.toArray();
System.out.println(objs);
for (int i = 0; i <objs.length; i++) {
System.out.println(objs[i]);
}
int size= c.size();
System.out.println(size);
}
}
第二章、 Iterator(接口)迭代器
1.1、迭代器
迭代器:是通用的取出集合中元素的方式。在取元素之前我们要判断集合中是否有元素存在(hasNext()),如果有则取出(Next()),继续再判断,如果还有就再取出来,一直到把集合中所有元素取出,这种取出方式的专业术语叫做迭代!
-
可以对集合进行遍历。
-
/*Iterator 接口:迭代器 可以对集合进行遍历! 有两个常用的方法: boolean hasNext() 如果仍有元素可以迭代,则输出true;判断集合中是否有下一个元素,有就返回true, 没有就返回false; E Next():返回迭代的下一个元素。去除集合中的下一个元素; Iterator迭代器,是一个接口,我们无法直接使用,需要使用Iterator接口的实现类对象 获取实现类的方式比较特殊! Collection接口中有一个方法叫做iterator() ,这个方法返回的就是实现类的对象! Iterator<> iterator () 返回在此collection元素上进行迭代的迭代器! 使用步骤: 1.使用iterator()方法来获取迭代器的实例化对象,使用Iterator接口接收(多态); 2.使用Iterator中的方法hasNext()来判断还有没有下一个元素; 3.使用next()方法来取出集合中的下一个元素。 */ public class IteratorDemo { public static void main(String[] args) { Collection<String> coll=new ArrayList<>();//创建集合对象 coll.add("阿迪"); coll.add("阿玛尼"); coll.add("耐克"); coll.add("北面"); coll.add("乔丹"); System.out.println(coll); Iterator<String> it= coll.iterator();//import java.util.Iterator; boolean b= it.hasNext(); System.out.println(b); /*在这里用next方法来取出集合中的元素时,发现有重复过程 要进行while循环优化,因为不确定有多少元素,所以用while,否则用for循环。 循环结束的条件是 hasNext()=false; */ while (it.hasNext()==true){ String n=it.next(); System.out.println(n); } } }
2.2 迭代器的实现原理
2.3、for循环增强
是jDK1.5出来以后的高级for循环,专门用来遍历数组和集合的!他的内部原理其实是个Iterator迭代器,所以不能直接对集合中的元素直接进行操作!
public class forDemo {
public static void main(String[] args) {
method01();
// method02();
}
//遍历数组
private static void method01(){
int arr[]={12,34,32};
for (int a:arr) {
System.out.println(a);
}
}
//遍历集合
private static void method02(){
ArrayList<String> ar=new ArrayList<>();
ar.add("中国");
ar.add("日本");
ar.add("法国");
Iterator<String> it=ar.iterator();
for (String r:ar){
System.out.println(r);
}
}
}
第三章、泛型
在我们学习集合时,都知道集合中可以存放任意的对象,但是只要把对象存储集合后,这时他们都被提升为object类型,当我们再取出每一个对象,并进行相应的操作,就需要类型转换!
3.1、泛型的概念
当我们不知道使用什么数据类型时就可以用泛型,泛型也可以看出是一个变量,用来接收数据类型,
E e:element元素
T t: Type类型
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wh4CHHBi-1668256169874)(C:\Users\27343\AppData\Roaming\Typora\typora-user-images\image-20221110134454054.png)]
ArrayList 集合创建对象的时候就会确定泛型的数据类型:
ArrayList<String> arr=new ArrayList();
3.2、使用泛型的好处
public class GenericDemo {
public static void main(String[] args) {
show02();
}
private static void show01(){
//创建一个集合对象,不使用泛型!
ArrayList arr=new ArrayList();
arr.add("abc");
arr.add(2);
//使用Iterator遍历!
Iterator it=arr.iterator();
while (it.hasNext()){
Object obj=it.next();
System.out.println(obj);
/*如果我们想用String的特有方法 length来获取字符串的长度 不能使用! 多态
需要向下转型
异常:ClassCastException:类型转换异常 不能把int类型转换成String类型!
*/
String s=(String) obj;
System.out.println(s.length());
}
}
/*
使用泛型! 好处:
1.不用进行类型转换,存储的什么类型,取出就是什么类型!
2.不会出现编译器异常!
弊端:
就是泛型是什么类型,就只能存储什么类型!
*/
private static void show02(){
ArrayList<String> arr2 =new ArrayList<>();
arr2.add("中国");
arr2.add("日本");
arr2.add("法国");
Iterator<String> it=arr2.iterator();
while (it.hasNext()){
String s=it.next();
System.out.println(s);
System.out.println(s.length());
}
}
}
3.3、泛型的定义与使用
定义格式:
修饰符 class 类名 <代表泛型的变量> {}
/*
定义一个含有泛型的类,来模拟ArrayList集合
泛型是一个未知的数据类型,当我们不确定是一个什么数据类型的时候可以使用泛型
创建对象的时候来确定使用什么数据类型!
*/
public class GenericClass<E> {
private E name;
private E age;
public E getAge() {
return age;
}
public void setAge(E age) {
this.age = age;
}
public E getName() {
return name;
}
public void setName(E name) {
this.name=name;
}
}
public class DemoGenericClass {
public static void main(String[] args) {
method02();
}
//创建一个GenericClass对象,泛型使用String类型
private static void method01(){
GenericClass<String> gc = new GenericClass<>();
gc.setName("dong东");
String n = gc.getName();
System.out.println(n);
}
//创建一个GenericClass对象,泛型使用int类型
private static void method02(){
GenericClass<Integer> gc2=new GenericClass<>();
gc2.setAge(21);
int age=gc2.getAge();
System.out.println(age);
}
}
3.4、泛型的使用方法(1)
/*
在方法里使用泛型,泛型定义在修饰符与返回值之间
格式:
修饰符<泛型> 返回值 方法名(使用泛型){
方法体;
}
*/
public class GenericMethod {
public <M> void method01(M m) {
System.out.println(m);
}
//静态方法:
public static<S> void method02(S s){
System.out.println(s);
}
}
public class DemoGenericMethod {
public static void main(String[] args) {
//创建一个GenericMethod对象
GenericMethod gm=new GenericMethod();
gm.method01("name");
gm.method01("age");
gm.method01(12);
gm.method01(12.23);
gm.method02("静态方法,不建议使用");
}
}
3.5、定义泛型的接口
*
定义含有泛型的接口
*/
public interface GenericInterface<E> {
public abstract void method(E e);
}
第一种使用方式:
/*
含有泛型的接口,第一种使用方式:定义接口的实现类,实现接口,指定接口的泛型
*/
public class GenericInterfaceimpl1 implements GenericInterface<String> {
@Override
public void method(String s) {
System.out.println(s);
}
}
第二种使用方式:
/*
第二种使用方式:接口使用什么泛型,实现类就使用什么泛型,类跟着接口走
就相当于定义了一个含有泛型的类,创建对象的时候确定泛型。
public interface List<E>{
boolean add(E e);
*/
public class GenericInterfaceImpl2<E> implements GenericInterface<E>{
@Override
public void method(E e) {
System.out.println(e);
}
}
测试类:
//测试类
public class DemoGenericInteerface {
public static void main(String[] args) {
GenericInterfaceimpl1 gi1=new GenericInterfaceimpl1();
gi1.method("中国");
//gi1.method(123);//报错
gi1.method("法国");
GenericInterfaceImpl2<String> gi2=new GenericInterfaceImpl2();
// gi2.method(123);//报错!
gi2.method("刘振东");
}
}
3.6、泛型的通配符?
/*
泛型通配符:? 当不知道用什么类型时,就用?
*/
public class Demo02Generic {
public static void main(String[] args) {
ArrayList<Integer> list=new ArrayList();
list.add(12);
list.add(34);
ArrayList<String> list1=new ArrayList<>();
list1.add("东东");
list1.add("冬冬");
printArray(list1);
printArray(list);
} /*需求: 定义一个方法来遍历所有类型的ArrayList集合元素!
这时我们不知道ArrayList使用的什么数据类型,我们可以使用通配符?来接收数据类型
注意:
泛型是没有继承概念的!
*/
public static void printArray(ArrayList<?> list){
Iterator<?> it1=list.iterator();
while (it1.hasNext()){
//it.next()方法取出的是Object()类型,因为只有object可以接收任意类型!
Object o = it1.next();
System.out.println(o);
}
}
}
3.7、通配符的高级使用
/*
泛型通配符:? 当不知道用什么类型时,就用?
*/
public class Demo02Generic {
public static void main(String[] args) {
ArrayList<Integer> list=new ArrayList();
list.add(12);
list.add(34);
ArrayList<String> list1=new ArrayList<>();
list1.add("东东");
list1.add("冬冬");
printArray(list1);
printArray(list);
} /*需求: 定义一个方法来遍历所有类型的ArrayList集合元素!
这时我们不知道ArrayList使用的什么数据类型,我们可以使用通配符?来接收数据类型
注意:
泛型是没有继承概念的!
*/
public static void printArray(ArrayList<?> list){
Iterator<?> it1=list.iterator();
while (it1.hasNext()){
//it.next()方法取出的是Object()类型,因为只有object可以接收任意类型!
Object o = it1.next();
System.out.println(o);
}
}
}
集合----斗地主综合案例
需求分析
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Qn9gJgjh-1668256169875)(C:\Users\27343\AppData\Roaming\Typora\typora-user-images\image-20221112111158924.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-059Uv9vn-1668256169876)(C:\Users\27343\AppData\Roaming\Typora\typora-user-images\image-20221112111650153.png)]
代码实现
/*
斗地主综合案例:
1.准备牌
2.发牌
3.看牌
*/
public class doudz {
public static void main(String[] args) {
//创建一个集合对象
ArrayList<String> arr=new ArrayList<>();
//创建两个数组,来分别放牌和花色!
String[] ar1={"3","4","5","6","7","8","9","10","J","Q","K","A","2"};
String[] ar2={"♦","♠","♥","♣"};
//先把大王,小王来存到集合arr中
arr.add("大王");
arr.add("小王");
//循环遍历两个数组,组装两个数组!
for( String s1:ar1){
for( String s2:ar2){
System.out.println(s2+s1);
arr.add(s2+s1);
}
}
System.out.println(arr);
//发牌!
Collections.shuffle(arr);//打乱牌的顺序,来随机发牌!
System.out.println(arr);
String player1=("玩家1");
String player2="玩家2";
String player3="玩家3";
String bt="底牌";
//定义四个集合来存储玩家的牌和底牌!
ArrayList<String> player01=new ArrayList<>();
ArrayList<String> player02=new ArrayList<>();
ArrayList<String> player03=new ArrayList<>();
ArrayList<String> bottom=new ArrayList<>();
//发牌
for (int i = 0; i<arr.size() ; i++) {
//获取每一张牌
String pk = arr.get(i);
if (i%3==0&&i<51){
player01.add(pk);
}else if (i%3==1&&i<51){
player02.add(pk);
}else if (i%3==2&&i<51){
player03.add(pk);
}else if (i>=51){
bottom.add(pk);
}
}
//看牌
System.out.println(player1+player01);
System.out.println(player2+player02);
System.out.println(player3+player03);
System.out.println(bt+bottom);
}
}