APIDay04ListSet

最新推荐文章于 2024-08-10 16:13:20 发布
最新推荐文章于 2024-08-10 16:13:20 发布
阅读量36 收藏
点赞数
文章标签： java 数据结构 面试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zjx0519/article/details/129959046
版权 
笔记：

1. List接口：

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

   - 常见的实现类：

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

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

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

2. List集常用方法：

   - get()：根据下标获取元素
   - set()：将指定元素设置到指定位置，并返回被替换的元素(用时才接收)
   - 重载remove()：删除指定位置元素，并返回被删除的元素(用时才接收)
   - 重载add()：将指定元素添加到指定位置，理解为插入操作
   - subList()：获取集合的子集(含头不含尾)

3. 集合排序：

   - Collections为集合的工具类，里面定义了很多静态方法用于操作集合
   - Collections.sort(List list)方法：可以对list集合进行自然排序(从小到大)，但是其要求List集合中的元素必须是可比较的，判断是否可以比较的标准是元素是否实现了Comparable接口，若没有实现该接口则直接发生编译错误，但是在实际开发中，我们一般是不会不让我们自己写的类去实现Comparable接口的，因为这对我们的程序有侵入性。
   - 侵入性：当我们调用某个API功能时，其要求我们为其修改其它额外的代码，这个现象叫做侵入性。侵入性越强越不利于程序的后期维护，应尽量避免。
   - 建议使用重载的Collections.sort(List list, Comparator o);可以通过Comparator来自定义比较规则

4. Lambda表达式：

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

   - 规则：

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

   - 语法：

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

5. Set接口：

   - 不可重复集合，并且大部分实现类都是无序的
   - 小面试题：如何去重？



## 笔记：

1. List接口：

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

   - 常见的实现类：

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

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

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

2. List集常用方法：

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

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

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

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

     ```java
     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()：获取集合的子集(含头不含尾)

     ```java
     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来自定义比较规则

     ```java
     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表达式对接口的要求：只能是函数式接口
     - 函数式接口:接口中要求实现类必须重写的方法只有一个

   - 语法：

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

     ```java
     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接口：

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

     ```java
     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); //并且大部分实现类都是无序的
         }
     }
     ```

   - 小面试题：如何去重？

     ```java
     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]
         }
     }
     ```



## 补充：

1. 匿名内部类中不能修改外面局部变量的值，因为在此处变量会默认为final的

2. 方法重写时，要求：派生类方法的访问权限必须大于或等于超类方法中

3. 接口补充：

   ```java
   package collection;
   /**
    * 接口补充
    */
   public class InterfaceMore {
   }
   
   //接口中可以包含:
   interface Inter1{
       public abstract void show(); //抽象方法-----用得最多
   
       public static final int NUM = 5; //常量----用得少
   
       public default void test(){ //默认方法----用得少，jdk1.8加入的
       }
   
       public static void say(){ //静态方法------用得少，jdk1.8加入的
       }
   }
   
   //接口中的成员访问权限只能是public(默认也是public)
   interface Inter{
       public abstract void show();
       void test(); //接口中成员访问权限默认是public的
   }
   abstract class Aoo{
       abstract void say(); //类中成员访问权限默认是默认权限
   }
   //方法重写时，要求：派生类方法的访问权限必须大于或等于超类方法中
   class Boo extends Aoo implements Inter{
       //重写方法时，访问权限必须大于或等于超类方法的
       public void show(){}
       public void test(){}
       void say(){}
   }
zjx0519
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
Java初学笔记APIday04--List接口、List接口常用方法、ArrayList、接口的排序、Lambda表达式、Set接口、HashSet
Ice_bear08042的博客
04-04 284
Collection.sort(List list)方法：可以对list集合进行自然排序（从小到大）但是其要求List集合中的元素必须是比较的，判断是否可以比较的标准是元素是否实现了Comparable接口，若没有实现该接口则直接发生编译错误，但是在实际开发中，我们一般是不会让我们自己写的类去实现Comparable接口的，因为这对我们的程序有侵入性。继承自Collection接口，List集合是可以重复集合的，并且有序，还提供了一套可以通过下标来操作元素的方法。不可重复集合，并且大部分实现类都是无序的。
集合Collection
ConSelt的博客
01-08 146
Java常见API
APIDay04
m0_74741009的博客
10-29 275
API基础Day04
Java中的集合Collection，List，Set
xiao610212b的博客
08-28 265
Java初学者中的集合Collection，List，Set
API接口第四天 list集合 set集合
m0_61332438的博客
10-28 566
list集合 set集合
javaapi2
weixin_51599093的博客
10-02 106
集合.Collection顶级接口,下面List 和Set
第二阶段：JavaAPI总复习一一一之一一一02
weixin_59404863的博客
02-23 568
1、
API day01
weixin_50831410的博客
09-28 99
List 接口 常见方法 集合的排序 set接口
【java基础，API基础三】集合、Collection常用方法、 集合的遍历、增强for循环/新循环、泛型、集合与数组之间转换
居然天上楼的博客
09-27 295
集合、Collection常用方法、 集合的遍历、增强for循环/新循环、泛型、集合与数组之间转换。集合和数组一样，可以保存一组数据，并且提供了操作集合元素的相关方法，使用更加方便- 集合和数组一样，可以保存一组数据，并且提供了操作集合元素的相关方法，使用更加方便。
ApiDay06Test.java
05-25
ApiDay06Test.java
apiday02标准练习.md
10-26
apiday02标准练习.md
APIday02 (1).md
04-19
APIday02 (1).md
C++ - 函数重载
jiaowenjie的专栏
08-06 324
/打印的是第二个函数的地址。//打印的是第一个函数的地址。-> 重载函数在本质上是相互独立的不同函数。-> 函数返回值不能作为函数重载的依据。-> 重载函数的函数类型不同。**3.函数默认参数和函数重载****函数重载的注意事项：****4.函数重载的本质**
Spring事务
c1tenj2的博客
08-07 432
以银行转账为例，一次转账操作伴随着一个账户的扣钱和另一个账户的加钱，这个流程是一个原子操作，要么同时发生，一气呵成，要么都不做。AccountServiceImpl实现AccountService接口，里面只有一个转账方法AccountMapper以及其映射文件account数据库测试代码用1/0模拟程序运行时出现异常的情况由于没有开启事务，出现了莫名其妙少了100块钱的情况，说明这个事务不是连续的。
反射和注解
supercool7的博客
08-08 253
反射的基本步骤包括获取Class对象、获取类的信息（构造函数、方法、字段等），然后通过Constructor、Method、Field等类的实例进行具体的操作。注解以@符号开头，通常紧跟着一个标识符，后面可以跟一些参数，用于给类、方法、字段等添加元数据信息，这些信息可以在编译时、运行时被读取和处理。通过Class类，可以获取类的构造函数、方法、字段等信息，而不需要在编译时确定这些信息。Spring、SpringBoot、Mybatis等框架中都大量使用了反射机制。此外，开发者还可以定义自己的注解，通过。
Java：继承，this，super
最新发布
m0_75257168的博客
08-10 268
可以同名，但参数列表不能相同（有参无参构造）
安卓Android & JAVA校招/实习面试合集:多线程、强软弱虚引用、进程、内存管理、Activity、Fragment......
qq_41915623的博客
08-10 269
安卓Android、java面试资料合集：内存管理、多线程、进程、强软弱虚应用、Activity
JVM 加载阶段 Class对象加载位置是在 堆中还是方法区？
萧曳丶
08-06 367
Class对象的加载位置：Class对象本身是加载到堆区中的。类的类型信息加载位置：类的类型信息（元数据）是加载到方法区（或元空间）中的。因此，对于问题“jvm 加载阶段 Class加载到堆中还是方法区”，答案是：Class对象加载到堆中，而类的类型信息加载到方法区（或元空间）中。这两个区域在JVM的类加载过程中都扮演着重要的角色，共同支持着Java程序的运行。
Spring一个强大便捷的代理工厂类
330553352的专栏
08-10 194
但如果你需要一种更加灵活和可配置性，那么Spring还提供了一个非常方便强大的ProxyFactoryBean类，该类特别适合那些需要更多自定义和控制的场景，例如当你需要为特定的Bean创建代理，或者需要在不修改原始代码的情况下为现有类添加额外的功能时。在Spring框架中，AOP（面向切面编程）是一种强大的编程范式，它允许开发者在不修改原有代码的情况下，为程序添加额外的功能，如日志记录、事务管理、安全控制等。在上面配置拦截器时，我们都是指定的具体拦截器，其实我们还可以使用通配符，指定拦截器。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

zjx0519

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

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

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

打赏作者

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

抵扣说明：

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

余额充值