Java-API基础 04

于 2024-07-30 10:42:47 发布
阅读量247 收藏 3
点赞数 5
分类专栏： Java 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_68522070/article/details/140790851
版权

1. List接口：

  • 继承自Collection接口，List集合是可重复集合，并且有序，还提供了一套可以通过下标来操作元素的方法

  • 常见的实现类：

    • ArrayList：内部使用数组实现，查询性能更好(直接下标找到物理地址)、增删性能不好

    • LinkedList：内部使用链表实现，查询性能不好，首尾增删性能好

      注意：在对集合操作的增删性能没有特别苛刻的要求时，通常选择ArrayList

2. List集常用方法：

  • get()：根据下标获取元素

  • set()：将指定元素设置到指定位置，并返回被替换的元素(用时才接收)

  • 重载remove()：删除指定位置元素，并返回被删除的元素(用时才接收)

  • 重载add()：将指定元素添加到指定位置，理解为插入操作

    package collection;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
/**
 * List集合的演示
 */
public class ListDemo {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("one");
        list.add("two");
        list.add("three");
        list.add("four");
        list.add("five");
        list.add("one");
        System.out.println("list:"+list); //[one, two, three, four, five, one]

        //E get(int index):获取指定下标所对应的元素
        String e = list.get(2); //获取第3个元素
        System.out.println(e); //three

        for(int i=0;i<list.size();i++){
            System.out.println(list.get(i));
        }
        for(String s : list){
            System.out.println(s);
        }
        Iterator<String> it = list.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }

        System.out.println("-----------------------");

        //E set(int index,E e):将给定元素设置到指定位置，返回被替换的元素
        //list.set(2,"six"); //将list中下标为2的元素设置为six---常规用法
        String old = list.set(2,"six"); //将list中下标为2的元素设置为six，同时将原数据返回给old
        System.out.println(old); //three
        System.out.println("list:"+list); //[one, two, six, four, five, one]

        //E remove(int index):删除指定位置元素，并返回被删除的元素
        //list.remove(2); //删除下标为2的元素---常规用法
        String s = list.remove(2); ///删除下标为2的元素，并将被删除元素返回给s
        System.out.println(s); //six
        System.out.println("list:"+list); //[one, two, four, five, one]

        //void add(int index,E e):将给定元素e添加到index所指定的位置，相当于插入操作
        list.add(3,"seven"); //在list下标为3的位置插入seven
        System.out.println("list:"+list); //[one, two, four, seven, five, one]
    }
}

  • subList()：获取集合的子集(含头不含尾)

    package collection;
import java.util.ArrayList;
import java.util.List;
/**
 * subList()获取子集的演示
 */
public class SubListDemo {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        for(int i=0;i<10;i++){
            list.add(i*10);
        }
        System.out.println("list:"+list); //[0, 10, 20, 30, 40, 50 ,60, 70, 80, 90]

        //List subList(int start,int end):含头不含尾
        List<Integer> subList = list.subList(3,8);  //获取下标3到7的子集
        System.out.println("subList:"+subList); //[30, 40, 50 ,60, 70]

        //将子集每个元素都扩大10倍
        for(int i=0;i<subList.size();i++){
            subList.set(i,subList.get(i)*10);
        }
        System.out.println("subList:"+subList); //[300, 400, 500 ,600, 700]
        //对子集的操作就是对原集合对应的元素操作
        System.out.println("list:"+list); //[0, 10, 20, 300, 400, 500 ,600, 700, 80, 90]

        list.set(3,1000); //将原集合下标为3的元素修改为1000
        System.out.println("list:"+list); //[0, 10, 20, 1000, 400, 500 ,600, 700, 80, 90]
        //原集合数据改变后，子集也跟着变了
        System.out.println("subList:"+subList); //[1000, 400, 500 ,600, 700]

        //对子集增删后，原集合跟着改
        subList.remove(0);
        System.out.println("subList:"+subList);
        System.out.println("list:"+list);

        //对原集增删后，子集不能再进行操作了----因为载体变了
        list.remove(0);
        System.out.println("list:"+list);
        //System.out.println("subList:"+subList); //运行时发生不支持修改异常
    }
}

3. 集合排序：

  • Collections为集合的工具类，里面定义了很多静态方法用于操作集合

  • Collections.sort(List list)方法：可以对list集合进行自然排序(从小到大)，但是其要求List集合中的元素必须是可比较的，判断是否可以比较的标准是元素是否实现了Comparable接口，若没有实现该接口则直接发生编译错误，但是在实际开发中，我们一般是不会不让我们自己写的类去实现Comparable接口的，因为这对我们的程序有侵入性。

  • 侵入性：当我们调用某个API功能时，其要求我们为其修改其它额外的代码，这个现象叫做侵入性。侵入性越强越不利于程序的后期维护，应尽量避免。

  • 建议使用重载的Collections.sort(List list, Comparator o);可以通过Comparator来自定义比较规则

    package collection;
import java.util.Random;
import java.util.List;
import java.util.ArrayList;
import java.util.Collections;
/**
 * 对Integer元素数据排序
 */
public class SortInteger {
    public static void main(String[] args) {
        Random rand = new Random();
        List<Integer> list = new ArrayList<>();
        for(int i=0;i<10;i++){
            list.add(rand.nextInt(100));
        }
        System.out.println("list原始数据:"+list);

        Collections.sort(list); //自然排序(从小到大)
        System.out.println("list排序后数据:"+list);

        Collections.reverse(list); //反转list集合(数据已经变了--大到小)
        System.out.println("list反转后数据:"+list);
        System.out.println("第1个元素为:"+list.get(0)); //大
    }
}

package collection;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

/**
 * 对String元素排序
 */
public class SortString {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("王克晶");
        list.add("传奇sdfsdf");
        list.add("国斌老师");
        System.out.println("list原始数据: "+list); //[王克晶, 传奇djflkjflw, 国斌老师]

        //自定义排序规则:
        Collections.sort(list, new Comparator<String>() {
            /*
              compare()方法用于定义o1和o2比较大小的规则，它的返回值表达大小关系
              结论:
                1)前面的-后面的------------升序
                2)后面的-前面的------------降序
             */
            public int compare(String o1, String o2) {
                //return o1.length()-o2.length(); //升序
                return o2.length()-o1.length(); //降序
            }
        });

        //Lambda简化版
        Collections.sort(list, (o1,o2)->o1.length()-o2.length());

        System.out.println("list排序后数据:"+list);

        /*
        List<String> list = new ArrayList<>();
        list.add("jack");
        list.add("rose");
        list.add("tom");
        list.add("jerry");
        list.add("black");
        list.add("Kobe");
        System.out.println("list原始数据:  "+list); //[jack, rose, tom, jerry, black, Kobe]

        //对英文字符串排序时，会按首字母的ASCII码来排
        //若首字母相同，则比较第2个字母的ASCII码，以此类推
        Collections.sort(list);
        System.out.println("list排序后数据:"+list);
         */

    }
}

public class SortPoint {
    public static void main(String[] args) {
        List<Point> list = new ArrayList<>();
        list.add(new Point(5,8));
        list.add(new Point(15,60));
        list.add(new Point(57,89));
        list.add(new Point(1,4));
        list.add(new Point(10,8));
        list.add(new Point(22,35));
        System.out.println("list原始数据:"+list);

        //jdk1.8时，List集合自身提供了sort方法进行排序，方法中需要传入比较器
        list.sort(new Comparator<Point>() {
            public int compare(Point o1, Point o2) {
                return o1.getX()-o2.getX();
            }
        });
        System.out.println("list排序后数据:"+list);

        list.sort((o1,o2)->{
            int len1 = o1.getX()*o1.getX()+o1.getY()*o1.getY();
            int len2 = o2.getX()*o2.getX()+o2.getY()*o2.getY();
            return len1-len2; //升序
        });

        /*
        //自定义排序规则:
        Collections.sort(list, new Comparator<Point>() {
            public int compare(Point o1, Point o2) {
                int len1 = o1.getX()*o1.getX()+o1.getY()*o1.getY();
                int len2 = o2.getX()*o2.getX()+o2.getY()*o2.getY();
                //return len1-len2; //升序
                return len2-len1; //降序
                //return o1.getX()-o2.getX(); //按x坐标升序
                //return o2.getY()-o1.getY(); //按y坐标降序
            }
        });
         */
        Collections.sort(list,(o1,o2)->{
            int len1 = o1.getX()*o1.getX()+o1.getY()*o1.getY();
            int len2 = o2.getX()*o2.getX()+o2.getY()*o2.getY();
            return len1-len2; //升序
        });

        System.out.println("list排序后数据:"+list);

    }
}

4. Lambda表达式：

  • JDK1.8之后推出了一个新特性：Lambda表达式

  • 规则：

    • 不是任何匿名内部类都可以转换为Lambda表达式
    • Lambda表达式对接口的要求：只能是函数式接口
    • 函数式接口:接口中要求实现类必须重写的方法只有一个

  • 语法：

    (参数列表)->{
   方法体
}

    public class LambdaDemo {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();

        //匿名内部类写法
        Collections.sort(list, new Comparator<String>() {
            public int compare(String o1, String o2) {
                return o1.length()-o2.length();
            }
        });

        //Lambda表达式写法
        Collections.sort(list, (String o1, String o2) -> {
                return o1.length()-o2.length();
        });

        //Lambda表达式中的参数类型可以不写
        Collections.sort(list, (o1, o2) -> {
            return o1.length()-o2.length();
        });

        //Lambda表达式方法体中只有一句代码，方法体的{}可以不写，如果这句话中有return，也一并不写
        Collections.sort(list, (o1, o2) -> o1.length()-o2.length());

        //Lambda表达式的方法参数只有1个,那么()可以忽略不写---本案例不适用

    }
}

5. Set接口：

  • 不可重复集合，并且大部分实现类都是无序的

    package collection;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

/**
 * Set集合的演示
 */
public class SetDemo {
    public static void main(String[] args) {
        Set<String> set = new HashSet<>();
        set.add("one");
        set.add("two");
        set.add("three");
        set.add("four");
        set.add("five");
        set.add("two"); //无法被正确添加进去，因为Set集是不可重复集合
        System.out.println(set); //并且大部分实现类都是无序的
    }
}

  • 小面试题：如何去重？

    package collection;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

/**
 * Set集合的演示
 */
public class SetDemo {
    public static void main(String[] args) {
        //小面试题:如何去重?
        List<String> list = new ArrayList<>();
        list.add("one");
        list.add("two");
        list.add("three");
        list.add("four");
        list.add("five");
        list.add("two");
        System.out.println("list:"+list); //[one, two, three, four, five, two]

        Set<String> set = new HashSet<>();
        set.addAll(list); //将list集合元素添加到set集合中，重复的添加不进去
        System.out.println("set:"+set); //[one, two, three, four, five]
    }
}
字节探索者
关注
  • 5
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
【Java基础知识 1】Java入门级概述
学Java，找哪吒
09-25 15万+
CSDN最强Java专栏，包含全部Java基础知识点、Java8新特性、Java集合、Java多线程、Java代码实例，理论结合实战，实现Java的轻松学习。
飞书组织架构同步（部门和用户） Java-API 的使用
wxhyc2019的博客
02-23 5164
飞书组织架构对接 Java-API 的使用 概述 本次实现主要针对飞书平台的基础通讯录功能（ContantService）的使用 实现把本地本地批量导入飞书平台。
java使用ews-java-api发送邮件（包括附件和内联图片处理）
qq_35614141的博客
08-04 1851
java使用ews-java-api发送邮件（包括附件和内联图片处理）
亚马逊SP-API对接JAVA版(amazon selling-partner)
热门推荐
乔丹码得的博客
02-01 1万+
背景： 亚马逊(amazon)在2020年10月推出了新的替代mws的api方案，称为Selling Partner API(SP-API)。sp-api在修改原mws的接口方式的基础上引入了aws的IAM权限管理，增加了开发者的对接门坎和学习成本。这里整理了一份java版的对接信息，供大家借鉴 MWS: 对接的文档介绍document:http://docs.developer.amazonservices.com/en_US/dev_guide/index.html ...
ZooKeeper-API基础--头歌平台
m0_46560176的博客
05-04 3007
第1关：会话创建与关闭 合集 import java.io.IOException; import org.apache.zookeeper.WatchedEvent; import org.apache.zookeeper.Watcher; import org.apache.zookeeper.ZooKeeper; public class test1 { // 初始化 ZooKeeper 实例 private ZooKeeper zk; // 实现一个 Watcher .
Java-API简析_java.lang.reflect.Method类（基于 Latest JDK）（浅析源码）
进步*于辰的博客
07-15 1万+
本篇文章是我解析Java-API的笔记，更多的是从方法着手，少对类的整体情况进行说明，故并不详尽，可供大家参考。 如果文中阐述不全或不对的，多多交流。
Java-API简析_java.lang.reflect.Constructor＜T＞类（基于 Latest JDK）（浅析源码）
进步*于辰的博客
03-30 1万+
本篇文章是我解析Java-API的笔记，更多的是从方法着手，少对类的整体情况进行说明，故并不详尽，可供大家参考。 如果文中阐述不全或不对的，多多交流。
Java基础--API文档是什么
为什么我的眼里常含泪水？
11-16 9069
API文档是什么？ 开发一个大型软件时，需要定义成千上万的类，而且需要很多人参与开发。每个人都会开发一些类，并在类里面定义一些方法，成员变量提供给其他人使用。但其他人怎么知道如何使用这些类和方法呢？ 这时候就需要提供一份说明文档，用于说明每个类，每个方法的用途。当其他人使用一个类或者一个方法时，她无需关系这个类或者方法的具体实现，只需要知道这个类或者方法的功能即可，然后使用这个类或者方法来实现具体...
Java-日期时间API（详解）
weixin_52533007的博客
08-31 2512
本博主将用CSDN记录软件开发求学之路上亲身所得与所学的心得与知识，有兴趣的小伙伴可以关注博主！也许一个人独行，可以走的很快，但是一群人结伴而行，才能走的更远！让我们在成长的道路上互相学习，欢迎关注！System类提供的用来返回当前时间与1970年1月1日0时0分0秒之间以毫秒为单位的时间差。//返回当前时间与1970年1月1日0时0分0秒之间以毫秒为单位的时间差。//称为时间戳 System . out . println(time);表示特定的瞬间，精确到毫秒类为。...
在Java中调用ETCD使用JETCD--API3 基础部分
qq_35336312的博客
06-03 3752
这里写自定义目录标题欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 欢迎使用Markdown编辑器 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Mar
java-gitlab-api-master.zip
05-12
除了这些基础操作，你还可以通过这个Java库实现更多高级功能，如提交代码、创建分支、管理标签、触发持续集成/持续部署(CI/CD)流程等。在实际开发中，需要熟悉GitLab API的文档，了解每个端点的具体用法，并结合`...
client-java-api
03-22
一个玩具项目，可作为我撰写的有关Java + Spring的中型系列文章的理论基础。 API主网址/api-travels/v1 。特征该API为以下提供HTTP端点和工具： 创建行程： POST/api-travels/v1/travels 更新行程： PUT/api-...
zookeeper-api基础java案例.zip
06-21
zookeeper-api基础java案例.zipzookeeper-api基础java案例.zipzookeeper-api基础java案例.zipzookeeper-api基础java案例.zipzookeeper-api基础java案例.zipzookeeper-api基础java案例.zipzookeeper-api基础java案例....
java-ee-api原版
01-30
这个"java-ee-api原版"的压缩包很可能包含了Java EE 6的官方API文档，它是开发人员在使用Java EE 6进行开发时的重要参考资料。下面我们将深入探讨Java EE 6的一些核心概念和技术。 Java EE 6的引入是为了简化企业级...
Java-api-mac
04-04
Java API for Mac，简称为Java-API-Mac，是专门为苹果Mac操作系统设计的一套Java开发接口。这个API使得Java开发者能够充分利用Mac平台特有的功能和特性，如Aqua界面、Carbon库集成以及Core Foundation框架等，从而...
使用hutool工具判断字符串是否全部是字母(包括大小写)，java判断字符串是否全部是字母(包括大小写)
最新发布
qq_43700885的博客
07-29 251
1.导入hutool的maven依赖。2.复制一下代码执行。
golang 接口
m0_70982551的博客
07-24 1009
接口定义了一组方法，这些方法没有具体的实现。接口类型的变量可以存储任何实现了这些方法的类型的值。// 更多方法...在Go语言中，接口值是指存储了实现某个接口的具体类型值的变量。接口值由两部分组成：1.动态类型：这是接口值当前存储的实际类型。2.动态值：这是实际存储的值，该值必须实现了接口中定义的所有方法。
java判断邮箱地址是否正确，使用hutool工具判断邮箱地址是否正确
qq_43700885的博客
07-29 95
1.导入hutool的maven依赖。2.直接复制一下代码运行。
Swagger使用Map接受参数时，页面如何显示具体参数及说
a1058926697的博客
07-26 543
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

字节探索者

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值