Java Day9 集合

1.
在这里插入图片描述
在这里插入图片描述
2.List(有序集合)
是一个接口,只能用List list = new ArrayList的形式 父类接口创建子类对象
List中的对象可以是重复的,Set的对象不可以重复
使用集合的步骤:
1.创建集合对象
2.创建元素对象
3.将元素对象添加到集合对象中
4.遍历集合
list.add(obj) 向集合添加一个对象
list.get(index) 根据索引值获取集合中的对象
list.size() 获取集合长度

package cn.itcast.demo1;

import java.util.ArrayList;
import java.util.List;

/*
    使用集合的步骤:
        1.创建集合对象
        2.创建元素对象
        3.将元素对象添加到集合对象中
        4.遍历集合
 */
public class Test {
    public static void main(String[] args) {
        //需求:在List集合中添加3个学生对象然后遍历
        List list = new ArrayList();
        Student s1 = new Student("张三",20);
        Student s2 = new Student("李四",30);
        Student s3 = new Student("王五",40);
        Student s4 = new Student("王五",40);
        list.add(s1);
        list.add(s2);
        list.add(s3);
        list.add(s4);
        //直接打印集合
        System.out.println(list);
        //获取索引为2的元素
        //get方法是通过索引来获得对象的
        Object a = list.get(2);  //获取的是一个对象,所以左边要用Object类先创建一个对象
        System.out.println(a);


        for (int i = 0; i < list.size();i++) {
            //Object obj = list.get(i);
            System.out.println(list.get(i));
        }
    }
}

3.增强for循环和迭代器
在这里插入图片描述

package cn.itcast.demo2;

import java.util.ArrayList;
import java.util.List;

/*
       增强for格式:
            for(元素的数据类型 变量名 : 要遍历的集合或数组对象) {
                循环体
            }
       增强for依赖于迭代器
       快捷方式 :iter
       快捷方式 :iter
       快捷方式 :iter
 */
public class Test {
    public static void main(String[] args) {
        //通过增强for循环遍历List集合
        //1.创建集合对象
        List list = new ArrayList();
        //2.创建元素对象
        //3.将元素对象添加到集合对象中
        list.add(10);
        list.add(10);    //表示元素内容可以重复
        list.add(20);
        list.add(30);
        list.add(40);
        list.add(50);
        //遍历
        for (Object obj : list ) {
            //obj是集合中的元素,其本身应该是Integer类型的数据
            //可以强制转换类型来输出Integer形式的数据
            //Integer li = (Integer)obj;
            //System.out.println(li);
            System.out.println(obj);
        }
    }
}

4.迭代器实现对集合的遍历
列表迭代器可以在遍历的同时添加、修改元素

迭代器常用方法:
    1.E next();                 返回迭代的下一个元素对象
    2.bollean  haNext();        如果仍有元素可以迭代,则返回true
    
迭代器使用步骤:
    1.根据集合对象获取对应的迭代器对象
    2.判断迭代器是否有对象
    3.如果有就获取对象
    
总结:
    1.普通的迭代器在遍历时不能添加、删除元素,否则会报,并发修改异常
    2.列表迭代器在遍历时可以修改集合中的元素,的那必须使用列表迭代器中的方法
package cn.itcast.demo3;

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

/*
    迭代器常用方法:
        1.E next();                 返回迭代的下一个元素对象
        2.bollean  haNext();        如果仍有元素可以迭代,则返回true
    迭代器使用步骤:
        1.根据集合对象获取对应的迭代器对象
        2.判断迭代器是否有元素
        3.如果有就获取对象

    总结:
        1.普通的迭代器在遍历时不能添加、删除元素,否则会报,并发修改异常
        2.列表迭代器在遍历时可以修改集合中的元素,的那必须使用列表迭代器中的方法
 */
public class Test {
    public static void main(String[] args) {
        //需求:通过迭代器遍历List集合
        //1.创建集合对象
        List list = new ArrayList();
        //2.创建元素对象
        //3.将元素对象添加到集合对象
        list.add(10);
        list.add(20);
        list.add(30);
        list.add(40);

        //遍历集合
        //1.根据集合对象获取对应的迭代器对象
        //Iterator it = list.iterator();
        //2.判断迭代器是否有对象
        //while (it.hasNext()) {
        //3.如果有就获取对象
            //Integer s = (Integer)it.next();
            //System.out.println(s);
            //System.out.println(it.next());
            //System.out.println(it.hasNext());
        //}

        //需求:判断集合中如果有字符串“b”,就在后米面加一个""java
        Iterator it = list.iterator();
        //2.判断迭代器是否有对象
        while (it.hasNext()) {
        //3.如果有就获取对象
            Integer s = (Integer)it.next();
            if ("b".equals(s)) {  //这种写法是为了规避空指针异常的问题


                list.add("java");  //这样写不可以,会触发并行错误,因为不能对集合一边遍历,一边修改
            }
            System.out.println(s);
        }
    }
}

package cn.itcast.demo3;

import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;

public class Test1 {
    public static void main(String[] args) {
        //需求:测试列表迭代器
        //需求:通过迭代器遍历List集合
        //1.创建集合对象
        List list = new ArrayList();
        //2.创建元素对象
        //3.将元素对象添加到集合对象
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        //需求:判断集合中如果有字符串“b”,就在后米面加一个""java
        //1.根据集合对象获取对应的列表迭代器对象
        ListIterator lit = list.listIterator();
        //2.判断迭代器是否有对象
        while (lit.hasNext()) {
            //3.如果有就获取对象
            String s1 = (String)lit.next();
            if ("b".equals(s1)) {
                //list.add("java");   这样写是不可以的,必须调用列表迭代器
                lit.add("java");
            }
            System.out.println(s1);
        }
        System.out.println(list);
    }
}

5.泛型
只存储指定类型的元素
List list = new ArrayList<>();

package cn.itcast.demo4;

import java.util.ArrayList;
import java.util.List;

//泛型好处:类型安全(写其它类型的会直接报错)、避免了类型转换
public class Test {
    public static void main(String[] args) {
        List<String> list = new ArrayList();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        //list.add(10);   //会直接报错

        //遍历
        //增强for循环
        for (String s : list) {
            System.out.println(s);
        }
    }
}

6.Collections工具类

package cn.itcast.demo5;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

/*
    Collections概述:
        针对集合进行操作的工具类。
    成员方法
        max(Collection<T>);         返回集合的最大元素
        sort(List<T>):              根据元素的自然顺序,将指定列表按升序排序
        reverse(List<T);            反转List築合元素
        shuffle(List<D);            使用默认的随机源随机置换指定的列表

 */
public class Test {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(10);
        list.add(40);
        list.add(50);
        list.add(20);
        list.add(40);
        for (Integer i : list) {
            System.out.println(i);
        }

        Integer max = Collections.max(list);
        System.out.println(max);

        Collections.sort(list);
        System.out.println(list);

        Collections.reverse(list);
        System.out.println(list);

        Collections.shuffle(list);
        System.out.println(list);
    }
}

7.Set集合
不可重复 子类对象为HashSet

package cn.itcast.demo6;

import java.util.Objects;

public class Student {
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age && Objects.equals(name, student.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

package cn.itcast.demo6;

import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

/*
    set集合的特点:无序(元素存取顺序不一致)、唯一性
    Set集合保证元素的唯一性依赖: equals() 和 hashCode()两个方法
 */
public class Test {
    public static void main(String[] args) {
        //需求:往set集合里添加5个学生对象
        //1.创建Set集合对象
        Set<Student> set = new HashSet<>();//注意记得用泛型  里面的类型用Student

        //2.创建元素对象
        Student s1 = new Student("张三",10);
        Student s2 = new Student("李四",20);
        Student s3 = new Student("李四",20);
        Student s4 = new Student("王五",30);

        //3.向集合添加元素对象
        set.add(s1);
        set.add(s2);
        set.add(s3);
        set.add(s4);

        //4.集合遍历
        /*
            为什么Set集合没有“去重”?
                因为Set集合保证元素的唯一性依赖: equals() 和 hashCode()两个方法
                因为没有在Student类中重写这两个方法,默认调用的是0bject类中的这两个方法
                而0bject类中的equals()方法默认比较的是地址值是否相同

         */
        System.out.println(set);
        //通过迭代器遍历
        Iterator<Student> iterator = set.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
        //通过增强for循环遍历
        for (Student stu : set) {
            System.out.println(stu);
        }
    }
}

8.Map集合
双列集合,元素由键值对构成

package cn.itcast.demo7;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

/*
    遍历步骤:
        1.获取所有键的集合,                 keySet()
        2.遍历所有的键,获取到每一个键.        迭代器,增强for.
        3.根据鍵,获取指定的值。              get(); .

 */
public class Test {
    public static void main(String[] args) {
        //需求:向Map集合中添加三个元素,并遍历打印
        //1.创建集合对象
        Map<Integer,Student> map = new HashMap();

        //2.创建元素对象
        Student s1 = new Student("张三",10);
        Student s2 = new Student("李四",20);
        Student s3 = new Student("王五",30);

        //3.将元素对象添加到set集合
        map.put(1,s1);
        map.put(3,s2);
        map.put(2,s3);
        System.out.println(map);
        //根据键,获取值
        System.out.println(map.get(2));

        //4.遍历集合
     /*  //4.1.获取所有键的集合,                 keySet()
        Set<Integer> keys = map.keySet();
        //4.2.遍历所有的键,获取到每一个键.        迭代器,增强for.
        //获取迭代器对象
        Iterator<Integer> iterator = keys.iterator();
        //判断是否还有元素(这里指的是键值)
        while (iterator.hasNext()) {
            //先获取key
            //System.out.println(map.get(iterator.next()));
            Integer key = iterator.next();
            //4.3.根据鍵,获取指定的值。              get();
            //用get方法通过key获取value值
            Student value = map.get(key);
            //输出value
            System.out.println(value);
        }*/


        //增强for实现
        //获取所有的键
        Set<Integer> it = map.keySet();
        for (Integer key : it) {
            //key就是双列集合的每一个键
            //System.out.println(map.get(key));
            Student value = map.get(key);
            System.out.println(value);

        }

    }
}

9.集合实例–斗地主

package cn.itcast.demo8;

import java.util.*;

public class SendPokerTest {
    public static void main(String[] args) {
        //1.买牌
        //1.1 定义一个双列集合,键:牌的编号;值:具体的牌:   规则:编号越小,牌越小
        Map<Integer, String> pokers = new HashMap<>();
        //1.2 定义一个单列集合,存储牌的编号
        List<Integer> list = new ArrayList();
        //1.3 具体的买牌动作
        //普通牌,52
        String[] numbers = {"3","4","5","6","7","8","9","10","J","Q","K","A","2"};
        String[] colors = {"♦","♣","♥","♠"};
        int num = 0;
        //通过循环嵌套 造普通牌
        for (String number : numbers) {
            for (String color : colors) {
                String poker = color + number;
                //System.out.println(poker);
                //将牌的编号、具体的牌放到双列集合中
                pokers.put(num,poker);
                //将牌的编号放到单列集合中
                list.add(num);
                //每添加一张牌,编号自增1
                num++;
            }
        }
        //大小王
        pokers.put(num,"大王");
        list.add(num++);
        pokers.put(num,"小王");
        list.add(num);

        //打印牌
        System.out.println(pokers);
        System.out.println(list);
        /*直接用两个for循环的方法尝试
        for (int i =0; i < 13; i++) {
            for (int j = 0; j < 4; j++) {
                colors[i].concat(num[j]);
            }
        }*/



        //2.洗牌
        Collections.shuffle(list);
        System.out.println("牌的编号" + list);

        //3.发牌
        //3.1 新建3个集合和一个底牌集合
        List<Integer> A = new ArrayList<>();
        List<Integer> B = new ArrayList<>();
        List<Integer> C = new ArrayList<>();
        List<Integer> D = new ArrayList<>();
        //3.2 按照模进行分类
        for (int i = 0; i < list.size(); i++) {
            Integer integer = list.get(i);
            if (i >= list.size() - 3) {
                D.add(integer);
            } else if (i % 3 == 0) {
                A.add(integer);
            } else if (i % 3 == 1) {
                B.add(integer);
            } else if (i % 3 == 2) {
                C.add(integer);
            }
        }
        //3.3 遍历4个集合
        System.out.println(A);
        System.out.println(B);
        System.out.println(C);
        System.out.println(D);


        System.out.println(printPoker(A,pokers));
        System.out.println(printPoker(B,pokers));
        System.out.println(printPoker(C,pokers));
        System.out.println(printPoker(D,pokers));
    }

    //4.看牌
    //4.1 创建一个看牌方法
    public static String printPoker(List<Integer> num, Map<Integer,String> pokers) {
        Collections.sort(num);
        StringBuilder sb = new StringBuilder();
        for (Integer nums : num) {
            String poker = pokers.get(nums);
            sb.append(poker + " ");
        }
        //将拼接结果返回
        String str = sb.toString();
        return str.trim();

    }
}

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值