JavaSE学习总结（十三）Set集合/HashSet集合/LinkedHashSet集合/TreeSet集合/比较器的使用/利用Set集合实现去重

最新推荐文章于 2023-07-15 18:00:59 发布
最新推荐文章于 2023-07-15 18:00:59 发布
阅读量369 收藏 2
点赞数 1
分类专栏： # JavaSE
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/allenfoxxxxx/article/details/109185214
版权

一、Set集合

Set集合是Collection集合的一个子接口，实际上Set就是Collection，只是行为略有不同：

  • Set集合不保存重复的元素。（唯一性）
  • Set集合是无序的：存储和取出的顺序无序。（无序性）

案例演示

import java.util.HashSet;
import java.util.Set;

public class MyTest {
    public static void main(String[] args) {
        Set<String> set = new HashSet<>();
        set.add("hello");
        set.add("world");
        set.add("hello");
        set.add("world");
        set.add("good");
        set.add("morning");
        for (String s : set) {
            System.out.println(s);
        }
    }
}

在这里插入图片描述

二、HashSet集合

（一）概述

HashSet是Set接口的典型实现（集合中元素也是无序且唯一的），实现了Set接口中的所有方法，并没有添加额外的方法，大多数时候使用Set集合时就是使用这个实现类。HashSet 底层数据结构是哈希表，HashSet 不是线程安全的，集合元素可以是 null。

  • 哈希表:是一个元素为链表的数组，综合了数组和链表的优点 (像新华字典一样) (JDK1.7之前)

（二）存储规则

当向 HashSet 集合中添加一个元素A时，HashSet 会调用该对象的 hashCode() 方法来得到该对象的整型hashCode 值，然后根据 hashCode 值决定该对象在 HashSet 中的存储位置，如果存储位置已经有元素B了，然后再根据equals()方法来判断元素A和元素B是否相同，相同则不再存入这个元素A，以确保元素唯一性；不同则将元素A链在已存在的元素B后面。

结论:HashSet 保证元素唯一性是靠元素重写hashCode()和equals()方法来保证的，如果不重写则无法保证。

（三）HashSet中如何判断集合元素相等

两个对象比较 具体分为如下四个情况：

  • 1.如果有两个元素的hashCode()方法返回不相等的值，但它们通过equals()方法比较返回false，HashSet将会把它们存储在不同的位置。

  • 2.如果有两个元素的hashCode()方法返回不相等的值，但它们通过equals()方法比较返回true，HashSet将会把它们存储在不同的位置。

  • 3.如果有两个元素的hashCode()方法返回相等的值，但它们通过equals()方法比较不相等，HashSet将会把它们存储在相同的位置，在这个位置以链表式结构来保存多个对象

  • 4.如果有两个元素的hashCode()方法返回相等的值，但它们通过equals()方法比较返回true，HashSet将不予添加。

结论：HashSet判断两个元素相等的标准———两个对象通过hashCode()方法比较相等，并且两个对象的equals()方法返回值也相等。

注意：HashSet是根据元素的hashCode值来快速定位的，如果HashSet中两个以上的元素具有相同的hashCode值，将会导致碰撞次数增加，性能下降。所以如果重写类的equals()方法和hashCode()方法时，应尽量保证两个对象通过hashCode()方法返回值相等时，通过equals()方法比较返回true。

案例演示
用HashSet集合存储学生对象，重写hashCode()和equals()保证集合中的元素不重复。

import java.util.Objects;
import java.util.HashSet;

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 +
                '}';
    }
    //重写equals()
    @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);
    }
    //重写hashCode()
    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

public class MyTest {
    public static void main(String[] args) {
        //HashSet集合能够保证元素的唯一性,是靠元素重写hashCode()方法和equals()方法来保证的，如果元素不重写则无法保证
        //HashSet 底层用的是HashMap来存的
        Student s1 = new Student("张三", 25);
        Student s2 = new Student("张三", 25);
        Student s3 = new Student("张三", 25);
        Student s4 = new Student("王五", 26);
        Student s5 = new Student("王五", 23);
        Student s6 = new Student("小明", 25);
        Student s7 = new Student("赵四", 26);
        Student s8 = new Student("李四", 28);
        Student s9 = new Student("李四", 28);
        Student s10 = new Student("小红", 25);
        HashSet<Student> hashSet = new HashSet<>();
        hashSet.add(s1);
        hashSet.add(s2);
        hashSet.add(s3);
        hashSet.add(s4);
        hashSet.add(s5);
        hashSet.add(s6);
        hashSet.add(s7);
        hashSet.add(s8);
        hashSet.add(s9);
        hashSet.add(s10);
        for (Student student : hashSet) {
            System.out.println(student);
        }
    }
}

在这里插入图片描述

三、LinkedHashSet集合

LinkedHashSet 底层数据结构是链表和哈希表，元素有序（存取顺序一致）且唯一 ，链表保证了元素有序，哈希表保证了元素唯一。

案例演示

import java.util.LinkedHashSet;

public class MyTest {
    public static void main(String[] args) {
        LinkedHashSet<String> linkedHashSet = new LinkedHashSet<>();
        linkedHashSet.add("A");
        linkedHashSet.add("B");
        linkedHashSet.add("D");
        linkedHashSet.add("E");
        linkedHashSet.add("C");
        linkedHashSet.add("E");
        linkedHashSet.add("C");
        linkedHashSet.add("E");
        linkedHashSet.add("C");

        for (String s : linkedHashSet) {
            System.out.println(s);
        }
    }
}

在这里插入图片描述

四、TreeSet集合

（一）特点

元素唯一，并且可以对元素进行排序
底层数据结构是二叉树

案例演示

import java.util.TreeSet;

public class MyTest1 {
    public static void main(String[] args) {
        TreeSet<Integer> treeSet = new TreeSet<>();
        treeSet.add(20);
        treeSet.add(18);
        treeSet.add(23);
        treeSet.add(22);
        treeSet.add(17);
        treeSet.add(24);
        treeSet.add(19);
        treeSet.add(18);
        treeSet.add(24);
        for (Integer integer : treeSet) {
            System.out.println(integer);
        }
    }
}

在这里插入图片描述
结果是排好序的，并且唯一
那么它的底层的数据结构是如何实现排序的呢？
在这里插入图片描述
添加完以后，按左中右的顺序取出来就是有序的了：
在这里插入图片描述

（二）排序

Treeset集合的排序又分为自然排序和使用比较器排序

具体用哪种排序，根据你使用的构造方法，如果用空参构造，那么就使用的是自然排序，如果用有参构造，就是使用比较器来排序。

1.自然排序

如果我们使用的是自然排序：那么对元素所属的类是有要求的，要求该类必须实现一个Comparable接口并且重写里面的compareTo()方法（否则报错），根据此方法的返回值(正、负、0)来决定元素在二叉树的位置。

我们上面的例子中的Integer类就已经实现了Comparable接口，并且重写了compareTo()方法:
在这里插入图片描述
在这里插入图片描述
继续点开compare()方法可以看到它的实现逻辑：
其实就是x小于y就返回负数，那么x就放置在y的左边；x等于y返回0，就不放进去；x大于y就返回正数，那么x就放置在y的右边。
在这里插入图片描述

案例演示1
需求：将集合中的学生按年龄来排序

import java.util.TreeSet;

class Student implements Comparable<Student>{//实现Comparable接口
    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 int compareTo(Student s) {
        int num1 = this.age-s.age;//比较逻辑是按照年龄大小来排序
        //此时可能有人觉得return num1;这个方法就可以结束了
        //但是会出现一个现象：名字不同，年龄相同的Student对象存不进去
        //而这个和重写equals方法没关系，因为底层数据结构是二叉树不是哈希表

        //年龄相同不能说明他是同一个对象，还得比较姓名
        int num2=num1==0?this.name.compareTo(s.name):num1;
        return num2;//如果需要降序，则return -num2;
    }
}

public class MyTest {
    public static void main(String[] args) {
        Student s1 = new Student("王五", 21);
        Student s2 = new Student("王五", 21);
        Student s3 = new Student("王五五", 21);
        Student s4 = new Student("王五", 22);
        Student s5 = new Student("张三", 25);
        Student s6 = new Student("李四", 29);
        Student s7 = new Student("赵四", 24);
        Student s8 = new Student("赵六", 26);
        Student s9 = new Student("小明", 26);
        Student s10 = new Student("小红", 28);
        Student s11 = new Student("小张", 21);
        Student s12 = new Student("小刚", 20);
        TreeSet<Student> treeSet = new TreeSet<>();
        treeSet.add(s1);
        treeSet.add(s2);
        treeSet.add(s3);
        treeSet.add(s4);
        treeSet.add(s5);
        treeSet.add(s6);
        treeSet.add(s7);
        treeSet.add(s8);
        treeSet.add(s9);
        treeSet.add(s10);
        treeSet.add(s11);
        treeSet.add(s12);
        for (Student student : treeSet) {
            System.out.println(student);
        }
    }
}

在这里插入图片描述
元素的唯一性是靠compareTo()方法的返回值来保证的，如果返回0，表示两个元素相等，则不重复存储

案例演示2
需求：按照姓名的长度进行排序
主要条件是姓名的长度
然后是姓名内容
然后是年龄

import java.util.TreeSet;

class Student implements Comparable<Student>{//实现Comparable接口
    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 int compareTo(Student s) {
   		 //先比较姓名长度
        int num1=this.name.length()-s.name.length();
        //姓名长度一样 再比较姓名内容
        int num2=num1==0?this.name.compareTo(s.name):num1;
        //如果姓名长度和内容一样再比较年龄
        int num3=num2==0?this.age-s.age:num2;
        return num3;
    }
}

public class MyTest {
    public static void main(String[] args) {
        Student s1 = new Student("王五", 21);
        Student s2 = new Student("王五", 21);
        Student s3 = new Student("王五五", 21);
        Student s4 = new Student("王五六七八", 22);
        Student s5 = new Student("张三三", 25);
        Student s6 = new Student("李四", 29);
        Student s7 = new Student("赵六六", 27);
        Student s8 = new Student("赵六六", 26);
        Student s9 = new Student("明", 26);
        Student s10 = new Student("小红", 28);
        Student s11 = new Student("小红", 21);
        Student s12 = new Student("小刚", 20);
        TreeSet<Student> treeSet = new TreeSet<>();
        treeSet.add(s1);
        treeSet.add(s2);
        treeSet.add(s3);
        treeSet.add(s4);
        treeSet.add(s5);
        treeSet.add(s6);
        treeSet.add(s7);
        treeSet.add(s8);
        treeSet.add(s9);
        treeSet.add(s10);
        treeSet.add(s11);
        treeSet.add(s12);
        for (Student student : treeSet) {
            System.out.println(student);
        }
    }
}

在这里插入图片描述

2.使用比较器排序

在创建TreeSet对象的时候使用有参构造TreeSet(Comparator<? super E> comparator) 构造一个新的空 TreeSet，它根据指定比较器进行排序。

案例演示
需求：将集合中的学生按年龄来排序

  • 方式1
    创建一个Comparator的子实现类，并使用
import java.util.TreeSet;
import java.util.Comparator;

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 +
                '}';
    }
}

//自定义的Comparator子实现类
class MyComparator implements Comparator<Student> {
    @Override
    public int compare(Student s1, Student s2) {
        int num1=s1.getAge()-s2.getAge();
        int num2=num1==0?s1.getName().compareTo(s2.getName()):num1;
        return num2;
    }
}

public class MyTest {
    public static void main(String[] args) {
        Student s1 = new Student("王五", 21);
        Student s2 = new Student("王五", 21);
        Student s3 = new Student("王五五", 21);
        Student s4 = new Student("王五", 22);
        Student s5 = new Student("张三", 25);
        Student s6 = new Student("李四", 29);
        Student s7 = new Student("赵四", 24);
        Student s8 = new Student("赵六", 26);
        Student s9 = new Student("小明", 26);
        Student s10 = new Student("小红", 28);
        Student s11 = new Student("小张", 21);
        Student s12 = new Student("小刚", 20);
        //创建Comparator子实现类的对象
        MyComparator myComparator = new MyComparator();
        //有参构造，传入Comparator子实现类的对象
        TreeSet<Student> treeSet = new TreeSet<>(myComparator);
        treeSet.add(s1);
        treeSet.add(s2);
        treeSet.add(s3);
        treeSet.add(s4);
        treeSet.add(s5);
        treeSet.add(s6);
        treeSet.add(s7);
        treeSet.add(s8);
        treeSet.add(s9);
        treeSet.add(s10);
        treeSet.add(s11);
        treeSet.add(s12);
        for (Student student : treeSet) {
            System.out.println(student);
        }
    }
}

在这里插入图片描述

  • 方式2
    不创建多的类，使用匿名内部类
import java.util.Comparator;
import java.util.TreeSet;

public class MyTest {
    public static void main(String[] args) {
        Student s1 = new Student("王五", 21);
        Student s2 = new Student("王五", 21);
        Student s3 = new Student("王五五", 21);
        Student s4 = new Student("王五", 22);
        Student s5 = new Student("张三", 25);
        Student s6 = new Student("李四", 29);
        Student s7 = new Student("赵四", 24);
        Student s8 = new Student("赵六", 26);
        Student s9 = new Student("小明", 26);
        Student s10 = new Student("小红", 28);
        Student s11 = new Student("小张", 21);
        Student s12 = new Student("小刚", 20);
        //使用匿名内部类传入比较器对象
        TreeSet<Student> treeSet = new TreeSet<>(new Comparator<Student>() {
            @Override
            public int compare(Student s1, Student s2) {
                int num1=s1.getAge()-s2.getAge();
                int num2=num1==0?s1.getName().compareTo(s2.getName()):num1;
                return num2;
            }
        });
        treeSet.add(s1);
        treeSet.add(s2);
        treeSet.add(s3);
        treeSet.add(s4);
        treeSet.add(s5);
        treeSet.add(s6);
        treeSet.add(s7);
        treeSet.add(s8);
        treeSet.add(s9);
        treeSet.add(s10);
        treeSet.add(s11);
        treeSet.add(s12);
        for (Student student : treeSet) {
            System.out.println(student);
        }
    }
}

聊到比较器，提一下Arrays的sort方法：

import java.util.Arrays;

public class MyTest {
    public static void main(String[] args) {
        Integer[] i={2,54,6,23,74,685,0};
        Arrays.sort(i);
        System.out.println(Arrays.toString(i));
    }
}

在这里插入图片描述
我们平时使用的Arrays的sort()方法，默认是升序排序，那么如果我们想要降序呢？
其实可以用到比较器：

import java.util.Arrays;
import java.util.Comparator;

public class MyTest {
    public static void main(String[] args) {
        Integer[] i={2,54,6,23,74,685,0};
        Arrays.sort(i, new Comparator<Integer>() {
            @Override
            public int compare(Integer i1, Integer i2) {
                return i2-i1;
            }
        });
        System.out.println(Arrays.toString(i));
    }
}

在这里插入图片描述

五、应用

案例演示1
需求：编写一个程序，获取10个1至20的随机数，要求随机数不能重复。
思路：可以使用HashSet、LinkedHashSet、TreeSet作为容器接收这些随机数，它们可以帮忙去重。

import java.util.HashSet;
import java.util.Random;

public class MyTest {
    public static void main(String[] args) {
        Random random = new Random();
        HashSet<Integer> set = new HashSet<>();
        while(set.size()<10){
            int num=random.nextInt(20)+1;
            set.add(num);
        }
        System.out.println(set);
    }
}

在这里插入图片描述
案例演示2
需求：将ArrayList中的元素去重
思路：将ArrayList传给HashSet（HashSet(Collection<? extends E> c) 构造一个包含指定 collection 中的元素的新 set。）

import java.util.ArrayList;
import java.util.HashSet;

public class MyTest {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        list.add(2210);
        list.add(2210);
        list.add(2130);
        list.add(2150);
        list.add(2150);
        list.add(2210);
        list.add(2130);
        list.add(2150);
        list.add(21770);
        list.add(21550);

        HashSet<Integer> set = new HashSet<>(list);
        System.out.println(set);
    }
}

在这里插入图片描述

ZaynFox
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
collection之set集合的使用：HashSet、LinkedHashSet、TreeSet使用案例
yalu_123456的博客
05-23 343
Set集合概述及特点 A:Set集合概述及特点: 通过API查看即可 B: 案例演示: 无序(存储和取出的顺序)和唯一 案例一： import java.util.Collection; import java.util.HashSet; public class SetDemo { public static void main(String[] args) { //...
Java Set接口中的 LinkedHashSet集合 和 TreeSet集合
m0_60489526的博客
08-22 95
LinKedHashSet 集合： 元素存取有序，元素无索引，元素不可重复（唯一） 采用哈希表 + 链表 结构，由哈希表保证元素唯一，由链表保证元素存取有序 LinkedHashSet 的使用： // 创建一个LinkedHashSet集合，限制集合中元素的类型为Integer类型 LinkedHashSet<Integer> set = new LinkedHashSet<>(); ...
J集合Set（HashSet（重写HashCode、equals比较对象的属性值）、LinkedHashSet、TreeSet（实现Comparable、创建对象时传递Comparator比较器））
Jackmat的博客
02-27 355
哈希值：对象的整数表现形式（没有重写hashcode方法，不同的对象hashcode值不相同；重写了hashcode方法，不同的对象属性值相同，hashcode值相同）LinkedHashSet继承于HashSet，底层数据结构是哈希表和双向链表，因而我们存入数据和取出数据的顺序是一样的，即是有序的。因为在JDk8以后，新元素直接挂在老元素后面，所以无法确定其中的数据是第几个存入的，因而存和取的顺序不一样。因为在JDK8以后，HashSet是由数组+链表+红黑树组合而成的，不好规定数据的索引。
查漏补缺第一天（比较器，HashSet，Collections）
young_rookie的博客
06-18 58
Comparator定制排序Comparable自然排序Comparable需要在类上进行实现接口，然后实现ComparaTo方法，本对象大那么返回值为1本对象小返回值为-1.Comparator是为了解决没办法修改的类，而有的定制排序，因为Java的API改不了，然后你不用它的排序规则，或者说用别人的类，动了别人的类，其它地方要出问题。
JavaSE学习总结（十三）Set集合HashSet集合LinkedHashSet集合TreeSet集合比较器的使用利用Set集合实现去重
long3359的博客
04-02 491
HashSet是Set接口的典型实现（集合中元素也是无序且唯一的），实现了Set接口中的所有方法，并没有添加额外的方法，大多数时候使用Set集合时就是使用这个实现类。HashSet 底层数据结构是哈希表，HashSet 不是线程安全的，集合元素可以是 null。哈希表:是一个元素为链表的数组，综合了数组和链表的优点 (像新华字典一样) (JDK1.7之前)
Java集合框架（Set与Map，HashSet与HashMap，TreeSet与TreeMap）
磷火的博客
10-14 4652
定义
Java中TreeSet、HashSet、Collection重写比较器
最新发布
TaloyerG的博客
07-15 789
比较器是一种可以对集合或数组中的元素按照自定义的方式进行排序的对象，它是实现了Comparator接口的类的实例，可以决定元素在集合或映射中如何被排序和存储。比较器有两种基本类型：自然排序和定制排序。自然排序是指让要排序的类实现Comparable接口，并重写compareTo方法，来定义元素的默认排序方式。定制排序是指创建一个实现了Comparator接口的类，并重写compare方法，来定义元素的特定排序方式。定制排序可以覆盖自然排序，也可以在自然排序不适用的情况下使用。
JavaSE专题-Set集合.doc
06-03
Set集合是JavaSE中的一种重要数据结构，主要包括HashSet、TreeSet和LinkedHashSet三个子类。下面我们将对Set集合的原理、特点、使用场景等进行详细的探索和分析。 HashSet HashSet是Set集合中的一种重要实现类，...
JavaSe知识总结：I/O流.xmind
10-19
思维导图，含括流概念，流分类，流关系的图文展示等
JavaSE_集合.zip
07-21
JavaSE集合的全部内容，大大小小重点，全部包含，内容之多之全，首先声明，这是一个完全完整的集合全部重点内容，如果您难呢过坚持下来一个一个知识点去攻破，那恭喜你，集合的知识你差不多已经足够掌握了，妈妈再也...
java集合三种比较器（详解）
12-21
关于java集合比较器的创建和使用 概述： 在java集合中，TreeSet集合和TreeMap集合底层数据结构都是自平衡二叉树，所以在这两个集合中添加元素的时候会实现自动排序，排序方式为中序排序(即左根右的方式进行排序，详情请见二叉树数据结构，这里不做赘述)。 SUN公司编写源代码的时候已经为我们写好了排序代码，因此在我们输入数据元素后会实现自动排序(这里的数据都是对象，也就是引用类型，不能是基本数据类型)，源码中可见底层是调用了compareTo()方法进行了排序(详情请见TreeSet或者TreeMap源码) 如果我们要实现自定义的引用类型排序需要重写排序方法，就必须重写排序方法，有
JavaSE专题-List集合.doc
06-03
【JavaSE专题-List集合】 Java集合框架是Java API的核心组件之一，主要用于存储和操作对象。List集合是其中的一个重要接口，它代表了一个有序的、允许元素重复的序列。List接口扩展了Collection接口，提供了更丰富...
集合中常用方法总结大框
07-30
资源主要是Map集合整理，Set集合整理，集合中常用的方法总结，各自底层结构的入门了解，缓缓步入集合门框中，图片绘制更加明了明确，帮助理解。
HashSet原理及Comparable(接口)比较器~(2022.5.23)
weixin_66262328的博客
05-23 795
每一次的练习就是让自己变强的根本！
LinkedHashSet--将存入的对象顺序输出
weixin_45846799的博客
05-10 1328
package en.itcast.set.demo; import java.util.Iterator; import java.util.LinkedHashSet; import java.util.Set; public class HashSetDemo { public static void main(String[] args) { //1.创建一个HashSet容器对象 Set set = new LinkedHashSet(); //2.添加元素 //改变
Java集合框架篇-57-LinkedHashSet基本概述和使用
Anthony_tester的博客
05-07 669
      这篇，学习一个HashSet类的子类，叫LinkedHashSet,看名称就大概明白是什么作用。LinkedHashSet是底层用链表实现的一种HashSet集合。前面我们知道，链表存储是List的一种实现方式，最明显的特点就是能保证元素的存入和取出顺序是一致的。这个特点，刚好弥补了Set集合无序的缺点。 1.API阅读关于LinkedHashSet        具有可预知迭代顺序的...
Java基础理论之集合,比较器，哈希
Allen_Heng的博客
09-27 452
集合即容器，了解容器是什么，可以放什么，怎么放，怎么拿，多种容器的区别和共同点是什么，这样我们才能在开发中游刃有余的使用容器，更换容器等。 集合分为两大类 一类继承Collection接口（单列集合） 一类继承Map接口（双列集合）。 资料多取自JDK1.8 Api文档，学习java自己的类是建议对照此进行学些，类归属，类，类的继承关系，类的构造方法，类的成员方法和静态方法。 集合概述 集合：集合是java中提供的一种容器，可以用来存储多个数据。 继承体系 Iterator迭代器
【转】LinkedHashMap实现由插入集合的顺序输出
weixin_30520015的博客
04-22 509
(转载声明： 　　作者：kingdelee 　　地址：http://kingdelee.iteye.com/blog/1582135 　　) HashMap是无序的，HashMap在put的时候是根据key的hashcode进行hash然后放入对应的地方。所以在按照一定顺序put进HashMap中，然后遍历出HashMap的顺序跟put的顺序不同（除非在put的时候key已经按照hashc...
Java 网络编程
热门推荐
ZaynFox的博客
05-30 6万+
网络编程 一、网络编程基础概念 首先理清一个概念：网络编程不等于网站编程，网络编程即使用套接字来达到进程间通信，现在一般称为TCP/IP编程。 计算机网络： 把分布在不同地理区域的计算机与专门的外部设备用通信线路互连成一个规模大，功能强的网络系统，从而使众多的计算机可以方便的互相传递信息，共享硬件，软件，数据信息等资源。 计算机网络的主要功能： 资源共享 信息传输与集中处理 均衡负荷与分布处理 ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值