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

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

一、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);
    }
}

在这里插入图片描述

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/6489.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

VUE3项目实现动态路由demo

VUE3项目实现动态路由demo

文章目录1、创建vue项目2、安装常用的依赖2.1 安装elementUI2.2 安装axios2.3 安装router2.4 安装vuex2.5 安装store2.6 安装mockjs3、编写登录页面以及逻辑4、编写首页以及逻辑5、配置router.js6、配置store.js7、配置menuUtils.js&#xff08;动态路由重点&#xff09;8、配置…
阅读更多...
树的前序遍历与中序遍历构造二叉树和树的中序遍历与后序遍历构造二叉树

树的前序遍历与中序遍历构造二叉树和树的中序遍历与后序遍历构造二叉树

目录 一.树的前序遍历与中序遍历构造二叉树 1.题目描述 2.问题分析 3.代码实现 二.树的中序遍历与后序遍历构造二叉树 1.题目描述 2.问题分析 3.代码实现 三.问题思考 一.树的前序遍历与中序遍历构造二叉树 1.题目描述 给定两个整数数组 preorder 和 inorder &#xf…
阅读更多...
【机器学习】Logistic回归---学习笔记

【机器学习】Logistic回归---学习笔记

Logistic回归学习笔记Logistic回归学习线路预备知识&#xff1a;建议先去B站学习一下信息量&#xff0c;熵&#xff0c;BL散度&#xff0c;交叉熵的概念。Logistic回归的函数模型损失最小化架构分类函数最大概率分类函数阈值分类函数Logistic回归的优化算法梯度下降随机梯度下降…
阅读更多...
4.5--计算机网络之基础篇--2.网址到网页解析--（复习＋深入）---好好沉淀，加油呀

4.5--计算机网络之基础篇--2.网址到网页解析--（复习＋深入）---好好沉淀，加油呀

1.浏览器做的第一步工作是解析 URL 对 URL 进行解析&#xff0c;从而生成发送给 Web 服务器的请求信息 URL? URL 实际上是请求服务器里的文件资源 当没有路径名时&#xff0c;就代表访问根目录下事先设置的默认文件&#xff0c;也就是 /index.html 或者 /default.html 这些文件…
阅读更多...
计算机网络复习笔记（三）物理层

计算机网络复习笔记（三）物理层

文章目录一物理层的基本概念四大特性&#xff1a;两种信号&#xff1a;调制和编码传输介质三大部分二物理层的基本通信技术四种信道复用技术数据的传输方式三OSI模型一物理层的基本概念 四大特性&#xff1a; 机械特性 接口是怎么样的 电气特性 用多少伏的电 功能特性 线路上…
阅读更多...
linux基础之计算机基础

linux基础之计算机基础

一、计算机基础 &#xff08;1) 计算机发展&#xff1a;电子管、晶体管、集成电路、大规模集成电路 &#xff08;2) 冯诺依曼体系&#xff1a;用二进制表示数据和指令&#xff1b; 存储程序控制&#xff0c;程序和数据预先存入存储器&#xff1b; 计算机系统5大部分&#xf…
阅读更多...
Python 高级编程（文件操作）

Python 高级编程（文件操作）

文件&#xff1a;存储在某种长期存储设备上的数据&#xff01;&#xff01;包括&#xff08;硬板 u 盘 移动硬盘 光盘&#xff09; 计算机中临时的数据&#xff1a; 存储在内存中&#xff0c;一旦操作结束&#xff0c;内存中的空间就会被释放 文件&#xff08;特指普通文本&am…
阅读更多...
R语言 4.2.2安装包下载及安装教程

R语言 4.2.2安装包下载及安装教程

[软件名称]:R语言 4.2.2 [软件大小]: 75.6 MB [安装环境]: Win11/Win10/Win7 [软件安装包下载]: https://pan.quark.cn/s/b6f604930d04 R语言软件的GUI界面比较的简陋,只有一个命令行窗口,且每次创建图片都会跳出一个新的窗口,比较的繁琐,我们可以安装RStudio,来更方便的操作R(…
阅读更多...
ChatGPT +工业机器人/自动驾驶控制器的一些尝试

ChatGPT +工业机器人/自动驾驶控制器的一些尝试

ChatGPT 的功能目前已扩展到机器人领域&#xff0c;可以用语言直观控制如机械臂、无人机、家庭辅助机器人等的多个平台。这会改变人机交互的未来形式吗&#xff1f; 你可曾想过用自己的话告诉机器人该做什么&#xff0c;就像对人说话那样&#xff1f; 比如说&#xff0c;只要告…
阅读更多...
多个硬盘挂载到同一个目录

多个硬盘挂载到同一个目录

同一目录无法重复挂载&#xff0c;后挂载的会覆盖之前挂载的磁盘。但是现在需要将4块磁盘并行挂载&#xff0c;该如何操作呢&#xff1f; 将2块磁盘合并到一个逻辑卷 进行挂载。 基本知识 基本概念PV(Physical Volume)- 物理卷物理卷在逻辑卷管理中处于最底层&#xff0c;它可…
阅读更多...
新能源锂电池行业除杂工艺介绍

新能源锂电池行业除杂工艺介绍

近年来新能源汽车快速发展对锂电池的需求引发了人们对锂资源的高度关注。由于锂需求不断上升&#xff0c;全球锂资源越来越紧缺&#xff0c;而在生产含锂产品中会有大量废水、废渣。这些废水废渣含有丰富的锂&#xff0c;对其进行回收提锂具有极高的经济利益。在氟化锂生产中会…
阅读更多...
文件操作介绍及C语言实现通讯录管理系统3.0最终版（文件操作版本）

文件操作介绍及C语言实现通讯录管理系统3.0最终版（文件操作版本）

文章目录1. 前言2. 文件操作2.1 什么是文件2.2 文件缓冲区2.3 文件指针2.4 文件的打开与关闭2.5 文件的顺序读写3. 优化通讯录3.1 保存通讯录3.2 加载通讯录4. 结尾1. 前言 上一篇文章我们学习了动态内存开辟的相关知识点&#xff0c;并用动态内存函数优化了我们的通讯录&…
阅读更多...
【数据库连接，线程，ThreadLocal三者之间的关系】

【数据库连接，线程，ThreadLocal三者之间的关系】

一、数据库连接与线程的关系 在实际项目中&#xff0c;数据库连接是很宝贵的资源&#xff0c;以MySQL为例&#xff0c;一台MySQL服务器最大连接数默认是100, 最大可以达到16384。但现实中最多是到200&#xff0c;再多MySQL服务器就承受不住了。因为mysql连接用的是tcp协议&…
阅读更多...
JAVA：常用API

JAVA：常用API

一.什么是API&#xff1f; API&#xff08;Application Programming Interface&#xff09;&#xff1a;应用程序编程接口。 简单的来说&#xff1a;就是Java帮我们已经写好的方法&#xff0c;我们可以直接使用。 二.有哪些常用的API&#xff1f; Object、Objects、StringB…
阅读更多...
二战华为成功上岸，准备了小半年，要个27k应该也算不上很高吧~

二战华为成功上岸，准备了小半年，要个27k应该也算不上很高吧~

先说下我基本情况&#xff0c;本科不是计算机专业&#xff0c;现在是学通信&#xff0c;然后做图像处理&#xff0c;可能面试官看我不是科班出身没有问太多计算机相关的问题&#xff0c;因为第一次找工作&#xff0c;华为的游戏专场又是最早开始的&#xff0c;就投递了&#xf…
阅读更多...
二，八，十，十六进制等常用进制详解

二，八，十，十六进制等常用进制详解

总目录 文章目录总目录一、常用进制1、进制基本信息2、各进制的表示形式二、进制转换原理1、其他进制转为十进制计算原理2、十进制转为其他进制计算原理3、二进制&#xff0c;八进制&#xff0c;十六进制之间的转换结语一、常用进制 1、进制基本信息 基数数码名称描述20 和 1…
阅读更多...
【C++】| C/C++内存管理

【C++】| C/C++内存管理

前言&#xff1a; 在上期&#xff0c;我们已经对类和对象的全部知识进行了总结和梳理。在类和对象学习完之后&#xff0c;今天我将给大家呈现的是关于——C/C内存管理的基本知识。 本文目录 1. C/C内存分布 2. C语言中动态内存管理方式 &#xff08;1&#xff09;C语言跟内…
阅读更多...
php科研项目申报审批系统

php科研项目申报审批系统

目 录 1 绪论 4 1.1 开发背景 4 1.2 开发意义 4 1.3 相关知识介绍 4 1.3.1 Apache 4 1.3.2 MySQL 5 1.3.3 PHP 6 1.3.4 Dreamweaver CS3 7 1.4 本文所做的工作及组织结构 7 2 系统分析 7 2.1 需求分析 7 2.2 可行性分析 7 2.3 系统界面…
阅读更多...
CSDN博客专家证书发放名单（2023年3月已更新）

CSDN博客专家证书发放名单（2023年3月已更新）

目录 证书发放频次 6月&#xff08;第一批&#xff09;证书发放名单&#xff08;80位&#xff09; 7月&#xff08;第二批&#xff09;证书发放名单&#xff08;50位&#xff09; 8月&#xff08;第三批&#xff09;证书发放名单&#xff08;54位&#xff09; 9月&#xf…
阅读更多...
2个月月活突破1亿，增速碾压抖音，出道即封神的ChatGPT，现在怎么样了？ChatGPT它会干掉测试？

2个月月活突破1亿，增速碾压抖音，出道即封神的ChatGPT，现在怎么样了？ChatGPT它会干掉测试？

从互联网的普及到智能手机&#xff0c;都让广袤的世界触手而及&#xff0c;如今身在浪潮中的我们&#xff0c;已深知其力。 前阵子爆火的ChatGPT&#xff0c;不少人保持观望态度。现如今&#xff0c;国内关于ChatGPT的各大社群讨论&#xff0c;似乎沉寂了不少&#xff0c;现在…
阅读更多...
最新文章

Copyright @ 2022~2023