JAVA学习笔记（十一）

最新推荐文章于 2024-08-18 21:36:31 发布
最新推荐文章于 2024-08-18 21:36:31 发布
阅读量288 收藏 2
点赞数 3
文章标签： java 学习 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/JiaXingNashishua/article/details/123228668
版权

目录

一：Set（续）

二：泛型

一：Set（续）

1.1 LinkedHashSet集合概述和特点：

  • 哈希表和链表实现的set接口，具有可预测的迭代次序。
  • 由链表保证元素有序，也就是说元素的存储和取出顺序是一致的。
  • 由哈希表保证元素唯一，也就是说没有重复元素。

1.2 Treeset集合概述和特点

treeSet集合特点：

  • 元素有序，这里的顺序不是指存储和取出的顺序，而是按照一定的规则进行排序，具体排序方式取决于构造方法。

TreeSet（）：根据其元素的自然排序进行排序

TreeSet（Comparator comparator）：根据指定的比较器进行排序

  • 没有带索引的方法，所以不能使用普通for循环遍历。
  • 由于是Set集合，所以不包含重复元素的集合。
import java.util.*;
public class Main {
    public static void main(String[] args) {
      TreeSet<Integer> ts=new TreeSet<>();
      ts.add(10);
      ts.add(40);
      ts.add(30);
      ts.add(50);
      ts.add(20);
      //TreeSet不包含重复元素
      ts.add(30);
      for(Integer i:ts){
          System.out.println(i);
      }
    }
}

1.3 自然排序Comparable的使用

  • 存储学生对象并遍历，创建TreeSet集合使用无参构造方法
  • 要求：按照年龄从小到大排序，年龄相同时，按照名字的字母顺序排序。
import java.util.TreeSet;
public class Main {
    public static void main(String[] args) {
        //创建集合对象
        TreeSet<student> ts = new TreeSet<>();
        //创建学生对象
        student s1=new student("小明",19);
        student s2=new student("小白",18);
        student s3=new student("小黑",20);
        student s4=new student("小黄",22);
        student s5=new student("小绿",22);
        student s6=new student("小绿",22);
        ts.add(s1);
        ts.add(s2);
        ts.add(s3);
        ts.add(s4);
        ts.add(s5);
        ts.add(s6);
        //保证元素的唯一性
        //遍历集合
        for(student s:ts){
            System.out.println(s.getName()+","+s.getAge());
        }
    }
}

class student implements Comparable<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 int compareTo(student s) {
        //return 1;    正向输出
        // return -1;   逆向输出

        //年龄由小到大排序
        int num=this.age-s.age;
        int num2=num==0?this.name.compareTo(s.name):num;
        return num2;
    }
}

结论：

  • 用TreeSet集合存储自定义对象，无参构造方法使用的是自然排序对元素进行排序的。
  • 自然排序，就是让元素所属的类实现Comparable接口，重写comparableTo（To）方法。
  • 重写方法时，一定要注意排序规则必须按照；要求的主要条件和次要条件来写。

1.4 比较器排序Comparator的使用

  • 存储学生对象并遍历，创建TreeSet集合使用带参构造方法
  • 要求：按照年龄从小到大排序，年龄相同时，按照姓名的字母顺序排序
import java.util.Comparator;
import java.util.TreeSet;
public class Main {
    public static void main(String[] args) {
        //创建集合对象
        TreeSet<student> ts=new TreeSet<student>(new Comparator<student>() {
            @Override
            public int compare(student s1,student s2) {
                int num=s1.getAge()-s2.getAge();
                int num2=num==0?s1.getName().compareTo(s2.getName()):num;
                return num2;
            }
        });

        student s1=new student("小明",19);
        student s2=new student("小白",18);
        student s3=new student("小黑",20);
        student s4=new student("小黄",22);
        student s5=new student("小绿",22);
        student s6=new student("小绿",22);
        ts.add(s1);
        ts.add(s2);
        ts.add(s3);
        ts.add(s4);
        ts.add(s5);
        ts.add(s6);
        //保证元素的唯一性
        //遍历集合
        for(student s:ts){
            System.out.println(s.getName()+","+s.getAge());
        }
    }
}


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

结论：

  • 用TreeSet集合存储自定义对象，带参构造方法使用的是比较器排序对元素进行排序的
  • 比较器排序，就是集合构造方法接收Comparator的实现类对象，重写compare（To1，To2）方法
  • 重写方法时，一定要注意排序规则必须按照要求的主要条件和次要条件来写。

二：泛型

2.1 泛型概述：

泛型：是JDK5中引入的特性，它提供了编译时类型安全检测机制，该机制允许在编译时检测到非法的类型。

它的本质是参数化类型，也就是说操作的数据类型被指定为一个参数。

一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参，那么参数化类型怎么理解呢？

顾名思义，就是将类型由原来的具体的类型参数化，然后在使用/调用时传入具体的类型

这种参数类型可以用在类、方法和接口中，分别被称为泛型类、泛型方法、泛型接口

 泛型的好处：

  • 把运行时期的问题提前到了编译期间。
  • 避免了强制类型转换。
public class Main {

    public static void main(String[] args) {
       Generic<String> g=new Generic<String>();
       g.setT("java");
        System.out.println(g.getT());
        Generic<Integer> g1=new Generic<Integer>();
        g1.setT(123);
        System.out.println(g1.getT());
        Generic<Boolean> g2=new Generic<Boolean>();
        g2.setT(true);
        System.out.println(g2.getT());

    }
}

class Generic<T> {
    private T t;

    public Generic() {
    }

    public Generic(T t, T t1, T t2) {
        this.t = t;
    }

    public T getT() {
        return t;
    }

    public void setT(T t) {
        this.t = t;
    }


}

2.2 泛型方法

public class Main {
    public static void main(String[] args) {
        Generic g=new Generic();

        g.show("123");
        g.show('a');
        g.show(true);
        g.show(12.13);

    }
}
class Generic<T> {
    public void show(T t) {
        System.out.println(t);
    }
}

2.3 泛型接口

格式：修饰符interface接口名<类型>{}

范例：public interface Generic<T>{}

public class Main {
    public static void main(String[] args) {
        Genericimpl<String> g = new Genericimpl<String>();
        g.show("java");
        Genericimpl<Integer> g1=new Genericimpl<Integer>();
        g1.show(1);
        Genericimpl<Boolean> g2=new Genericimpl<Boolean>();
        g2.show(true);
    }
}

interface Generic<T> {
    void show(T t);
}

class Genericimpl<T> implements Generic<T> {
    @Override
    public void show(T t) {
        System.out.println(t);
    }
}

2.4 类型通配符：

为了表示各种泛型List的父类，可以使用类型通配符。

  • 类型通配符：<?>
  • List<?>:表示元素类型位置的List，它的元素可以匹配任何的类型。
  • 这种带通配符的List仅表示它是各种泛型LIst的父类，并不能把元素添加到其中

如果说我们不希望List<?>是任何泛型List的父类，只希望它代表某一类泛型List的父类，可以使用类型通配符的上限。

  • 类型通配符上限：<?extends 类型>
  • List<?extends Number>:它表示的类型是Number或者其子类型。

除了可以指定类型通配符的上限，我们也可以指定类型通配符的下限

  • 类型通配符下限：<?super 类型>
  • List<?super Number>:它表示的类型是Number或者其父类型。
import java.util.*;

public class Main {
    public static void main(String[] args) {
       //类型通配符，<?>
        List<?> list1=new ArrayList<Object>();
        List<?> list2=new ArrayList<Number>();
        List<?> list3=new ArrayList<Integer>();
        System.out.println("--------------");
        //类型通配符上限：<? extends 类型>
       // List<? extends Number> list4 = new ArrayList<Object>();  报错
        List<? extends Number> list5 = new ArrayList<Number>();
        List<? extends Number> list6 = new ArrayList<Integer>();
        System.out.println("--------------");
        //类型通配符下限：<? super 类型>
        List<? super Number> list7 = new ArrayList<Object>();
        List<? super Number> list8 = new ArrayList<Number>();
        //List<? super Number> list9=new ArrayList<Integer>();  报错

    }
}

2.5 可变参数

可变参数又称参数个数可变，用作方法的形参出现，那么方法参数个数就是可变的了。

  • 格式：修饰符 返回值类型 方法名（数据类型...变量名）{}
  • 范例：public static int usm（int...a）{}

可变参数注意事项

  • 这里的变量其实是一个数组。
  • 如果一个方法有多个参数，包含可变参数，可变参数要放到最后。
public class Main {
    public static int sum(int b,int... a){
        int sum=b;
        for(int i:a){
            sum+=i;
        }
        return sum;
    };
    public static void main(String[] args) {

        System.out.println(sum(10,20,30,40));//100

    }
}

2.6 可变参数的使用

  

大数据阿嘉
关注
  • 3
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
JavaSE学习过程中问题总结 —— 集合框架、IO流、多线程等
Yshen的博客
03-31 1693
回顾完基本概念和一些常用类，进入重点：（内容很多但没有分文章写，主要是自己的知识巩固和做下笔记，不够负责任，算不上知识分享）一、集合框架1、集合引入（1）对象数组的概念：将多个类对象存放为数组特点：长度固定，不适应变化的需求。（2）面向对象强调的是对象，需要容器来进行存储和操作之前提过StringBuffer虽然是一种容器，但只存放字符串如果没有集合，我们只能选择对象数组，但并不能满足需求所以Ja...
java学习笔记总结
04-02
这份“java学习笔记总结”涵盖了作者在深入学习Java过程中积累的知识点和实践经验，旨在帮助读者理解和掌握Java的核心概念。 首先，Java的基础部分包括语法、变量、数据类型、运算符和流程控制。Java支持八种基本...
java程序员从笨鸟到菜鸟之(二十八)集合TreeSet排序之compareTo和compare方法
wzj_110的博客
11-16 1052
TreeSet 无参构造方法 特点：该set集合根据其元素的自然顺序进行排序；插入该 set 的所有元素都必须实现 Comparable 接口。另外所有这些元素都必须是相互可比较的。 分析：通过源码我们可以知道内部创建Comparable比较器对象，调用了元素键对象类型的compareTo方法 实现Comparable接口的常用类：Integer、String等 实例1 packag
集合类 Set
海阔天空的专栏
08-06 279
1 Set集合 (1)元素不重复 (2)没有带索引的方法，所以不能使用普通for循环遍历 2 HashSet (1)元素不重复 (2)没有带索引的方法，所以不能使用普通for循环遍历 (3)底层结构是哈希表 (4)不保障存储和取出的元素顺序一致 (5)在使用HashSet时，内容相同的不同对象，HashSet认为是不重复的。如果我们要实现相同内容不重复，需要在相应的类中使用Alt+Insert自动生成的方式重写equals()和hashCode()方法 3 LinkedHashSet集合 哈希表和链表实
java-11.12
qaqaqaerw的博客
11-14 193
Set接口:Set集合继承自Collection集合       Set:底层数据结构是一个哈希表,能保证元素是唯一的,元素不重复!                 它通过它的子实现了HashSet集合去实例化,HashSet集合底层是HashMap集合的实例! package org.lemon.Set; import java.util.HashSet; import java.u
java集合总结
铁马冰河入梦来
06-22 710
转载请注明出处:Java集合中List,Set以及Map等集合体系详解(史上最全) 概述: List , Set, Map都是接口，前两个继承至Collection接口，Map为独立接口 Set下有HashSet，LinkedHashSet，TreeSet List下有ArrayList，Vector，LinkedList Map下有Hashtable，LinkedHashMap，HashMap，TreeMap Collection接口下还有个Queue接口，...
Java学习笔记
Piglett的博客
12-30 986
随着后续的学习还会不断地更新，并不仅仅包含Java基础，后续还会更新SSM，MySQL等内容。其记录了Java基础的学习内容，主要包括24集合到30动态代理（见语雀目录）。希望这篇笔记能够帮助到Java的学习，方便快速进行回顾复习。
Java 学习笔记
weixin_42098295的博客
05-13 2001
Java 是一种面向对象的编程语言，广泛应用于开发各种应用程序，包括 Web 应用程序、桌面应用程序、移动应用程序和嵌入式系统。Java 中有八种基本数据类型：byte、short、int、long、float、double、char 和 boolean。集合用于存储和组织数据。Java 中有各种控制流语句，用于控制程序流程，例如 if-else 语句、switch 语句和循环语句。Java 中有各种运算符，用于执行算术运算、比较运算、逻辑运算和位运算。I/O 用于从文件、网络和其他来源读取和写入数据。
java学习笔记（持续更新）
快乐学习，daydayup!
12-24 7652
如果您也在学习java，希望能够和您一起讨论，一起学习。这篇文章是记录笔者0基础学习java的过程，如果您阅读这篇文章时，发现一些错误，也希望您愿意指出。本次java学习流程以黑马程序员的java教学视频为主，其他博主或公开教程为辅。学习过程中遇到的一些个别情况或错误都会记录其中并记载解决方案。本篇学习记录会一直更新，希望能与大家一起学习，共同成长。
Java 学习笔记：面向对象
Li__Daxia的博客
03-19 1057
Java 学习笔记：面向对象
Thinking in Java读书笔记
热门推荐
yjclsx的博客
07-31 42万+
Thinking in Java读书笔记（IO和并发除外） 1.1、类中所有的private方法都隐式地指定为final的，由于其他类无法取用private方法，所以也就无法覆盖它；private方法无法被重写，继承对应private的方法无效，private的属性也无法拿到，但我们通常private的属性有对应的get、set方法，通常是public的，所以子类继承后可以调用方法来取得到父类的...
Java基础 学习笔记 Markdownr版
06-27
本学习笔记主要涵盖了Java的基础知识，包括面向对象、集合、IO流、多线程、反射与动态代理以及Java 8的新特性等方面，旨在帮助初学者或有经验的开发者巩固和提升Java编程技能。 1. 面向对象（OOP）：Java的核心是...
java学习笔记.zip
11-16
java学习笔记java学习笔记.zipjava学习笔记.zipjava学习笔记.zipjava学习笔记.zipjava学习笔记.zipjava学习笔记.zipjava学习笔记.zipjava学习笔记.zipjava学习笔记.zipjava学习笔记.zipjava学习笔记.zipjava学习笔记...
java学习笔记markdown
03-12
【Java学习笔记Markdown版】是针对Java初学者和进阶者的一份详尽教程，以Markdown格式编写，便于阅读和整理。Markdown是一种轻量级的标记语言，它允许用户使用易读易写的纯文本格式编写文档，然后转换成结构化的HTML...
java学习笔记资源合集
05-25
java学习笔记 Java 自 1995 年诞生，至今有 16 年的历史，从诞生之日起，逐渐被广泛接受并成为推 动了 web 迅速发展。Java 的三种核心机制为虚拟机机制、代码安全机制、垃圾回收机制。 Java 最大的特点是平台无关性...
JAVA进阶补充
2301_80150315的博客
08-15 959
概念：把已经有的方法拿过来用，当作函数式接口中抽象方法的方法体条件：引用处必须是函数式接口被引用的方法需要已经存在被引用方法的形参和返回值需要跟抽象方法的形参和返回值保持一致被引用方法的功能需要满足当前需求：方法引用符意义：就是为让控制台的报错信息更加的见名知意自定义异常的步骤：定义异常类写继承关系空参构造带参构造​file对象就表示一个路径，可以是文件的路径、也可以是文件夹的路径；这个路径可以是存在的，也允许是不存在的构造方法描述根据文件路径创建对象。
Java基础之原反补码
u012135697的博客
08-14 465
整数类型数据在计算机底层进行存储或运算，以补码方式进行！ 正整数的原反补码，一模一样！
【Spring框架】
最新发布
m0_71941456的博客
08-18 641
Spring框架的功能远不止于此，它还包括Spring MVC、Spring Data、Spring Security等多个模块，每个模块都有其独特的应用场景。
进程间通信 ---共享内存
BUG制造机的博客
08-14 1099
在这篇文章中向大家介绍了共享内存的原理以及常用的指令函数，希望大家有所收获！😁。
Java学习笔记：从入门到精通
"这是一份详尽的Java学习笔记电子书，特别适合初学者。书中内容细致入微，涵盖了从基础到进阶的各种知识点，通过图片形式生动地展示了Java编程的核心概念。" 在Java学习过程中，了解对象的概念是至关重要的。粗粒度...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值