api-day04

于 2023-01-01 18:16:48 发布
阅读量67 收藏
点赞数 1
文章标签： java jvm 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_60106686/article/details/128513118
版权

  回顾：

  精华笔记：

          技能点：list、集合与数组的转换、集合的排序；

一、List

     a.   List集;

        * java.util.List接口,继承自Collection.
        * List集合是可重复集,并且有序,有一套可以通过下标操作元素的方法;
        * 常用实现类:
              java.util.ArrayList:内部使用数组实现,查询性能更好.
              java.util.LinkedList:内部使用链表实现,首尾增删元素性能更好.

     b.   List集合常见方法;

          1)   get()与set()；       E get(int index) 获取指定下标对应的元素

                                          E set(int index,E e) 将给定元素设置到指定位置，返回值为该位置原有                                            的元素.。 替换元素操作！

           2)  重载的add()和remove()

                                            void add(int index,E e)  将给定元素插入到指定位置

                                              E remove(int index)   删除并返回指定位置上的元素

             3)subList()方法

                                     List subList(int start,int end)  : 获取当前集合中指定范围内的子集。两个参                                      数为开始与结束的下标(含头不含尾)；

二、集合与数组的转换；

            a. 集合转换为数组：toArray方法

           b.数组转换为List集合：静态方法asList()

三、集合的排序；

      1.java.util.Collections类

                集合的工具类,定义了很多静态方法用于操作集合.

                常见的两个子类型:
                      java.util.Set:不可重复的集合
                      java.util.List:可重复且有序的集合

       2.方法

                 Collections.sort(List list)方法:     对List集合进行自然排序(从小到大)；

                 重载的Collections.sort(List list,Comparator c)方法  ：排序自定义类型元素

  3. 排序自定义类型元素之侵入性

                  侵入性：当我们调用某个API功能时,其要求我们为其修改其他额外的代码,)去实现Comparable接口，不利于后期可维护性.应当尽量避免.

                   最终没有侵入性写法

 4..排序字符串

                java中提供的类,如:String,包装类都实现了Comparable接口;

                有时比较规则不能满足排序需求时,可以临时提供一种比较规则来进行排序.;

  笔记：

一、List

     a.   List集;

        * java.util.List接口,继承自Collection.
        * List集合是可重复集,并且有序,有一套可以通过下标操作元素的方法;
        * 常用实现类:
              java.util.ArrayList:内部使用数组实现,查询性能更好.
              java.util.LinkedList:内部使用链表实现,首尾增删元素性能更好.

     b.   List集合常见方法;

          1)   get()与set()；       E get(int index) 获取指定下标对应的元素

                                          E set(int index,E e) 将给定元素设置到指定位置，返回值为该位置原有的元素.。 替换元素操作！

    

package collection;
import java.util.ArrayList;
import java.util.List;
/**
* List集合
* List是Collection下面常见的一类集合。
* java.util.List接口是所有List的接口，它继承自Collection。
* 常见的实现类:
* java.util.ArrayList:内部由数组实现，查询性能更好。
* java.util.LinkedList:内部由链表实现，增删性能更好。
*
* List集合的特点是:可以存放重复元素，并且有序。其提供了一套可以通过下标
* 操作元素的方法。
*/
public class ListDemo {
  public static void main(String[] args) {
    List<String> list = new ArrayList<>();
//    List<String> list = new LinkedList<>();
    list.add("one");
    list.add("two");
    list.add("three");
    list.add("four");
    list.add("five");
    /*
      E get(int index)
      获取指定下标对应的元素
    */
    //获取第三个元素
    String e = list.get(2);
    System.out.println(e);
    for(int i=0;i<list.size();i++){
      e = list.get(i);
重载的add()和remove()
      System.out.println(e);
   }
    /*
      E set(int index,E e)
      将给定元素设置到指定位置，返回值为该位置原有的元素。
      替换元素操作
    */
    //[one,six,three,four,five]
    String old = list.set(1,"six");
    System.out.println(list);
    System.out.println("被替换的元素是:"+old);
 }
}

           2)  重载的add()和remove()

                                            void add(int index,E e)  将给定元素插入到指定位置

                                              E remove(int index)   删除并返回指定位置上的元素

package collection;
import java.util.ArrayList;
import java.util.List;
/**
* List集合提供了一对重载的add,remove方法
*/
public class ListDemo2 {
  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");
    System.out.println(list);
    /*
      void add(int index,E e)
      将给定元素插入到指定位置
    */
    //[one,two,six,three,four,five]
    list.add(2,"six");
    System.out.println(list);
    /*
      E remove(int index)
      删除并返回指定位置上的元素
    */
    //[one,six,three,four,five]
    String e = list.remove(1);
    System.out.println(list);
    System.out.println("被删除的元素:"+e);
 }
}
package collection;
import java.util.ArrayList;
import java.util.List;
/**
* List集合提供了一对重载的add,remove方法
*/
public class ListDemo2 {
  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");
    System.out.println(list);
    /*
      void add(int index,E e)
      将给定元素插入到指定位置
    */
    //[one,two,six,three,four,five]
    list.add(2,"six");
    System.out.println(list);
    /*
      E remove(int index)
      删除并返回指定位置上的元素
    */
    //[one,six,three,four,five]
    String e = list.remove(1);
    System.out.println(list);
    System.out.println("被删除的元素:"+e);
 }
}

             3)subList()方法

                                     List subList(int start,int end)  : 获取当前集合中指定范围内的子集。两个参数为开始与结束的下标(含头不含尾)。

package collection;
import java.util.ArrayList;
import java.util.List;
/**
* List subList(int start,int end)
* 获取当前集合中指定范围内的子集。两个参数为开始与结束的下标(含头不含尾)
*/
public class ListDemo3 {
  public static void main(String[] args) {
    List<Integer> list = new ArrayList<>();
    for(int i=0;i<10;i++){
      list.add(i);
   }
    System.out.println(list);
    //获取3-7这部分
    List<Integer> subList = list.subList(3,8);
    System.out.println(subList);
    //将子集每个元素扩大10倍
    for(int i=0;i<subList.size();i++){
      subList.set(i,subList.get(i) * 10);
   }
    //[30,40,50,60,70]
    System.out.println(subList);
    /*
      对子集元素的操作就是对原集合对应元素的操作
    */
    System.out.println(list);
    //删除list集合中的2-8
    list.subList(2,9).clear();
    System.out.println(list);
 }
}

二、集合与数组的转换；

            a. 集合转换为数组：toArray方法

                             重载的toArray方法要求传入一个数组，内部会将集合所有元素存入该数组
      后将其返回（前提是该数组长度>=集合的size）。如果给定的数组长度不足，
      则方法内部会自行根据给定数组类型创建一个与集合size一致长度的数组并
      将集合元素存入后返回。

package collection;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
/**
* 集合转换为数组
* Collection提供了方法toArray可以将当前集合转换为一个数组
数组转换为List集合
数组的工具类Arrays提供了一个静态方法asList(),可以将一个数组转换为一个List集合
*/
public class CollectionToArrayDemo {
  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");
    System.out.println(list);
//    Object[] array = list.toArray();
    /*
      重载的toArray方法要求传入一个数组，内部会将集合所有元素存入该数组
      后将其返回（前提是该数组长度>=集合的size）。如果给定的数组长度不足，
      则方法内部会自行根据给定数组类型创建一个与集合size一致长度的数组并
      将集合元素存入后返回。
    */
    String[] array = list.toArray(new String[list.size()]);
    System.out.println(array.length);
    System.out.println(Arrays.toString(array));
 }
}

             b.数组转换为List集合：静态方法asList()

package collection;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
/**
* 集合转换为数组
* Collection提供了方法toArray可以将当前集合转换为一个数组
数组转换为List集合
数组的工具类Arrays提供了一个静态方法asList(),可以将一个数组转换为一个List集合
*/
public class CollectionToArrayDemo {
  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");
    System.out.println(list);
//    Object[] array = list.toArray();
    /*
      重载的toArray方法要求传入一个数组，内部会将集合所有元素存入该数组
      后将其返回（前提是该数组长度>=集合的size）。如果给定的数组长度不足，
      则方法内部会自行根据给定数组类型创建一个与集合size一致长度的数组并
      将集合元素存入后返回。
    */
    String[] array = list.toArray(new String[list.size()]);
    System.out.println(array.length);
    System.out.println(Arrays.toString(array));
 }
}
package collection;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
/**
* 数组转换为List集合
* 数组的工具类Arrays提供了一个静态方法asList，可以将数组转换为一个List集合。
*/
public class ArrayToListDemo {
  public static void main(String[] args) {
    String[] array = {"one","two","three","four","five"};
    System.out.println(Arrays.toString(array));
    List<String> list = Arrays.asList(array);
    System.out.println(list);
    list.set(1,"six");
    System.out.println(list);
    //数组跟着改变了。注意:对数组转换的集合进行元素操作就是对原数组对应的操作
    System.out.println(Arrays.toString(array));
    /*
      由于数组是定长的，因此对该集合进行增删元素的操作是不支持的，会抛出
      异常:java.lang.UnsupportedOperationException
    */
//    list.add("seven");
    /*
集合的排序
java.util.Collections类
Collections是集合的工具类,里面定义了很多静态方法用于操作集合.
Collections.sort(List list)方法
可以对List集合进行自然排序(从小到大)
集合的排序
java.util.Collections类
      若希望对集合进行增删操作，则需要自行创建一个集合，然后将该集合元素
      导入。
    */
//    List<String> list2 = new ArrayList<>();
//    list2.addAll(list);
    /*
      所有的集合都支持一个参数为Collection的构造方法，作用是在创建当前
      集合的同时包含给定集合中的所有元素
    */
    List<String> list2 = new ArrayList<>(list);
    System.out.println("list2:"+list2);
    list2.add("seven");
    System.out.println("list2:"+list2);
 }
}

三、集合的排序；

      1.java.util.Collections类

                集合的工具类,定义了很多静态方法用于操作集合.

                常见的两个子类型:
                      java.util.Set:不可重复的集合
                      java.util.List:可重复且有序的集合

       2.方法

                 Collections.sort(List list)方法:     对List集合进行自然排序(从小到大)；

package collection;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Random;
/**
* 集合的排序
* 集合的工具类:java.util.Collections提供了一个静态方法sort,可以对List集合
* 进行自然排序
*/
public class SortListDemo1 {
  public static void main(String[] args) {
    List<Integer> list = new ArrayList<>();
    Random random = new Random();
    for(int i=0;i<10;i++){
      list.add(random.nextInt(100));
   }
    System.out.println(list);
    Collections.sort(list);
    System.out.println(list);
 }
}

                 重载的Collections.sort(List list,Comparator c)方法  ：排序自定义类型元素

package collection;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
/**
* 排序自定义类型元素
*/
public class SortListDemo2 {
  public static void main(String[] args) {
    List<Point> list = new ArrayList<>();
    list.add(new Point(1,2));
    list.add(new Point(97,88));
    list.add(new Point(7,6));
    list.add(new Point(9,9));
    list.add(new Point(5,4));
    list.add(new Point(2,3));
    System.out.println(list);
    /*
      Collections.sort(List list)在排序List集合时要求集合元素必须实现了
      Comparable接口。实现了该接口的类必须重写一个方法compareTo用与定义比较
      大小的规则，从而进行元素间的比较后排序。否则编译不通过。
      侵入性:
      当我们调用某个API时，其反过来要求我们为其修改其他额外的代码，这种现象就
      成为侵入性。侵入性不利于程序后期的维护，尽可能避免。
      compare:比较
    */
//    Collections.sort(list);
    //匿名内部类的形式创建一个比较器
    Comparator<Point> com = new Comparator<Point>() {
      @Override
      /**
      * 实现比较器接口后必须重写方法compare.
      * 该方法用来定义参数o1与参数o2的比较大小规则
      * 返回值用来表示o1与o2的大小关系
最终没有侵入性的写法
      */
      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;
     }
   };
    Collections.sort(list,com);//回调模式
    System.out.println(list);
 }
}

        3. 排序自定义类型元素之侵入性

                  侵入性：当我们调用某个API功能时,其要求我们为其修改其他额外的代码,)去实现Comparable接口，不利于后期可维护性.应当尽量避免.

package collection;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
/**
* 排序自定义类型元素
*/
public class SortListDemo2 {
  public static void main(String[] args) {
    List<Point> list = new ArrayList<>();
    list.add(new Point(1,2));
    list.add(new Point(97,88));
    list.add(new Point(7,6));
    list.add(new Point(9,9));
    list.add(new Point(5,4));
    list.add(new Point(2,3));
    System.out.println(list);
    /*
      编译不通过的原因:
      Collections.sort(List list)该方法要求集合中的元素类型必须实现接口:
      Comparable,该接口中有一个抽象方法compareTo,这个方法用来定义元素之间比较
      大小的规则.所以只有实现了该接口的元素才能利用这个方法比较出大小进而实现排序
实际开发中,我们并不会让我们自己定义的类(如果该类作为集合元素使用)去实现Comparable接口,因为
这对我们的程序有侵入性.
侵入性:当我们调用某个API功能时,其要求我们为其修改其他额外的代码,这个现象就是侵入性.侵入性越
强的API越不利于程序的后期可维护性.应当尽量避免.
重载的Collections.sort(List list,Comparator c)方法
      操作.
    */
    Collections.sort(list);//编译不通过 compare比较 comparable可以比较的
    System.out.println(list);
 }
}

                  最终没有侵入性写法

package collection;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
/**
* 排序自定义类型元素
*/
public class SortListDemo2 {
  public static void main(String[] args) {
    List<Point> list = new ArrayList<>();
    list.add(new Point(1,2));
    list.add(new Point(97,88));
    list.add(new Point(7,6));
    list.add(new Point(9,9));
    list.add(new Point(5,4));
    list.add(new Point(2,3));
    System.out.println(list);
    /*
      Collections.sort(List list)在排序List集合时要求集合元素必须实现了
      Comparable接口。实现了该接口的类必须重写一个方法compareTo用与定义比较
      大小的规则，从而进行元素间的比较后排序。否则编译不通过。
      侵入性:
      当我们调用某个API时，其反过来要求我们为其修改其他额外的代码，这种现象就
      称为侵入性。侵入性不利于程序后期的维护，尽可能避免。
      compare:比较
    */
//    Collections.sort(list);
排序字符串
java中提供的类,如:String,包装类都实现了Comparable接口,但有时候这些比较规则不能满足我们的排序
需求时,同样可以临时提供一种比较规则来进行排序.
    //匿名内部类的形式创建一个比较器
//    Comparator<Point> com = new Comparator<Point>() {
//      @Override
//      /**
//       * 实现比较器接口后必须重写方法compare.
//       * 该方法用来定义参数o1与参数o2的比较大小规则
//       * 返回值用来表示o1与o2的大小关系
//       */
//      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;
//      }
//    };
//    Collections.sort(list,com);//回调模式
//    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;
//      }
//    });
    Collections.sort(list,(o1,o2)->
        o1.getX() * o1.getX() + o1.getY() * o1.getY() -
        o2.getX() * o2.getX() - o2.getY() * o2.getY()
   );
    System.out.println(list);
 }
}

         4..排序字符串

                java中提供的类,如:String,包装类都实现了Comparable接口;

                有时比较规则不能满足排序需求时,可以临时提供一种比较规则来进行排序.;

package collection;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
/**
* 排序自定义类型元素
*/
public class SortListDemo2 {
  public static void main(String[] args) {
    List<Point> list = new ArrayList<>();
    list.add(new Point(1,2));
    list.add(new Point(97,88));
    list.add(new Point(7,6));
    list.add(new Point(9,9));
    list.add(new Point(5,4));
    list.add(new Point(2,3));
    System.out.println(list);
    /*
      Collections.sort(List list)在排序List集合时要求集合元素必须实现了
      Comparable接口。实现了该接口的类必须重写一个方法compareTo用与定义比较
      大小的规则，从而进行元素间的比较后排序。否则编译不通过。
      侵入性:
      当我们调用某个API时，其反过来要求我们为其修改其他额外的代码，这种现象就
      称为侵入性。侵入性不利于程序后期的维护，尽可能避免。
      compare:比较
    */
//    Collections.sort(list);
排序字符串
java中提供的类,如:String,包装类都实现了Comparable接口,但有时候这些比较规则不能满足我们的排序
需求时,同样可以临时提供一种比较规则来进行排序.
    //匿名内部类的形式创建一个比较器
//    Comparator<Point> com = new Comparator<Point>() {
//      @Override
//      /**
//       * 实现比较器接口后必须重写方法compare.
//       * 该方法用来定义参数o1与参数o2的比较大小规则
//       * 返回值用来表示o1与o2的大小关系
//       */
//      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;
//      }
//    };
//    Collections.sort(list,com);//回调模式
//    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;
//      }
//    });
    Collections.sort(list,(o1,o2)->
        o1.getX() * o1.getX() + o1.getY() * o1.getY() -
        o2.getX() * o2.getX() - o2.getY() * o2.getY()
   );
    System.out.println(list);
 }
}

补充：

陈序猿36
关注
核心类库常用方法初步总结
controler_的博客
07-31 148
核心库类常用方法初步总结 一、ArrayList常用方法 1.add(Object element):向列表的尾部添加指定的元素 2.size():返回列表中元素个数 3.get(int index):返回列表中指定位置的元素，index从0开始 4.add(int index,Object element):在列表的指定位置插入指定元素 5.set(int i,Object element):将索引位置元素替换为元素element，并返回被替 换的元素 6.clear():从列表
LinkedList的get(int index)方法分析
Toperli的博客
03-28 2421
问题：LinkedList底层基于链表结构，是没有索引（角标）的，那它的方法里面(get)怎么又通过索引来操作元素的呢？ 源码分析： public E get(int index) { checkElementIndex(index); return node(index).item; } Node<E> node(int index) { // assert is...
List集合
m0_51041464的博客
08-12 3634
侵入性:当我们调用某个API功能时,其要求我们为其修改其他额外的代码,这个现象就是侵入性.侵入性越强的API越不利于程序的后期可维护性.应当尽量避免.实际开发中,我们并不会让我们自己定义的类(如果该类作为集合元素使用)去实现Comparable接口,因为这对我们的程序有。E set(int index, E e):将给定元素设置到index指定的位置，返回值为该位置被替换的元素。java.util.LinkedList:内部使用链表实现，增删性能更好，首尾增删性能最佳。...
Java集合之ArrayList
骑着猪猪去旅行的博客
10-29 2091
Java集合之ArrayList
java中List集合三种获取集合元素方式
热门推荐
欢迎你的到来，我们一起加油！！！
08-20 4万+
java中List集合三种获取集合元素方式
WebAPI-day-01.md
10-23
自给学习整理的笔记，即可以为自给提供复习，也可以为大家提供帮助。喜欢请关注
day13_API-异常.pdf
11-02
Java 中的 Math、BigInteger 和 BigDecimal 类 Java 语言中提供了多种数学类来帮助开发者进行数学运算，包括 Math、BigInteger 和 BigDecimal 类。这些类提供了丰富的数学方法，帮助开发者快速高效地进行数学运算。...
Week06-Day04
03-13
在“Week06-Day04”的学习中，我们将深入探讨MySQL数据库系统，了解如何在JavaScript环境中，特别是Node.js（NPM）和Express框架下与MySQL进行交互，以及如何设计和实现RESTful API来构建Web服务。 MySQL是世界上最...
day01-day04.zip
最新发布
09-05
从提供的文件信息来看，我们关注的是一个名为"day01-day04.zip"的压缩包，它可能包含了一个为期四天的学习教程或者项目实战内容，特别是侧重于“框架实战”的第四阶段。由于标签为空，我们无法获取额外的分类信息，...
devops-test-day-app：天气控制API
02-11
d.weather API 天气报告和天气控制API。 叠放 PostgreSQL 雷迪斯 导轨6 Sidekiq用于后台处理，使用sidekiq-scheduler定期获取天气报告。 本地安装 创建Dockerfile并构建映像。 使用容器配置创建docker-compose...
集合框架C
m0_67517103的博客
04-10 880
什么是集合 集合和数组一样，保存一组元素，提供了操作元素的方法 java.util.Collection是所有集合的顶级接口 Collection下面有两个常见的子接口: java.util.List:线性表.是可重复集合,并且有序. java.util.Set:不可重复的集合,大部分实现类是无序的. 判定重复元素的标准是依靠元素自身equals比较的结果.为true就认为是重复元素. 方法： 1.boolean add(E e) 向当前元素添加一个元素，元素添加成功返回true E 参.
Java集合--list接口
weixin_33858485的博客
09-21 66
list是一个接口，实现类：Arraylist，Vector，Linkedlist list接口（有序）： 常用方法 排除Collection中具有的之外的 添加功能 void add(int index, E element)：在指定位置添加元素 boolean addAll(int index, Collection<? extends E> c)：在指定位置添加一组元...
RE:JAVA学习-集合操作
Lucky_WWW的博客
08-23 505
1.Iterator:迭代器 1.1 作用：对collection集合进行迭代（遍历集合） Collection c = new HashSet(); Iterator it= c.iterator();public class Collection_iterator { public static void main(String[] args)
【java基础】聊聊List
qq_43654226的博客
10-07 308
写在最前，本人也只是个大三的学生，如果你发现任何我写的不对的，请在评论中指出。   List， 在java里是一个接口，其常见的实现类有ArrayList和linkedList， 但是一般在编程中用的最多的还是ArrayList，究其原因，ArrayList的底层是数组， LinkedList的底层是双向链表， 而我们的开发需求中遍历的需求比增删要多，即使是增删也一般是在List的尾部添加元素即可，像是尾部添加元素，ArrayList的时间负责度也不过是O(1)。 对于ArrayList我们可以关注的第.
add(int index, E element) 在列表的指定位置插入元素
javaerSir的专栏
12-03 1万+
转载▼ void add(int index, E element) 在列表的指定位置插入指定元素（可选操作）。将当前处于该位置的元素（如果有的话）和所有后续元素向右移动（在其索引中加 1）。   参数：index - 要在其中插入指定元素处的索引element - 要插入的元素抛出：UnsupportedOperationException - 如
list.get(0) 和list.get(i)的区别
Architect_CSDN的博客
03-23 4万+
List&lt;People&gt;list=newArrayList&lt;People&gt;();for(inti=0;i&lt;list.size();i++){Peoplepeople=list.get(i);}//当i=0时，取得是list集合中第一个元素，//当i=1时，取得是list集合中第二个元素，......//当i=i时，取得是list集合中第i+1...
List获取指定位置元素
oBuTianBuNi的博客
03-10 1万+
ArrayList中怎么获取指定第几个元素，例如获取第5个元素，可以通过list.get(4)得到。 源码如下： public class ArrayList<E> extends AbstractList<E>implements List<E>, RandomAccess, Cloneable, java.io.Serializable { ...
26、线性表（List）
weixin_33937499的博客
06-27 72
1、List 　　List接口是Collection的子接口，List是一个可重复集合 2、ArrayList和LinkedList 　　ArrayList和LinkedList是List接口最常见的两个实现类，分别用动态数组和链表的方式实现了List接口。 3、get与set方法 　　List除了继承Collection定义的方法外，还根据其线性表的数据结构定义了一系列方法，其中最常用...
Java—List的使用【数据结构】
一朵花花
09-26 3280
List - 线性表List 常用方法 总览： List 接口继承于Collection接口 List 特指：线性表这一类数据结构，而List的典型实现有：Vector，ArrayList 和 LinkedList三个 其中 Vector 和 ArrayList 表示顺序表，而 LinkedList 表示链表 List 常用方法 ...
js-day01培训内容1
08-08
（3）解释性 每次运行JS代码时，得需要将原代码一行一行的解释执行 相对编译型语言（例如：Java、C++）执行速度相对较慢 （4）基于浏览器的动态交互网页技

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值