Java集合_泛型_Set_Map

最新推荐文章于 2023-02-15 20:56:15 发布

远道学java

最新推荐文章于 2023-02-15 20:56:15 发布

阅读量175

点赞数

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

本文链接：https://blog.csdn.net/xmcxmc___/article/details/123030714

版权

在这里插入图片描述

泛型

1、通常情况下集合中可以存放不同类型的对象，是因为将所有对象都看做Object类型放入的，因此从集合中取出元素时也是Object类型，为了表达该元素真实的数据类型，则需要强制类型转换，而强制类型转换可能会引发类型转换异常。
2、为了避免上述错误的发生，从Java5开始增加泛型机制，也就是在集合名称的右侧使用<数据类型>的方式来明确要求该集合中可以存放的元素类型，若放入其它类型的元素则编译报错。
3、泛型只在编译时期有效，在运行时期不区分是什么类型。
4、泛型中有三种通配符形式：

<?> 无限制通配符	表示我们可以传入任意类型的参数
<? extends E>	表示类型的上界是E，只能是E或者是E的子类。
<? super E>	表示类型的下界是E，只能是E或者是E的父类

// 自定义泛型方法
public <T> void show(T[] arr) {
        for (T t : arr) {
            
        }
    }

public class GenericTest {

    public static void main(String[] args) {

        // 1.声明两个List类型的集合进行测试
        List<Animal> lt1 = new LinkedList<>();
        List<Dog> lt2 = new LinkedList<>();
        // 试图将lt2的数值赋值给lt1，也就是发生List<Dog>类型向List<Animal>类型的转换
        //lt1 = lt2;  Error: 类型之间不具备父子类关系

        System.out.println("---------------------------------------------");
        // 2.使用通配符作为泛型类型的公共父类
        List<?> lt3 = new LinkedList<>();
        lt3 = lt1; // 可以发生List<Animal>类型到List<?>类型的转换
        lt3 = lt2; // 可以发生List<Dog>类型到List<?>类型的转换

        // 向公共父类中添加元素和获取元素
        //lt3.add(new Animal()); Error: 不能存放Animal类型的对象
        //lt3.add(new Dog());    Error: 不能存放Dog类型的对象， 不支持元素的添加操作

        Object o = lt3.get(0);  // ok，支持元素的获取操作，全部当做Object类型来处理

        System.out.println("---------------------------------------------");
        // 3.使用有限制的通配符进行使用
        List<? extends Animal> lt4 = new LinkedList<>();
        // 不支持元素的添加操作
        //lt4.add(new Animal());
        //lt4.add(new Dog());
        //lt4.add(new Object());
        // 获取元素
        Animal animal = lt4.get(0);

        System.out.println("---------------------------------------------");
        List<? super Animal> lt5 = new LinkedList<>();
        lt5.add(new Animal());
        lt5.add(new Dog());
        //lt5.add(new Object());  Error: 超过了Animal类型的范围
        Object object = lt5.get(0);
    }
}

Set集合

1、java.util.Set集合是Collection集合的子集合，与List集合平级。
2、该集合中元素没有先后放入次序，且不允许重复。
3、该集合的主要实现类是：HashSet类和 TreeSet类以及LinkedHashSet类。
4、其中HashSet类的底层是采用哈希表进行数据管理的。
5、其中TreeSet类的底层是采用红黑树进行数据管理的。
6、其中LinkedHashSet类与HashSet类的不同之处在于内部维护了一个双向链表，链表中记录了元素的迭代顺序，也就是元素插入集合中的先后顺序，因此便于迭代
7、常用的方法参考Collection集合中的方法即可！

HashSet集合

为什么要求重写equals方法后要重写hashCode方法呢？
当两个元素调用equals方法相等时证明这两个元素相同，重写hashCode方法后保证这两个元
素得到的哈希码值相同，由同一个哈希算法生成的索引位置相同，此时只需要与该索引位置已有元
素比较即可，从而提高效率并避免重复元素的出现。

TreeSet集合

1、二叉树主要指每个节点最多只有两个子节点的树形结构。
2、满足以下3个特征的二叉树叫做有序二叉树。
a.左子树中的任意节点元素都小于根节点元素值；
b.右子树中的任意节点元素都大于根节点元素值；
c.左子树和右子树的内部也遵守上述规则；
3、由于TreeSet集合的底层采用红黑树进行数据的管理，当有新元素插入到TreeSet集合时，需要使用新元素与集合中已有的元素依次比较来确定新元素的合理位置。
4、比较元素大小的规则有两种方式：
使用元素的自然排序规则进行比较并排序，让元素类型实现java.lang.Comparable接口；
使用比较器规则进行比较并排序，构造TreeSet集合时传入java.util.Comparator接口；
5、自然排序的规则比较单一，而比较器的规则比较多元化，而且比较器优先于自然排序；

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

 	@Override
    public int compareTo(Student o) {
        //return 0;   // 调用对象和参数对象相等，调用对象就是新增加的对象
        //return -1;  // 调用对象小于参数对象
        //return 1;     // 调用对象大于参数对象
        //return this.getName().compareTo(o.getName());  // 比较姓名
        //return this.getAge() - o.getAge(); // 比较年龄
        /*
        int ia = this.getName().compareTo(o.getName());
        if (0 == ia) {
            return this.getAge() - o.getAge();
        }
        return ia;
         */
        int ia = this.getName().compareTo(o.getName());
        return 0 != ia? ia : this.getAge() - o.getAge();
    }
}

public class TreeSetTest {

    public static void main(String[] args) {

        // 1.准备一个TreeSet集合并打印
        Set<String> s1 = new TreeSet<>();
        System.out.println("s1 = " + s1); // [啥也没有]

        // 2.向集合中添加String类型的对象并打印
        boolean b1 = s1.add("aa");
        System.out.println("b1 = " + b1); // true
        System.out.println("s1 = " + s1); // [aa]

        b1 = s1.add("cc");
        System.out.println("b1 = " + b1); // true
        System.out.println("s1 = " + s1); // [aa, cc]

        b1 = s1.add("bb");
        System.out.println("b1 = " + b1); // true
        // 由于TreeSet集合的底层是采用红黑树实现的，因此元素有大小次序，默认从小到大打印
        System.out.println("s1 = " + s1); // [aa, bb, cc]

        System.out.println("----------------------------------------------------------");
        // 4.准备一个比较器对象作为参数传递给构造方法
        // 匿名内部类： 接口/父类类型 引用变量名 = new 接口/父类类型() { 方法的重写 };
        /*
        Comparator<Student> comparator = new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {  // o1表示新增加的对象  o2表示集合中已有的对象
                return o1.getAge() - o2.getAge(); // 表示按照年龄比较
            }
        };
        */
        // 从Java8开始支持Lambda表达式: (参数列表) -> { 方法体 }
        Comparator<Student> comparator = (Student o1, Student o2) -> { return o1.getAge() - o2.getAge(); };

        // 3.准备一个TreeSet集合并放入Student类型的对象并打印
        //Set<Student> s2 = new TreeSet<>();
        Set<Student> s2 = new TreeSet<>(comparator);
        s2.add(new Student("zhangfei", 35));
        s2.add(new Student("zhangfei", 30));
        s2.add(new Student("guanyu", 35));
        s2.add(new Student("liubei", 40));
        System.out.println("s2 = " + s2);
    }
}

Map集合

1、java.util.Map<K,V>集合中存取元素的基本单位是：单对元素，其中类型参数如下：
K - 此映射所维护的键(Key)的类型，相当于目录。
V - 映射值(Value)的类型，相当于内容。
2、该集合中key是不允许重复的，而且一个key只能对应一个value。
3、该集合的主要实现类有：HashMap类、TreeMap类、LinkedHashMap类、Hashtable类、Properties类。
4、其中HashMap类的底层是采用哈希表进行数据管理的。
5、其中TreeMap类的底层是采用红黑树进行数据管理的。
6、其中LinkedHashMap类与HashMap类的不同之处在于内部维护了一个双向链表，链表中记录了元素的迭代顺序，也就是元素插入集合中的先后顺序，因此便于迭代。
7、其中Hashtable类是古老的Map实现类，与HashMap类相比属于线程安全的类，且不允许null作为key或者value的数值。
8、其中Properties类是Hashtable类的子类，该对象用于处理属性文件，key和value都是String类
型的。
9、Map集合是面向查询优化的数据结构, 在大数据量情况下有着优良的查询性能。
10、经常用于根据key检索value的业务场景。
在这里插入图片描述

方法声明	功能介绍
V put(K key, V value)	将Key-Value对存入Map，若集合中已经包含该Key，则替换该Key所对应的Value，返回值为该Key原来所对应的Value，若没有则返回null
V get(Object key)	返回与参数Key所对应的Value对象，如果不存在则返回null
boolean containsKey(Object key);	判断集合中是否包含指定的Key
boolean containsValue(Object value);	判断集合中是否包含指定的Value
V remove(Object key)	根据参数指定的key进行删除
Set keySet()	返回此映射中包含的键的Set视图
Collection values()	返回此映射中包含的值的Set视图
Set<Map.Entry<K,V>> entrySet()	返回此映射中包含的映射的Set视图

public class MapTest {
    public static void main(String[] args) {
        // 1、声明一个Map集合
        Map<String,String> map = new HashMap<>();
        // 2、向map集合中添加元素
        String one = map.put("1", "one");
        System.out.println("原来的value值为：" + one); // 原来的value值为：null
        System.out.println("map集合为：" + map); // map集合为：{1=one}

        String two = map.put("2", "two");
        System.out.println("原来的value值为：" + two); // 原来的value值为：null
        System.out.println("map集合为：" + map); // map集合为：{1=one, 2=two}

        // 修改key="1"的value值
        String s = map.put("1", "1");
        System.out.println("原来的value值为：" + s); // 原来的value值为：one
        System.out.println("map集合为：" + map); // map集合为：{1=1, 2=two}

        // 3、获取Map集合中所有的key并组成Set视图
        Set<String> s1 = map.keySet();
        // 遍历所有的key
        for (String ts : s1) {
            System.out.println(ts + "=" + map.get(ts));
        }

        System.out.println("-------------------------------------------------------------");
        // 4、获取Map集合中所有的Value并组成Collection视图
        Collection<String> co = map.values();
        for (String ts : co) {
            System.out.println("ts = " + ts);
        }

        System.out.println("-------------------------------------------------------------");
        // 5、获取Map集合中所有的键值对并组成Set视图
        Set<Map.Entry<String, String>> entries = map.entrySet();
        for (Map.Entry<String, String> me : entries) {
            System.out.println(me);
        }
    }
}

Collections类

java.util.Collections类主要提供了对集合操作或者返回集合的静态方法。

方法声明	功能介绍
static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll)	根据元素的自然顺序返回给定集合的最大元素
static T max(Collection<? extends T> coll, Comparator<? super T> comp)	根据指定比较器引发的顺序返回给定集合的最大元素
static <T extends Object & Comparable<?super T>> T min(Collection<? extends T> coll)	根据元素的自然顺序返回给定集合的最小元素
static T min(Collection<? extends T> coll, Comparator<? super T> comp)	根据指定比较器引发的顺序返回给定集合的最小元素
static void copy(List<? super T> dest, List<? extends T> src)	将一个列表中的所有元素复制到另一个列表中
static void reverse(List<?> list)	反转指定列表中元素的顺序
static void shuffle(List<?> list)	使用默认的随机源随机置换指定的列表
static <T extends Comparable<? super T>> void sort(List list)	根据其元素的自然顺序将指定列表按升序排序
static void sort(List list, Comparator<? super T> c)	根据指定比较器指定的顺序对指定列表进行排序
static void swap(List<?> list, int i, int j)	交换指定列表中指定位置的元素

public class CollectionsTest {

    public static void main(String[] args) {

        // 1.准备一个集合并初始化
        List<Integer> lt1 = Arrays.asList(10, 30, 20, 50, 45);
        // 2.实现集合中元素的各种操作
        System.out.println("集合中的最大值是：" + Collections.max(lt1)); // 50
        System.out.println("集合中的最小值是：" + Collections.min(lt1)); // 10

        // 实现集合中元素的反转
        Collections.reverse(lt1);
        System.out.println("lt1 = " + lt1); // [45, 50, 20, 30, 10]
        // 实现两个元素的交换
        Collections.swap(lt1, 0, 4);
        System.out.println("交换后：lt1 = " + lt1); // [10, 50, 20, 30, 45]
        // 实现元素的排序
        Collections.sort(lt1);
        System.out.println("排序后：lt1 = " + lt1); // [10, 20, 30, 45, 50]
        // 随机置换
        Collections.shuffle(lt1);
        System.out.println("随机置换后：lt1 = " + lt1); // [30, 10, 45, 20, 50] 随机
        // 实现集合间元素的拷贝
        //List<Integer> lt2 = new ArrayList<>(20);
        List<Integer> lt2 = Arrays.asList(new Integer[10]);
        System.out.println("lt1的大小是：" + lt1.size());
        System.out.println("lt2的大小是：" + lt2.size());
        // 表示将lt1中的元素拷贝到lt2中
        Collections.copy(lt2, lt1);
        System.out.println("lt2 = " + lt2);
    }
}

远道学java

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java集合_泛型_Set_Map

泛型1、通常情况下集合中可以存放不同类型的对象，是因为将所有对象都看做Object类型放入的，因此从集合中取出元素时也是Object类型，为了表达该元素真实的数据类型，则需要强制类型转换，而强制类型转换可能会引发类型转换异常。2、为了避免上述错误的发生，从Java5开始增加泛型机制，也就是在集合名称的右侧使用<数据类型>的方式来明确要求该集合中可以存放的元素类型，若放入其它类型的元素则编译报错。3、泛型只在编译时期有效，在运行时期不区分是什么类型。4、泛型中有三种通配符形式：.
复制链接

扫一扫