集合-java(2)

最新推荐文章于 2024-06-30 20:23:11 发布

weixin_47744616

最新推荐文章于 2024-06-30 20:23:11 发布

阅读量251

点赞数

文章标签： java 开发语言后端

本文链接：https://blog.csdn.net/weixin_47744616/article/details/122347442

版权

set集合

set集合里面不包含重复的元素 ,set集合对迭代顺序不保证所以普通for循环不能满足他

set输出的东西是无序的

默认不会添加重复的元素

package 集合2;

import java.util.HashSet;

public class Set集合 {
    public static void main(String[] args) {
        HashSet<String> str = new HashSet<>();
        str.add("java");
        str.add("php");
        str.add("js");
        str.add("js2");
        str.add("js4");
        str.add("js");
        for(String item:str){
            System.out.println(item);
        }
    }
}

哈希值

不同字符串会出现不同的哈希值

通过哈希方法的重写我们可以实现不同的字符串相同的哈希值

哈希set集合

它实现的set集合的接口

迭代的顺序不保证

哈希set集合是由哈希表实现的,哈希set 集合里面不能重复的元素

哈希set集合元素唯一的源码分析

1.add() 方法里面调用一些列方法然后调用元素的hashCode方法

2.然后看哈希表哈希表未初始化就对其初始化

3.根据对象的hash值计算存储位置如果空就存储不空就比较他的哈希值

4.如果哈希不同就存储

5.如果哈希相同就比较对象的 equlas() 方法

常见的链式哈希表

哈希标的数组长度默认是16 他是链条式的存储再原位置上先比较哈希值再比较对象的equals方法

再数组中的位置是通过哈希值 %16 得到的数去找数组中对应的位置

常见的LinkedhashSet()

这个哈希链表是由链表式的组成的可以让元素保证有序输出或者有序存储

哈希表也会保证元素的唯一也就是说没有重复的元素

treeSet 集合

根据元素自然排序这里的排序不是指存储和去除的排序而是指的是会按着规则排序具体的排序方法是根据构造方法来的

无参构造根据元素自然排序

有参根据指定的比较器进行排序

重点这个集合没有带索引所以不可以使用普通for循环遍历

由于是 set集合,所以不包含重复的集合

package 集合2;

import java.util.TreeSet;

public class Treeset集合 {
    public static void main(String[] args) {
        TreeSet<String> str = new TreeSet<>();
        str.add("1");
        str.add("2");
        str.add("你好");
        str.add("你好");
        str.add("4");
        str.add("5");
        System.out.println(str);

        //treeset集合 是根据元素的分类 完成存储的
        //是跟句  数字  字母  还是汉字 完成分类的元素排序
    }
}

自然排序按照 1-n 从小到大的排序的方法排序

记住集合里面我们存储的是引用类型如果

我们想存基本类型我们就需要存储 int 的包装类 interger包装类

自然排序规则

//treeset集合 是根据元素的分类 完成存储的
//是跟句  数字  字母  还是汉字 完成分类的元素排序

数字排序是根据先分类型再按着类型的大小进行排序

比如数字类型 1-100 慢慢排序

TreeSet集合存储学生对象

package 集合2;


import java.util.TreeSet;

public class Treeset集合存学生对象 {
    public static void main(String[] args) {


        TreeSet<Student> strs = new TreeSet<Student>();

        Student stu1= new Student("卢贝", 20);
        Student stu2= new Student("魏长瑞", 20);
        Student stu3= new Student("唐三", 20);
        Student stu4= new Student("小舞", 20);

        strs.add(stu1);
        strs.add(stu2);
        strs.add(stu3);
        strs.add(stu4);

        for(Student stu:strs){
            System.out.println(stu);
        }
    }
}

对象再 treeset集合里面 Comparable 比较器自然排序是无法排序的

该接口对实现它的每个类的对象强加一个整体排序。这个排序被称为类的自然排序 ，类的compareTo方法被称为其自然比较方法 。
也就是说那个类想自然排序就要让该类实现这个自然排序的接口
一类的自然排序C被说成是与equals一致 ，当且仅当e1.compareTo(e2) == 0具有相同的布尔值e1.equals(e2) 0返回的就是相同的元素

package 集合2;

import java.util.Objects;

public class Student implements Comparable<Student>{
    String name;
    int age;

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

    public Student() {
    }

    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 boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Student)) return false;
        Student student = (Student) o;
        return age == student.age && Objects.equals(name, student.name);
    }

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

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

    @Override
    public int compareTo(Student o) {

        return this.age - o.age;
    }
}

最后重写的 comparTo 方法按照的是年龄重新写入的所以他的自然排序是按照年龄排序的这个方法返回值是 0 认为他俩相同返回值为正数认为不是重复的排序正序小于0 的是倒叙可以用年龄相减的插值比较

o.age 就是之前有的对象 this 就是之后进来的新对象
主要条件次要条件一次排序

比较器排序可以让类去实现那个 compater 接口或者再创建 treeset集合的时候直接创建

一个设置一个比较规则做返回

哈希set集合最终不会排序 Treeset集合会自动排序自然排序

泛型的好处

1.再存储数据的时候一般数据都是 object 类型

2.有时候 String 存进去可以 interger 不可以

3.泛型的好处把运行时代码错误提前

4.可以默认帮你转换数据类型

泛型类的使用

设置泛型给一个类自动的定义泛型 ()根据使用的泛型当作参数传递

泛型常用的类型 T V K E 都是一般代表泛型

泛型方法

1.泛型一般通常指一类很多

2.泛型可以使用在类上 ,也可以使用在方法上

这个类型通配符只可以匹配任何的类型但是无法向里面存储元素

多个参数的传入

可变参数

package 集合2;

public class 可变参数 {
    public static void main(String[] args) {
        //可变参数  写法 类型... 名字  如果有 多余的参数 写在最前面 可变的参数放在最后面
        System.out.println(show(2, 3));
        System.out.println(duoge(1, 2, 33));
    }

    public static int show(int a, int b) {
        return a + b;
    }

    public static int duoge(int... a) {
        //System.out.println(a);
        //return a;
        int sum = 0;
        for (int item : a) {
            sum += item;
        }
        return sum;
    }
}

可变参数要在最后面

Array List set 这三个集合都有一个静态的方法集合.of() 方法这个方法生成的集合不允许改变方法不管用不能进行追加元素添加元素

Array 的可以修改操作增加删除操作不可以

map集合的遍历方式

package Map集合3;

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

public class map集合的创建 {
    public static void main(String[] args) {
        Map<String, String> objectObjectMap = new HashMap<>();
        objectObjectMap.put("1001","魏长瑞");
        objectObjectMap.put("1002","卢贝");
        objectObjectMap.put("1003","唐三");
//        System.out.println(objectObjectMap);
        //map 集合像是个对象  key value 结构的  一个键对应一个值
        //当 键重复的时候 就会变成了 重新赋值

        //常用的方法
        /*
        * put 方法 增加
        * remove 方法 删除
        * clear 方法 清除
        * isEmpty 方法 判断是否为空
        * containsKey 方法 是否有这个key
        * containsvalue   是否有这个值
        *
        * */
        System.out.println(objectObjectMap.isEmpty());
        objectObjectMap.remove("1003");
        System.out.println(objectObjectMap);
        System.out.println(objectObjectMap.containsKey("1001"));
        System.out.println(objectObjectMap.size());
        Set<String> strings = objectObjectMap.keySet();
        for (String str:strings){
           System.out.println(str);

           System.out.println(objectObjectMap.get(str));
        }
        /*
        * 用 map集合的KeySet()集合方法获取 所有key的方法 通过增强for
        * 循环 循环出每个key  通过 .getKey()获取对应的值
        * */

        //方法2  遍历 enetrSet集合 获取每一个成对的 键值对

        Set<Map.Entry<String, String>> entries = objectObjectMap.entrySet();
        for (Map.Entry<String, String> str:entries){
            System.out.println(str.getValue());

        }
    }

}

1.根据key 取值 2. 用enterSet集合获取整个键值对对应的.getkey或者value 方法直接获取值类型就是泛型

key是 object 值是 String 类型的 map 对象存储让key 保持唯一

需要重写对象的

@Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Student)) 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 Map集合3;

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

public class 对象map存放测试 {
    public static void main(String[] args) {
        HashMap<Object,String> objectObjectHashMap = new HashMap<>();

        //创建对象
        Student student = new Student("卢贝",22);
        Student student1 = new Student("魏长瑞",22);
        Student student2 = new Student("魏长瑞",22);
//        objectObjectHashMap.put("1001",student);
//        objectObjectHashMap.put("1002",student);
//
//        System.out.println(objectObjectHashMap);
//        Set<Map.Entry<String, Object>> entries = objectObjectHashMap.entrySet();
//        for (Map.Entry<String, Object> item:entries){
//            System.out.println( item.getKey());
//            System.out.println(item.getValue());
//        }
        objectObjectHashMap.put(student,"遥墙");
        objectObjectHashMap.put(student1,"商河");
        objectObjectHashMap.put(student2,"商河");

        System.out.println(objectObjectHashMap);

    }
}

取值方法

package Map集合3;

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

public class map集合存储嵌套 {
    public static void main(String[] args) {

        //map集合的嵌套
        //创建一个 Arraylist 信息是 key value结构的

        ArrayList<Map<String,String>> objects = new ArrayList<>();
        HashMap<String, String> objectObjectHashMap = new HashMap<>();
        objectObjectHashMap.put("卢贝","魏长瑞");
        objectObjectHashMap.put("唐三","小舞");
        objects.add(objectObjectHashMap);
        HashMap<String, String> objectObjectHashMap1 = new HashMap<>();
        objectObjectHashMap1.put("1001","唐三");
        objectObjectHashMap1.put("1002","小舞");
        objects.add(objectObjectHashMap1);

        System.out.println(objects);

        for (Map<String,String> item:objects){
            System.out.println(item);
            Set<Map.Entry<String, String>> entries = item.entrySet();
            for (Map.Entry<String, String> str:entries){
                System.out.println(str.getKey());
                System.out.println(str.getValue());
            }

        }

        //Arraylist   存储  map集合======================================================================


        //map 集合 存储  list集合嵌套 ==========================================================================

        HashMap<String, ArrayList<String>> objectObjectHashMap2 = new HashMap<>();

        ArrayList<String> sgyy = new ArrayList<>();
        sgyy.add("诸葛亮");
        sgyy.add("赵云");
        objectObjectHashMap2.put("三国演义",sgyy);
        ArrayList<String> shz = new ArrayList<>();
        shz.add("林冲");
        shz.add("鲁智深");
        objectObjectHashMap2.put("水浒传",shz);

        System.out.println(objectObjectHashMap2);
        //  entrySet();  集合取值方法===============================================================
        Set<Map.Entry<String, ArrayList<String>>> entries = objectObjectHashMap2.entrySet();
        for (Map.Entry<String, ArrayList<String>> item:entries){
            System.out.println(item);

            for (int i = 0; i < item.getValue().size(); i++) {
                System.out.println(item.getValue().get(i));
            }
        }
        // keySet(); 取值 方法===========================================================================
        Set<String> strings = objectObjectHashMap2.keySet();
        for (String str:strings){
            System.out.println(str);
            ArrayList<String> strings1 = objectObjectHashMap2.get(str);
            for (String item:strings1){
                System.out.println("\t"+item);
            }
        }

    }
}

随机输入一个字符串用 map集合来收入每个字符出现了多少次

package Map集合3;

import java.util.HashMap;
import java.util.Scanner;
import java.util.Set;

public class 字符多少个的测试 {
    public static void main(String[] args) {
        HashMap<Character, Integer> objectObjectHashMap = new HashMap<>();//创建map集合
        Scanner scanner = new Scanner(System.in);//创建接收器
        String s = scanner.nextLine();//接收字符串

        System.out.println(s);//输出字符串
        System.out.println(s.length());//字符串的长度

        for (int i = 0;i <s.length(); i++) {//循环字符
            System.out.println(s.charAt(i));//输出字符
            if(!objectObjectHashMap.containsKey(s.charAt(i))){//如果没有在map集合里面找到 就 增加一个 否则找到了 就让找到的加1
                objectObjectHashMap.put(s.charAt(i),1);
            }else {
                System.out.println(objectObjectHashMap.get(s.charAt(i)));
                Integer integer = objectObjectHashMap.get(s.charAt(i));
                integer++;
                objectObjectHashMap.put(s.charAt(i),integer);
            }
        }
        System.out.println(objectObjectHashMap);
    }
}

1.map集合的使用

1.用户输入字符串自动判断字符出现的次数

package Map集合3;

import java.util.HashMap;
import java.util.Scanner;
import java.util.Set;

public class 字符多少个的测试 {
    public static void main(String[] args) {
        HashMap<Character, Integer> objectObjectHashMap = new HashMap<>();//创建map集合
        Scanner scanner = new Scanner(System.in);//创建接收器
        String s = scanner.nextLine();//接收字符串

        System.out.println(s);//输出字符串
        System.out.println(s.length());//字符串的长度

        for (int i = 0;i <s.length(); i++) {//循环字符
            System.out.println(s.charAt(i));//输出字符
            if(!objectObjectHashMap.containsKey(s.charAt(i))){//如果没有在map集合里面找到 就 增加一个 否则找到了 就让找到的加1
                objectObjectHashMap.put(s.charAt(i),1);
            }else {
                System.out.println(objectObjectHashMap.get(s.charAt(i)));
                Integer integer = objectObjectHashMap.get(s.charAt(i));
                integer++;
                objectObjectHashMap.put(s.charAt(i),integer);
            }
        }
        System.out.println(objectObjectHashMap);

        //输出的不是按着顺序来的  如果需要按着顺序 可以 使用 TreeMap  树形的都是自动排序的
    }
}

2.treemap 类的集合大部分都是自动自然排序的

2.Collections集合的常用静态方法

Collections.reverse(integers); 数组反转

等等这种集合的常用方法

3.用list集合存储对象利用comaprbel 自然比较器排序

package Map集合3;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;

public class collection集合常用 {
    public static void main(String[] args) {
        ArrayList<Student> integers = new ArrayList<>();
//        integers.add(22);
//        integers.add(21);
//        integers.add(20);
//        integers.add(19);
//        integers.add(2);
        Student student = new Student("卢贝", 22);
        Student student1 = new Student("魏长瑞", 20);
        Student student2 = new Student("唐三", 20);
        integers.add(student);
        integers.add(student1);
        integers.add(student2);
        Collections.sort(integers);
        System.out.println(integers);
//        Collections.sort();
    }
}
//Tree set   Treemap都有比较器 
// list集合 使用  Collections 的sort方法 比较排序

//Collections.sort(integers); 但是需要学生类 实现 Comparable 接口 泛型是学生类的

package Map集合3;

import java.util.Objects;

public class Student implements Comparable<Student>{
    String name;
    int age;

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

    public Student() {
    }

    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 instanceof Student)) return false;
        Student student = (Student) o;
        return age == student.age && Objects.equals(name, student.name);
    }

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

    @Override
    public int compareTo(Student o) {
        int i = this.age - o.age;
        int i1 = i == 0 ? this.name.compareTo(o.name) : i;
        return i1;
    }
}

模拟斗地主

package 模拟斗地主;

import java.util.*;

public class 模拟斗地主升级版本 {
    public static void main(String[] args) {
        //定义花色
        String[] hs = {"♠", "♦", "♥", "♣"};
        //定义纸牌的数
        String[] zp = {"3","4","5","6","7","8","9","10","J","Q","K","A","2"};
        HashMap<Integer,String> poker1 = new HashMap<Integer,String>();
        ArrayList<Integer> suoyin = new ArrayList<>();
        int index =0;
        for (int i = 0; i < zp.length; i++) {
            for (int j = 0; j < hs.length; j++) {
                poker1.put(index,hs[j]+zp[i]);
                suoyin.add(index);
                index++;
            }
        }
        poker1.put(52,"小王");
        suoyin.add(52);
        poker1.put(53,"大王");
        suoyin.add(53);

        Collections.shuffle(suoyin);
        TreeSet<Integer> play1 = new TreeSet<>();
        TreeSet<Integer> play2 = new TreeSet<>();
        TreeSet<Integer> play3 = new TreeSet<>();
        TreeSet<Integer> dp = new TreeSet<>();
        for (int i = 0; i < suoyin.size(); i++) {
            if(i>=suoyin.size()-3){
                dp.add(suoyin.get(i));
            }else if(i%3==0){
                play1.add(suoyin.get(i));
            }else if(i%3==1){
                play2.add(suoyin.get(i));
            }else if(i%3==2){
                play3.add(suoyin.get(i));
            }
        }

        System.out.println(play1);
        System.out.println(play2);
        System.out.println(play3);
        System.out.println(dp);


        //看牌的方法
        look("play1",play1, (HashMap<Integer, String>) poker1);
        look("play2",play2, (HashMap<Integer, String>) poker1);
        look("play3",play3, (HashMap<Integer, String>) poker1);

    }

    public static void look(String name,TreeSet<Integer> play,HashMap<Integer,String> poker){
        String s = play.toString();
        String sum="";
        for (int i:play){
            sum+=poker.get(i);

        }
        System.out.println(name+"\t"+sum);
    }
}

我们要求是想让它数字从小到大排序按照数字

在我们生成扑克牌的时候假如是先花色外循环数字内循环

是 ===>黑桃3 黑桃 4 黑桃 5 .....这样的生成的

我们的treeset集合是排序的 key的值对应上面的 0 1 2 下标

如果是数字在外循环花色在内循环 ===> 3黑桃 3 红桃 3方块 3 梅花

我们的treeset集合是key的排序对应上面的是0,1,2,3 这样就是都是数字排序了

treeset 集合把我们的下标进行了排序所以它出来的就是按着数字排序挨着的一组扑克牌

weixin_47744616

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
集合-java(2)

set集合set集合里面不包含重复的元素 ,set集合对迭代顺序不保证所以普通for循环不能满足他set输出的东西是无序的默认不会添加重复的元素package 集合2;import java.util.HashSet;public class Set集合 { public static void main(String[] args) { HashSet<String> str = new HashSet<>();
复制链接

扫一扫