Java中List集合

最新推荐文章于 2023-06-25 18:33:36 发布
最新推荐文章于 2023-06-25 18:33:36 发布
阅读量1.7k 收藏 1
点赞数
分类专栏： [---javaSE---] 文章标签： arraylist java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dzy21/article/details/51864988
版权

List集合

集合迭代

package com.cloud.list;
import java.util.ArrayList;
import java.util.List;
public class Demo1 {
   public static void main(String[] args) {
      List list=new ArrayList();
      list.add("Spring1");
      list.add("Spring2");
      list.add("Spring3");
      list.add("Spring4");
      for(int i=0;i<list.size();i++){
        System.out.println(list.get(i)+";");
      }
      List sublist=list.subList(1, 4);
      System.out.println(sublist);
   }
}

package com.cloud.list;
import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;
public class Demo2 {
         /**
          * @param args
          */
         public static void main(String[] args) {
                   // TODO Auto-generated method stub
                   List list=new ArrayList();
                   list.add("Spring1");
                   list.add("Spring2");
                   list.add("Spring3");
                   ListIterator it=list.listIterator();
                   it.next();
                   it.next();
                   it.set("Spring5");
                   /*
                   it.add("Spring4");
                  
                   while(it.hasNext()){
                            System.out.println(it.next());
                   }
                   */
                   System.out.println(list);
         }
}

正逆迭代

package com.cloud.list;
import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;
public class Demo3 {
         /**
          * @param args
          */
         public static void main(String[] args) {
                   // TODO Auto-generated method stub
                   List list=new ArrayList();
                   list.add("Spring1");
                   list.add("Spring2");
                   list.add("Spring3");
                   //一：for变量集合
                   for(int i=0;i<list.size();i++){
                            System.out.print(list.get(i)+";");
                   }
                   System.out.println();
                   //二：迭代器正序迭代
                   ListIterator it=list.listIterator();
                   while(it.hasNext()){
                            System.out.print(it.next()+";");
                   }
                   System.out.println();
                   //三：迭代器倒序迭代
                   while(it.hasPrevious()){
                            System.out.print(it.previous()+";");
                   }
         }
}

ArrayList集合

package com.cloud.list;
import java.util.ArrayList;
import java.util.Iterator;
/* ArrayList
 *  查询快，增删慢
 */
public class Demo4 {
   public static void main(String[] args) {
      ArrayList list=new ArrayList();
      list.add(new Book(1,"java编程1"));
      list.add(new Book(2,"java编程2"));
      list.add(new Book(3,"java编程3"));
      list.add(new Book(3,"java编程4"));
      System.out.println(list);
      ArrayList list2=clearRepeat(list);
      System.out.println(list2);
   }
   public static ArrayList clearRepeat(ArrayList list){
      //创建新的集合
      ArrayList newList=new ArrayList();
      //获取新的集合
      Iterator it= list.iterator();
      while(it.hasNext()){
        Book book=(Book) it.next();
        if(!newList.contains(book)){
           newList.add(book);
        }
      }
      return newList;
   }
}
class Book{
   int id;
   String name;
   public Book(int id,String name){
      this.id=id;
      this.name=name;
   }
   @Override
   public String toString() {
      // TODO Auto-generated method stub
      return "(编号："+this.id+";名字："+this.name+")";
   }
   @Override
   public boolean equals(Object obj) {
      Book book=(Book)obj;
      return this.id==book.id;
   }
   @Override
   public int hashCode() {
      // TODO Auto-generated method stub
      return super.hashCode();
   }
}

LinkedList集合

package com.cloud.list;

import java.util.Iterator;

import java.util.LinkedList;

public class Demo5 {

         /*

          LinkedList

           查询速度慢，增删快

          Linkedlist特有的方法：

         1：方法介绍

                     addFirst(E e)

                                     addLast(E e)

                  

                                     getFirst()

                                     getLast()

                                    

                                     removeFirst()

                                     removeLast()

        

         2：数据结构

                                     1：栈 （1.6）  : 主要是用于实现堆栈数据结构的存储方式。

                                               先进后出

                                               push()

                                               pop()

                                     2：队列（双端队列1.5）： 主要是为了让你们可以使用LinkedList模拟队列数据结构的存储方式。

                                               先进先出

                                               offer()

                                               poll()

                                              

         3：返回逆序的迭代器对象     

                            descendingIterator()   返回逆序的迭代器对象

          */

         public static void main(String[] args) {

                   LinkedList list=new LinkedList();

                   list.add("Spring2");

                   list.add("Spring3");

                   list.add("Spring4");

//               list.addFirst("Spring1");

//               list.push("Spring");//把该元素放到集合的首位置

//               System.out.println("集合的首元素"+list.pop());//移除并返回集合中的第一个元素

//               list.offer("Spring0");//添加到末尾位置

//               System.out.println(list);

                  

                   //逆向输出的迭代器

                   Iterator it = list.descendingIterator();

                   while (it.hasNext()) {

                            System.out.println(it.next()); 

                   }

         }

 

}

模拟集合中的值栈

package com.cloud.list;

 

import java.util.LinkedList;

 

public class Demo6 {

         /*

         2：数据结构

                   1：栈 （1.6）  : 主要是用于实现堆栈数据结构的存储方式。

                            先进后出

                            push()

                            pop()

                   2：队列（双端队列1.5）： 主要是为了让你们可以使用LinkedList模拟队列数据结构的存储方式。

                            先进先出

                            offer()

                            poll()

         */

         public static void main(String[] args) {

                   System.out.println("======测试值栈=======");

                   StackList list=new StackList();

                   list.add("Spring1");

                   list.add("Spring2");

                   list.add("Spring3");

//               System.out.println(list.pop());//删除并返回Spring3

//               System.out.println(list.pop());//删除并返回Spring2

//               System.out.println(list.pop());//删除并返回Spring1

                  

                   /*list.size()大小在不断的变化，所以很难遍历完

                   for(int i=0;i<list.size();i++){

                            System.out.println(list.pop());

                   }

                   */

                   int size=list.size();

                   for(int i=0;i<size;i++){

                            System.out.println(list.pop());

                  }

                   System.out.println("======测试队列=======");

                   TeamList list2=new TeamList();

                   list2.add("Spring1");

                   list2.add("Spring2");

                   list2.add("Spring3");

                   int size2=list2.size();

                   for(int i=0;i<size2;i++){

                            System.out.println(list2.remove());

                   }

         }

}

//模拟堆栈存储方式

class StackList{

         LinkedList list;

         public StackList(){

                   list=new LinkedList();

         }

         // 进栈

         public void add(Object o){

                   list.push(o);

         }

         //出栈

         public Object pop(){

                   return list.pop();

         }

         //大小

         public int size(){

                   return list.size();

         }

}

//模拟队列存储方式

class TeamList{

         LinkedList list;

         public TeamList(){

                   list=new LinkedList();

         }

         public void add(Object o){

                   list.offer(o);

         }

         public Object remove(){

                   return list.poll();

         }

         public int size(){

                   return list.size();

         }

}

 

模拟洗牌的案例

package com.cloud.day3;
import java.util.LinkedList;
import java.util.Random;
/*
 * 实现一副扑克牌的洗牌功能
 */
class Poker{
   String color;
   String num;
   public Poker(String color,String num){
      this.color=color;
      this.num=num;
   }
   public String toString(){
      return "{"+color+num+"}";
   }
}
public class Demo1 {
   public static void main(String[] args) {
      LinkedList<Poker> list=createPokers();
      System.out.println(list.size()+"张扑克牌");
      washPokers(list);
      showPokers(list);
   }
   //获取一副扑克牌
   public static LinkedList<Poker> createPokers(){
      LinkedList<Poker> list=new LinkedList<Poker>();
      String [] color={"红桃","黑桃","方块","梅花"};
      String [] nums={"A","2","3","4","5","6","7","8","9","10","J","Q","K"};
      for(int i=0;i<nums.length;i++){
        for(int j=0;j<color.length;j++){
           list.add(new Poker(color[j],nums[i]));
        }
      }
      return list;
   }
   //显示一副扑克牌
   public static void showPokers(LinkedList<Poker> list){
      for(int i=0;i<list.size();i++){
        System.out.print(list.get(i));
        if(i%10==9){
           System.out.println();
        }
      }
   }
   //刷新一副扑克牌
   public static void washPokers(LinkedList<Poker> pokers){
      Random random=new Random();
      for(int i=0;i<20;i++){
        //随机产生两个索引值
        int index1=random.nextInt(pokers.size());
        int index2=random.nextInt(pokers.size());
        //根据索引取出两张牌，然后交换顺序
        Poker poker1=pokers.get(index1);
        Poker poker2=pokers.get(index2);
        pokers.set(index1, poker2);
        pokers.set(index2, poker1);
      }
   }
}

集合比较大小

package com.cloud.day3;
import java.util.LinkedList;
public class Demo2 {
   public static void main(String[] args) {
      LinkedList<Person> list=new LinkedList<Person>();
      list.add(new Person("Spring1",13));
      list.add(new Person("Spring2",12));
      list.add(new Person("Spring3",11));
      for(int i=0;i<list.size()-1;i++){
        for(int j=i+1;j<list.size();j++){
           Person p1 = list.get(i);
           Person p2 = list.get(j);
           if(p1.age>p2.age){
              list.set(i, p2);
              list.set(j, p1);
           }
        }
      }
      System.out.println(list);
   }
}
class Person{
   String name;
   int age;
   public Person(String name,int age){
      this.name=name;
      this.age=age;
   }
   @Override
   public String toString() {
      return "[姓名："+this.name+";年龄："+this.age+"]";
   }
}
午-夜
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java中List集合及其实现类的方法详解
08-25
本篇文章给大家带来的内容是关于java中List集合及其实现类的方法介绍（附代码），有一定的参考价值，有需要的朋友可以参考一下，希望对你有所帮助。下面我们就来学习一下吧
Java集合-List
weixin_43200566的博客
11-30 1万+
java.util.List接口继承自Collection接口，是单列集合的一个重要分支，习惯性地会将实现了List接口的对象称为List集合，在List集合中允许出现重复的元素，所有的元素是以一种线性方式进行存储的，在程序中可以通过索引来访问集合中的指定元素，另外List集合还有一个特点就是元素有序，即元素的存入顺序和取出顺序一致
java基础语法（二十二）List
Apikaqiu的博客
04-27 1万+
List接口常用方法 1、List集合存储元素特点：有序可重复 有序：List集合中的元素有下标，从0开始，依次递增 可重复：存储的元素可以重复 2、List既然是Collection接口的子接口，那么肯定List接口有自己"特色"的方法; 以下只列出List接口特有的常用的方法 void add(int index,E element) 在列表的指定位置插...
【Java 基础篇】Java List 详解
最新发布
繁依Fanyi的博客
06-25 1万+
List接口继承自Collection接口，并添加了一些针对有序列表的操作。它允许元素的重复，并提供了根据索引访问、添加、删除和替换元素的方法。在Java中，List接口有几个常见的实现类，每个实现类都具有不同的性能和用途。ArrayList：基于动态数组实现，支持随机访问和快速遍历，适用于读取和修改操作较多的场景。LinkedList：基于双向链表实现，支持高效的插入和删除操作，适用于频繁的插入和删除操作。Vector：与ArrayList类似，但是线程安全，适用于多线程环境。
List集合详细讲解
m0_65725031的博客
06-28 1万+
list集合想必大家都是不陌生的，我们用的也是非常的多，但是可能大家在使用中，也不是对list集合有非常详细的讲解，今天小编就详细的带大家了解list集合。目录 一.集合之间的关系 二.List集合三.ArrayList集合 for循环删除方法01 for循环删除方法02for循环删除方法03foreach删除方法迭代器删除01迭代器删除元素02list集合删除方法 四.LinkedList集合五.Vector集合 六.CopyOnWriteArrayList集合 下方是一张UML图，vector，Arr
三大集合----list集合 超详细，完整易懂
YZZdear的博客
06-14 2469
如图所示： 今天我们要了解的是List集合！！学集合框架就是了解容器的数据结构（增删改查）自带方法使用如下： 用的最多的一般是前面两种。 堆栈和队列 堆栈的特点就是先进后出，队列的特点是先进先出 上图!!!!!!就是我们平常用的去除重复项，不过我们现在要来了解其底层逻辑今天用两个例子来举例，分别是字符串和实体对象 对象相比于字符串不同的是，对象需要在实体类重写equals方法 输出结果为
java中List集合及其遍历详解
09-03
主要介绍了java中List集合及其遍历详解的相关资料,需要的朋友可以参考下
java中List集合分页的方法
10-21
java中List集合分页的方法
Java中List集合的遍历实例详解
08-26
主要介绍了Java中List集合遍历实例详解，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
Java中对List集合的常用操作详解
09-02
下面小编就为大家带来一篇Java中对List集合的常用操作详解。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧
Java中List的简述
m0_47087822的博客
05-07 1万+
什么是 List 什么是集合 什么是 List List的继承、实现关系 List的种类 List的简单实用
Java之List详解
三木易的博客
12-01 7043
第一篇技术博客，为了照顾阅读源码经验少的同学，讲的很详细，并分享了静态阅读源码的一些经验。总结与提炼出了一些源码中的亮点，方便同学们提高自己的代码水平，能在业务中更好的运用。我一直秉承着业务驱动技术，技术服务于业务的思维来讲解一些真正能实践的技术点。
Java集合之List集合
TestXzing的博客
06-14 6271
学Java集合之List集合，这一篇不看我替你遗憾
List集合
weixin_45300957的博客
04-24 1313
List是一个接口，它继承自Collection接口。List表示的是一个元素有序的集合，可以根据插入顺序或其他某个规则来存储元素。List还提供了访问下标、添加、删除、查询等常规操作。这些操作受到集合的大小、容量、对内存的影响等多个因素的影响，因此我们需要在使用时选择具体的子类。List的底层实现可以是数组或链表。对于数组实现的List，元素的插入和删除是相对耗时的操作，因为需要进行数组的移位操作。而对于链表实现的List，插入和删除则可以达到O(1)的时间复杂度。
Java LIst集合全解
吾之奉先的博客
05-18 2万+
集合的优势： （1）数组存储的不足与缺陷： 长度开始必须执行，而且一旦指定，无法修改 保存的必须为同一类型的元素 使用数组进行增加/删除操作比较麻烦 （2）集合的好处： 可以动态保存多个对象，使用方便 提供了一系列方便的操作对象的方法，如add、remove、set、get等 使用集合增加/删除较方便 集合的框架图 (重要) 集合主要是两组：单列集合、双列集合 Collection接口有两个重要的子接口List、Set，他们的实现子类都是单列集合 Map接口的实现子类是双列集合，存放K-
Java基础之List
qq_45344586的博客
04-08 2348
Java基础之List
Java中List的详细用法
热门推荐
qq_41439608的博客
11-12 4万+
Java中List的详细用法 定义：List name = new ArrayList<>() 具体方法如下： 1.list中添加，获取，删除元素； 添加方法是：.add(e)；　　获取方法是：.get(index)；　　删除方法是：.remove(index)； 按照索引删除；　　.remove(Object o)； 按照元素内容删除； List<String> person = new ArrayList<>(); person.add("jackie");
Java集合类史上最细讲解 - List篇
大河之犬的博客
07-21 1619
链表（Linked list）是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存到下一个节点的地址。Java的设计者在这里获取了链表头节点的地址，以备后续进行删除，随后检查了一个头节点为空的异常，在。的变量出现，它的作用就是记录当前集合被修改的次数。原理操作和上面类似，只不过它初始的容量为指定的容量，需要扩容时扩容为原容量的1.5倍。先获取一下头节点后面的节点的地址，保存下来，然后将头节点的数据和。的增加和删除的操作效率更高，而查找和修改的操作效率较低。
深入了解Java中的List集合
技术随笔
06-01 2485
Java中的List集合是一种常用的数据结构，它提供了一种有序、可重复的元素集合。在开发中，我们经常需要使用List来存储和操作一组数据。本文将深入介绍Java中List集合的特性、常见的操作方法以及一些使用技巧，帮助读者更好地理解和应用List集合。
java中list集合
05-29
使用List集合，我们可以进行以下操作： 1. 添加元素：使用add()方法可以将元素添加到List中。 2. 获取元素：可以使用get()方法获取List中指定位置的元素。 3. 移除元素：使用remove()方法可以移除List中指定位置的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值