0
点赞
收藏
分享

微信扫一扫

java-集合（day16巩固）

天天天蓝loveyou 2022-02-14 阅读 68
java开发语言

集合

一.集合和数组的对比

1.数组长度是不可变的，集合长度是可以变的
2.数组可以存储基本数据类型和引用数据类型  集合只能存储引用数据类型（可以存储基本数据类型
		 的包装类）

二.集合体系结构

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-C3z5fvIT-1644840054304)(C:/Users/%E6%82%B2%E9%99%8C/AppData/Roaming/Typora/typora-user-images/image-20220212145701406.png)]

list和set集合：
	list集合里面的元素可以重复，set不能存储重复的集合

二.案例：

使用集合存储字符串：a,b,b,c 遍历删除集合里面的b元素

分析：

使用ArrayList来进行存储，然后使用迭代器来进行遍历

代码：

package com.qf.lt.oop09;

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

public class Test {
    public static void main(String[] args) {
        //创建一个集合，存储元素：a b b c ； 使用迭代器遍历，删除元素b
        ArrayList<String> list = new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("b");
        list.add("c");
        System.out.println(list);
        //使用迭代器来进行遍历
        Iterator<String> iter = list.iterator();
        //使用while来进行遍历
        while(iter.hasNext()){
            //发现删除不干净，因为在删除第一个b元素的时候，集合的长度自动变化了，变短了，
            // 所以删除连续相同的元素的时候删除不干净
            //解决办法：使用迭代器的remove方法就可以删除干净
            if ("b".equals(iter.next())){
                //使用集合的移除方法,删除不干净
                //list.remove(iter.next());
                //使用迭代器的删除方法
                iter.remove();
            }
        }
        System.out.println(list);

    }

}

结果：

使用集合的删除方法：

​ [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vV8AKpDs-1644840054305)(C:/Users/%E6%82%B2%E9%99%8C/AppData/Roaming/Typora/typora-user-images/image-20220212155430075.png)]

使用迭代器的删除方法：

​ [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-S10dQoEg-1644840054306)(C:/Users/%E6%82%B2%E9%99%8C/AppData/Roaming/Typora/typora-user-images/image-20220212155457291.png)]

注意点；单列集合可以直接使用迭代器，双列集合不能直接使用迭代器

三.小技巧：

//增强for循环的小技巧：集合名.for+回车 -->可以快速构造增强for循环
      /*  for (String s : list) {

        }*/

四.集合三种循环使用场景

需要操作索引，使用普通for循环
如果在遍历过程里面需要删除元素，使用迭代器
仅仅是遍历集合的话使用增强for循环

五.案例：collection集合存储学生对象

step01 需求：创建一个collection集合来存储三个学生对象，然后使用遍历打印学生对象

step02 分析：

	创建一个学生类，
	创建collection集合对象
	创建学生对象
    把学生添加到集合里面
    遍历集合（迭代器）

代码：

package com.qf.lt.oop10;

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

public class Test {
    public static void main(String[] args) {
        //ArrayList集合的泛型是student
        ArrayList<Student>  list = new ArrayList<>();

        Student stu1 = new Student("张三",12);
        Student stu2 = new Student("李四",25);
        Student stu3 = new Student("王五",19);

        list.add(stu1);
        list.add(stu2);
        list.add(stu3);

        //使用迭代器遍历
        Iterator<Student> it = list.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }

System.out.println("************************");

        //使用增强for循环
        for (Student st : list) {
            System.out.println(st);
        }
    }
}

注意点：

package lq.lt.oop01;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;

public class Test {
    public static void main(String[] args) {
        //创建集合
        Collection list1 = new ArrayList();
        Collection list2 = new ArrayList();
        // boolean add(Object obj)      | 添加一个对象数据
        method1(list1);

        // boolean addAll(Collection c) | 将一个集合中的所有对象添加到此集合中
        method2(list1, list2);

        // void clear()                 | 清空此集合中的所有对象
        method3(list2);

        // boolean contains(Object o)   | 检查此集合中是否包含o对象
        method4(list1);

        // boolean equals(Object o)     | 比较此集合是否与指定对象相等
        method5(list1);

        // boolean isEmpty()            | 判断此集合是否为空
        method6(list1, list2);

        // boolean remove(Object o)     | 在此集合中移除o对象
        method7(list1);

        // int size()                   | 返回此集合中的元素个数
        method8(list1);

        // Object[] toArray()           | 将此集合转换成数组
        method9(list1);

    }

    private static void method9(Collection list1) {
        Object[] ary = list1.toArray();
        //注意数组不能直接打印，需要转换
        System.out.println(Arrays.toString(ary));
    }

    private static void method8(Collection list1) {
        System.out.println(list1.size());
    }

    private static void method7(Collection list1) {
        list1.remove("bbb");
        System.out.println(list1);
    }

    private static void method6(Collection list1, Collection list2) {
        boolean flag = list2.isEmpty();
        boolean flag1=list1.isEmpty();

        System.out.println(flag);
        System.out.println(flag1);
    }

    private static void method5(Collection list1) {
        boolean flag = list1.equals("aaa");
        boolean flag1 = list1.equals("aaa");

        System.out.println(flag);
    }

    private static void method4(Collection list1) {
        boolean flag=list1.contains("bbb");
        boolean flag1=list1.contains("ddd");
        System.out.println(flag);
        System.out.println(flag1);
    }

    private static void method3(Collection list2) {
        list2.clear();
        System.out.println(list2);
    }

    private static void method2(Collection list1, Collection list2) {
        list2.addAll(list1);
        System.out.println(list2);
    }

    private static void method1(Collection list1) {
        //添加元素
        list1.add("aaa");
        list1.add("bbb");
        list1.add("cccc");
        //打印集合
        System.out.println(list1);
    }
}

应用：

package lq.lt.oop01;

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

public class Test01 {
    public static void main(String[] args) {
        //实例化集合
        List list = new ArrayList();
        list.add("a");
        list.add("b");
        list.add("c");
        //void add(int index, Object o)            | 在index位置插入对象o。
        method1(list);

        //boolean addAll(int index, Collection c)  | 将一个集合中的元素添加到此集合中的index位置。
        method2(list);
        //Object get(int index)                    | 返回集合中指定位置的元素。
        System.out.println(list.get(4));
        //List subList(int fromIndex, int toIndex) | 返回fromIndex和toIndex之间的集合元素。
        //注意：返回的还是一个集合，可以再使用一个集合来进行接受
        method3(list);
    }

    private static void method3(List list) {
        List li = list.subList(1, 6);
        System.out.println(li);
        //使用增强for循环遍历
        for (Object obj : li) {
            System.out.println(obj);
        }
    }

    private static void method2(List list) {
        List list1 = new ArrayList();
        list1.add("1");
        list1.add("2");
        list1.add("3");
        list.addAll(2,list1);
        System.out.println(list);
    }

    private static void method1(List list) {
        System.out.println(list);
        list.add(1,"d");
        System.out.println(list);

    }
}

集合遍历：

package lq.lt.oop01;

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

public class Test02 {
    public static void main(String[] args) {
        List list = new ArrayList();
        //集合来存储对象时
        list.add(new Student("张三",12));
        list.add(new Student("李四",5));
        list.add(new Student("王五",22));
//        System.out.println(list);
        //使用普通for循环，需要把集合使用toString()方法转换成数组
        method01(list);

        System.out.println("*************************************");

        //使用迭代器,如果集合存储的是对象，在遍历的时候需要将集合拿到的对象强制转换成对像类型
        //需要拿到集合里面的数据，使用迭代器
        method02(list);

        System.out.println("*************************************");

        //使用增强for循环,只是单纯的需要遍历，使用增强for循环遍历，
        method03(list);

        System.out.println(list.contains(new Student("张三",12)));
    }

    private static void method03(List list) {
        for (Object obj : list) {
            System.out.println(obj);
        }
    }

    private static void method02(List list) {
        Iterator iter = list.iterator();
        while (iter.hasNext()){
            Student stu = (Student)iter.next();
            System.out.println(stu.toString());
            //获取对象的属性
//            System.out.println(stu.getName());
        }
    }

    private static void method01(List list) {
        Object[] arr = list.toArray();
        for (int i =0;i<arr.length;i++){
            //把数组强制转换成字符串
            Student st = (Student)arr[i];
            System.out.println(st);
        }
    }
}

七.LinkedList集合

package lq.lt.oop02;

import java.util.LinkedList;

public class Test01 {
    public static void main(String[] args) {
        //创建LinkedList集合
        LinkedList list = new LinkedList();
        list.add(new Student("张三",15));
        list.add(new Student("李四",35));
        list.add(new Student("王五",23));

        System.out.println(list);

        //使用普通for循环，集合转换为数组来进行遍历
        method01(list);

        System.out.println("***************************************************");
        //使用for循环，直接遍历集合
        method02(list);
    }

    private static void method02(LinkedList list) {
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
    }

    private static void method01(LinkedList list) {
        Object[] obj = list.toArray();
        for (int i = 0; i < obj.length; i++) {
            System.out.println(obj[i]);
        }
    }
}

八.ArrayList集合和LinkedList集合的区别：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xVDu0dut-1644840054307)(C:/Users/%E6%82%B2%E9%99%8C/AppData/Roaming/Typora/typora-user-images/image-20220214145014634.png)]

九.泛型

1.概念：泛型是jdk1.5之后引入的一个新特性，其本质是参数化数据类型，把类型作为参数传递
2.类型：泛型类，泛型方法，泛型接口
3.语法：<T> 表示数据类型占位符，表示一种引用数据类型
4.优点：
		A.提高代码的重用性
		B.防止数据类型转换异常，提高代码安全性
5.特点：泛型只能是引用数据类型

十.Collections工具类

package lq.lt.oop04;

import java.util.Collections;
import java.util.LinkedList;
import java.util.List;

public class Test {
    public static void main(String[] args) {
        List<Integer> iter = new LinkedList<>();
        iter.add(10);
        iter.add(30);
        iter.add(40);
        iter.add(260);
        iter.add(50);
        iter.add(42);

        System.out.println("原数据："+iter);

      //public static void reverse(List<?> list) 反转集合中元素的顺序
        Collections.reverse(iter);
        System.out.println("反转集合："+iter);

      // public static void shuffle(List<?> list) 随机重置集合元素的顺序
        Collections.shuffle(iter);
        System.out.println("打乱顺序后的集合："+iter);

      // public static void sort(List<T> list) 升序排序（元素类型必须实现Comparable接口）
        Collections.sort(iter);
        System.out.println("升序后的集合:"+iter);

      //public static <T> int binarySearch( list, T key) 二分查找 查找到元素的位置
        Integer temp = Collections.binarySearch(iter,50);
        System.out.println(temp);
    }
}

十一.Set集合

1.HashSet集合
1.基于Hashcode实现元素不重复

package lq.lt.oop05;

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

public class Test {
    public static void main(String[] args) {
        //Map集合
        Map<String,String> map = new HashMap<>();

        //Map集合赋值
        map.put("张三","男");
        map.put("李四","男");
        map.put("赵六","女");
        map.put("王二","男");

        System.out.println("原始集合："+map);

        //boolean containsKey(Object key)集合中是否包含指定的key
        System.out.println(map.containsKey("王二"));

        //Set<Map.Entry<K,V>> entrySet()用于来遍历map集合
        Set<Map.Entry<String, String>> entrySet = map.entrySet();
        for (Map.Entry<String, String> mapE : entrySet) {
            System.out.println(mapE);
        }

        //V get(Object key)通过键获取值
        System.out.println(map.get("赵六"));

        //boolean isEmpty()判断集合是否为空
        System.out.println(map.isEmpty());

        //Set keySet()获取map集合中所有的key
        Set<Map.Entry<String, String>> set = map.entrySet();
        for (Map.Entry<String, String> stringStringEntry : set) {
            System.out.println(stringStringEntry.getKey());
        }

        //Collection values()获取Map集合中所有的值
        Set<Map.Entry<String, String>> set02 = map.entrySet();
        for (Map.Entry<String, String> str : set) {
            System.out.println(str.getValue());
        }

        //int size()获取集合的长度
        System.out.println(map.size());

        //V remove(Object key)根据key删除整个键值对
        map.remove("李四");
        System.out.println(map);

        //V put(K key, V value)如果key不存在则执行添加,如果key存在则修改value
        map.put("张三","女");
        System.out.println(map);

        //void clear()删除map集合中所有的元素
        map.clear();
        System.out.println(map.isEmpty());
    }
}
2.HashMap的第一种遍历方式
package lq.lt.oop05;

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

public class Test01 {
    public static void main(String[] args) {
        //Map集合
        Map<String,String> map = new HashMap<>();

        //Map集合赋值
        map.put("张三","男");
        map.put("李四","男");
        map.put("赵六","女");
        map.put("王二","男");

        System.out.println("原始集合："+map);

        //使用增强for循环
        method01(map);

        System.out.println("*********************************************");
        //使用迭代器循环
        method02(map);

        
    }

    private static void method02(Map<String, String> map) {
        Set<Map.Entry<String, String>> set02 = map.entrySet();
        Iterator<Map.Entry<String, String>> iterator = set02.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }

    private static void method01(Map<String, String> map) {
        Set<Map.Entry<String, String>> set = map.entrySet();
        for (Map.Entry<String, String> entry : set) {
            System.out.println(entry);
        }
    }
}
3.Hash Map的第二种遍历方式
package lq.lt.oop05;

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

public class Test02 {
    public static void main(String[] args) {
        //Map集合
        Map<String,String> map = new HashMap<>();

        //Map集合赋值
        map.put("张三","男");
        map.put("李四","男");
        map.put("赵六","女");
        map.put("王二","男");

        System.out.println("原始集合："+map);

       //通过map.keyset来获取key值和value值
        for (String s : map.keySet()) {
            System.out.println(s+"\t"+map.get(s));
        }

        //遍历获取value值
        for (String s1: map.values()){
            System.out.println(s1);
        }
    }
}

十二.斗地主

step01 需求：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wRingy4W-1644840054308)(E:/%E8%87%AA%E5%B7%B1%E7%AC%94%E8%AE%B0/Web%E5%89%8D%E7%AB%AF%E5%AD%A6%E4%B9%A0%E7%AC%94%E8%AE%B0/image-20220214172953047.png)]

step02 分析：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wSd4xrRH-1644840054309)(E:/%E8%87%AA%E5%B7%B1%E7%AC%94%E8%AE%B0/Web%E5%89%8D%E7%AB%AF%E5%AD%A6%E4%B9%A0%E7%AC%94%E8%AE%B0/image-20220214173525709.png)]

step03 代码：

package lq.lt.oop05;

import java.util.*;

public class Test04 {
    public static void main(String[] args) {

        Map<Integer,String>  map= new HashMap<>();


        String[] colors = {"♦","♣","♥","♠"};
        String[] nums={"3","4","5","6","7","8","9","10","J","Q","K","A","2"};

        //遍历生成52张牌
        //使用一个数来代替索引
        Integer temp = 1;
        for (int i=0;i<nums.length;i++){
            for (int j=0;j<colors.length;j++){
                map.put(temp,colors[j]+nums[i]);
                temp++;
            }
        }

        //生成大小王
        map.put(53,"小王");
        map.put(54,"大王");
        /*System.out.println(map);*/

        //因为LinkedList集合可以重置集合的索引，所以使用这个集合来进行洗牌
        List list=new LinkedList();
        for (int i=1;i<55;i++){
            list.add(i);
        }
        /*System.out.println(list);*/

        //洗牌,使用集合的工具类的shuffle方法
        Collections.shuffle(list);
       /* System.out.println("洗牌后的集合："+list);*/

        List li01 = new ArrayList();
        List li02 = new ArrayList();
        List li03 = new ArrayList();
        List li04 = new ArrayList();

        //发牌
        for(int i=0;i<list.size()-3;i++){
            if (i%3==0){
                li01.add(list.get(i));
            }else if (i%3==1){
                li02.add(list.get(i));
            }else {
                li03.add(list.get(i));
            }
        }
        //拿取底牌
        li04.add(list.get(51));
        li04.add(list.get(52));
        li04.add(list.get(53));

        //打印牌的索引
        Collections.sort(li01);
        Collections.sort(li02);
        Collections.sort(li03);
        /*System.out.println("华仔："+li01);
        System.out.println("星仔："+li02);
        System.out.println("赌神："+li03);
        System.out.println("底牌："+li04);*/

        //根据索引看牌，定义一个看牌的方法
        //华仔
        System.out.print("华仔：");
        lookBoard(map, li01);
        
        //星仔
        System.out.print("星仔：");
        lookBoard(map, li02);

        //赌神
        System.out.print("赌神：");
        lookBoard(map, li03);

        //底牌
        System.out.print("底牌：");
        lookBoard(map,li04);
    }

    //看牌的方法
    private static void lookBoard(Map<Integer, String> map, List l) {
        //System.out.print("赌神:");
        Object[] array3 = l.toArray();
        for (int i=0;i<array3.length;i++){
            System.out.print(map.get(array3[i])+"\t");
        }
        System.out.println();
    }
}

总结：

1.使用collections集合的工具类升序：
	collections.sort（集合名）
2.集合工具类的shuffle()方法可以打乱LindekList集合的里面元素的索引，所以需要使用这个集合来进行洗牌
	collections.shuffle(集合名)
3.在看牌的时候，使用方法，这样可以避免重复看牌的代码
举报

相关推荐

Day16

java

Day16（Java的方法）

javaintellij-idea开发语言

寒假Java学习Day16：

java开发语言后端

架构（day16）

phpnginx数据库Linux系统/运维

Learn Java step by step day16

java

Python版day16

tcp/ip桥接模式vim

【English Learning】Day16

计算机视觉人工智能图像处理模糊处理Python

LeetCode刷题day16

leetcode深度优先算法子节点递归编程语言

day16 初始面向对象

正则表达式

LeetCode75——Day16

vue.js前端elementui
0 条评论