Java List 学习记录

已于 2022-05-29 18:56:38 修改
阅读量181 收藏
点赞数
分类专栏： 开发技能汇总 文章标签： 学习 java
于 2022-05-28 19:43:43 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_50902154/article/details/125016956
版权

List是有序的Collection，使用此接口能够精确的控制每个元素插入的位置。用户能够使用索引（元素在List中的位置，类似于数组下 >标）来访问List中的元素，这类似于Java的数组。 

迭代器

Java Iterator（迭代器）不是一个集合，它是一种用于访问集合的方法，可用于迭代 ArrayList 和 HashSet 等集合。

调用 it.next() 会返回迭代器的下一个元素，并且更新迭代器的状态。

调用 it.hasNext() 用于检测集合中是否还有元素。

调用 it.remove() 将迭代器返回的元素删除。

API

List list = new ArrayList();
		// 向列表的尾部追加指定的元素
		list.add("lwc");
		// 在列表的指定位置插入指定元素
		list.add(1, "nxj");
		// 追加指定 collection 中的所有元素到此列表的结尾
		list.addAll(new ArrayList());
		// 从列表中移除所有元素
		list.clear();
		// 如果列表包含指定的元素,则返回true
		list.contains("nxj");
		// 如果列表包含指定 collection 的所有元素,则返回 true
		list.containsAll(new ArrayList());
		// 比较指定的对象与列表是否相等
		list.equals(new ArrayList());
		// 返回列表中指定位置的元素
		list.get(0);
		// 返回列表的哈希码值
		list.hashCode();
		// 返回列表中首次出现指定元素的索引,如果列表不包含此元素,则返回 -1
		list.indexOf("lwc");
		// 返回列表中最后出现指定元素的索引,如果列表不包含此元素,则返回 -1
		list.lastIndexOf("lwc");
		// 如果列表不包含元素,则返回 true
		list.isEmpty();
		// 移除列表中指定位置的元素
		list.remove(0);
		// 移除列表中出现的首个指定元素
		list.remove("lwc");
		// 从列表中移除指定 collection 中包含的所有元素
		list.removeAll(new ArrayList());
		// 用指定元素替换列表中指定位置的元素
		list.set(0, "lp");
		// 返回列表中的元素数
		list.size();
		// 返回列表中指定的fromIndex(包括)和toIndex(不包括)之间的部分视图
		list.subList(1, 2);
		// 返回以正确顺序包含列表中的所有元素的数组
		list.toArray();
		// 返回以正确顺序包含列表中所有元素的数组
		list.toArray(new String[] { "a", "b" });

排序

简单数值排序 直接用Collections.sort( );方法

    List<Integer> list = new ArrayList<Integer>();
    list.add(new Integer(3));
    list.add(new Integer(14));
    list.add(new Integer(6));
    list.add(new Integer(10));
    Collections.sort(list);
    System.out.println(list.toString());

            复杂排序需要类继承Comparable 接口并重写 CompareTo方法

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class sort {
　　public static void main(String[] args) {
　　    List<User> list = new ArrayList<User>();
　　    list.add(new User("张三", 5));
　　    list.add(new User("李四", 30));
　　    list.add(new User("王五", 19));
　　    list.add(new User("王麻子", 17));
       // 按年龄排序
　　    Collections.sort(list); 
　　    System.out.println(list.toString());
　　}
}
 
 
class User implements Comparable<User>{
 
　　private String name; //姓名
　　private int age; // 年龄
 
　　public User(String name, int age) {
　　　　this.name = name;
　　　　this.age = age;
　　}
　　// getter && setter
　　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 String toString() {
　　　　return "User [name=" + name + ", age=" + age + "]";
　　}
 
　　@Override
　　public int compareTo(User user) {           
      // 重写Comparable接口的compareTo方法，根据年龄升序排列，降序修改相减顺序即可
　　　　return this.age - user.getAge();
　　}
}

        匿名内部类实现排序


import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class sort {
　　public static void main(String[] args) {
　　    List<User> list = new ArrayList<User>();
　　    list.add(new User("张三", 5));
　　    list.add(new User("李四", 30));
　　    list.add(new User("王五", 19));
　　    list.add(new User("王麻子", 17));
　　    Collections.sort(list, new Comparator<User>() {
　　　　    @Override
　　　　    public int compare(User u1, User u2) {
　　　　　　    int diff = u1.getAge() - u2.getAge();
　　　　　　    if (diff > 0) {
　　　　　　　　    return 1;
　　　　　　    }else if (diff < 0) {
　　　　　　　　    return -1;
　　　　　　    }
　　　　　　    return 0; //相等为0
　　　　    }
　　    }); // 按年龄排序
　　    System.out.println(list.toString());
　　}
}

遍历

可以用迭代器

List<String> list = new ArrayList<>();  
Iterator <String> it = list.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }

也可以直接 循环

for(int i = 0;i < list.size(); i ++){
    System.out.println(list.get(i));
}

循环....

for(String tmp:list){
    System.out.println(tmp);
}

package com.inspur.Test;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

@SuppressWarnings("unused")
public class MapTest {
    private static List<String> list= new ArrayList<String>();
    public static void main(String[]args){
        MapTest  mapTest = new  MapTest();
        mapTest.initList(mapTest.list);
        mapTest.iteratorList(list);
    }
    
    public List initList(List<String> list){
        int i=0;
        int num=6000000;
        for(i=0;i<num;i++){
            list.add("list"+i);
        }
        return list;
    }
  
    public void iteratorList(List<String> list){
        long start= System.currentTimeMillis();
        for(Iterator<String>  it=list.iterator();it.hasNext();){
            String value=it.next();
        }
    }
}

案例

package com.java.demoSet;

import java.util.*;

public class Only {
    public static void item(){
        List <String> list = new ArrayList<>();
        list.add("托尼弗格森");
        list.add("王伟琪");
        list.add("夜魔");
        for ( Iterator <String> it = list.iterator();it.hasNext();) {
            System.out.println(it.next());
        }
        String [] temp = (String [])list.toArray(new String [list.size()]);
        System.out.println(Arrays.toString(temp));
    }
    public static void getOnly(){
        String[] array = {"a","b","c","c","d","e","e","e","a"};
        Set set = new HashSet();
        for (int i = 0; i < array.length; i++) {
            set.add(array[i]);
        }
        String [] string = (String [])set.toArray(new String [set.size()]);
        System.out.println(Arrays.toString(string));
    }
    public  Only(){
        String[] array = {"a","b","c","c","d","e","e","e","a"};
        List<String> result = new ArrayList<>();
        boolean flag;
        for(int i=0;i<array.length;i++){
            flag = false;
            for(int j=0;j<result.size();j++){
                if(array[i].equals(result.get(j))){
                    flag = true;
                    break;
                }
            }
            if(!flag){
                result.add(array[i]);
            }
        }
        String[] arrayResult = (String[]) result.toArray(new String[result.size()]);
        System.out.println(Arrays.toString(arrayResult));
    }
    public static void main(String[] args) {
       // Only only = new Only();
       // Only.getOnly();
        Only.item();
    }
}

toArray()方法转string[]数组

List<String> strList = new ArrayList<String>();
strList.add("aa");
strList.add("bb");
//如果要变成String数组，需要强转类型。
final int size = strList.size();
String[] strs = (String[])strList.toArray(new String[size]);

List初始化转string[]数组

List<String> strList = new ArrayList<String>();
strList.add("aa");
strList.add("bb");
String[] strs = new String[strList.size()];

推荐用List自带的toArray()方法转string[]数组

删除元素

  public static void remove14(List<String> list, String target){
        for(int i = list.size() - 1; i >= 0; i--){
            String item = list.get(i);
            if(target.equals(item)){
                list.remove(item);
            }
        }
    }

//迭代器删除
  public static void remove32(List<String> list, String target){
        Iterator<String> iter = list.iterator();
        while (iter.hasNext()) {
            String item = iter.next();
            if (item.equals(target)) {
                iter.remove();
            }
        }

合并并删除重复数据

Set s=new TreeSet(l1);
for(Integer i:l2){
  //当添加不成功的时候 说明s中已经存在该对象
  s.add(i);
}
System.out.println(s);

手写合并操作（不难，写写更健康）

public static ArrayList addArrayList(ArrayList list1, ArrayList list2) {
    ArrayList list3 = new ArrayList();
    if (list1 == null || list1.size() == 0) {
        list3 = list2;
    } else if (list2 == null || list2.size() == 0) {
        list3 = list1;
    } else {
        for (int i = 0; i < list1.size(); i++) { // 遍历list1
            boolean isExist = false;
            for (int j = 0; j < list2.size(); j++) {
                if (list1.get(i).equals(list2.get(j))) {
                    isExist = true; // 找到相同项，跳出本层循环
                    break;
                }
            }
            if (!isExist) { // 不相同，加入list3中
                list3.add(list1.get(i));
            }
        }

        for (int k = 0; k < list2.size(); k++) {
            list3.add(list2.get(k));
        }
    }
    return list3;
}

LinkedList

public class Person1 implements Comparable < Person1 > {
    private Float height;
    private String name;

    Person1(float height) {
        this.height = height;
    }

    public Float getHeight() {
        return height;
    }

    public void setHeight(float height) {
        this.height = height;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override public int compareTo(Person1 p) {
        if (this.getHeight() < p.getHeight()) {
            return 1;

        } else if (this.getHeight() > p.getHeight()) {
            return - 1;
        } else {
            return 0;
        }
    }
}

public class Question3_1 {

    public static void main(String[] args) {
        Person1 p1 = new Person1(23.4f);
        p1.setName("Stud1");
        Person1 p2 = new Person1(2.34f);
        p2.setName("Stud2");
        Person1 p3 = new Person1(34.32f);
        p3.setName("Stud3");
        Person1 p4 = new Person1(56.45f);
        p4.setName("Stud4");
        Person1 p5 = new Person1(21.4f);
        p5.setName("Stud5");

        LinkedList < Person1 > al = new LinkedList < Person1 > ();

        al.add(p1);
        al.add(p2);
        al.add(p3);
        al.add(p4);
        al.add(p5);

        Collections.sort(al); //这里控制降序
        for (Person1 p: al) System.out.println(p.getName() + " " + p.getHeight());
    }
}

漆黑骑士
关注
专栏目录
java list排序
01-31
java开发，使用list对其进行排序，，易学简单。。。。。。。。。
java学习笔记markdown
03-12
【Java学习笔记Markdown版】是针对Java初学者和进阶者的一份详尽教程，以Markdown格式编写，便于阅读和整理。Markdown是一种轻量级的标记语言，它允许用户使用易读易写的纯文本格式编写文档，然后转换成结构化的HTML...
List 常用方法
sixyu的博客
07-29 325
package com.itlwc; import java.util.ArrayList; import java.util.List; public class Test { public static void main(String[] args) { List list = new ArrayList(); // 向列表的尾部追加
Java 集合全教程—List
最新发布
mh17680313750的博客
07-23 784
列表是一个有序的集合（有时称为序列）。列表可能包含重复的元素。位置访问-根据元素在列表中的数字位置来操作元素。这包括get、set、add、addAll和remove等方法。搜索-在列表中搜索指定的对象并返回其数字位置。搜索方法包括indexOf和lastIndexOf。迭代-扩展了Iterator语义，以利用列表的顺序性。listIterator方法提供了这种行为。范围视图-子列表方法对列表执行任意范围操作。Java平台包含两个通用的List实现。
java对list对象排序_java 对list中对象按属性排序
weixin_28697603的博客
02-12 151
实体对象类 --略排序类----实现Comparator接口，重写compare方法package com.tang.list;import java.util.Comparator;public class Mycompera implements Comparator {@Overridepublic int compare(Student o1, Student o2) {if (o1.ge...
java list 按属性排序_java list集合排序按某一属性排序操作
weixin_30249465的博客
02-12 1139
我就废话不多说了，大家还是直接看代码吧~public List sortList(List list){Collections.sort(list, new Comparator(){@Overridepublic int compare(FreightM o1, FreightM o2) {if(o1.getType()==0){return -1;}else{return 1;}}});ret...
java List集合学习
jy02324250的博客
09-09 226
感谢米聊java群的小伙伴的指导，特此记录 创建并使用二维List List<List<String>> str = new LinkedList<>(); //外层的 List<String> stringList = new LinkedList<>();//内层的 str.add(stringList);//内外关联 str.get...
Java基础 学习笔记 Markdownr版
06-27
本学习笔记主要涵盖了Java的基础知识，包括面向对象、集合、IO流、多线程、反射与动态代理以及Java 8的新特性等方面，旨在帮助初学者或有经验的开发者巩固和提升Java编程技能。 1. 面向对象（OOP）：Java的核心是...
java基础学习笔记.doc
10-08
以上是Java基础学习笔记中涉及的关键知识点，涵盖了输入输出、对象创建、随机数生成、数组和集合的使用以及字符串操作。这些是学习Java编程时的基础内容，深入理解和熟练运用这些知识将有助于进一步学习更复杂的Java...
Java基础尚硅谷宋红康学习笔记
05-29
【Java基础】 Java是一种广泛使用的面向对象的编程语言，由Sun Microsystems（现已被Oracle公司收购）于1995年发布。Java以其“一次编写，到处运行”的特性...通过深入学习和实践，你可以不断提升自己的Java编程能力。
学习Java基础知识 记录笔记练习代码 Java学习资料
06-25
4. **集合框架**：Java集合框架是处理对象组的重要工具，包括List（如ArrayList和LinkedList）、Set（如HashSet和TreeSet）和Map（如HashMap和TreeMap）。理解它们的区别和应用场景至关重要。 5. **输入输出流**：...
java list排序
weixin_34365417的博客
04-15 113
1、简介 　　这个和数组的排序又不一样了。 　　其实Java针对数组和List的排序都有实现，对数组而言，你可以直接使用Arrays.sort，对于List和Vector而言，你可以使用Collections.sort方法。 　　Java API针对集合类型的排序提供了2个方法: java.util.Collections.sort(java.util.List) java.ut...
Java集合list学习（一）：Java集合
qq_36955849的博客
11-25 342
Java集合 Java集合类是工作中运用最多的，最频繁的类，相比于数组（Array）来说，集合类的长度可变，更加适合于需求。 Java集合就像一个容器，可以存储任何类型的数据，也可以结合泛型来存储具体的类型对象，在程序运行时，Java集合可以动态的进行扩展，随着元素的增加而扩大。在Java中，集合类通常存在于java.util包中。 Java集合主要由2大体系构成，分别是Collection体系和...
java List学习（小白自学）
冷雨清的博客
11-01 264
java List学习 list有序列表(有顺序，可重复) Java 的 List 是非常常用的数据类型。 List 是有序的 Collection。 Java List 一共三个实现类： 分别是 ArrayList、 Vector 和 LinkedList 。 list接口结构图 ArrayList（数组,最常用的 List 实现类） 基于数组实现，无容量的限制。 在执行插入元素时可能要扩容，在删除元素时并不会减小数组的容量，在查找元素时要遍历数组，对于非null的元素采取equals的方式寻找。 是
java学习——List
weixin_43696229的博客
01-13 172
List List是一个接口，继承了Collection接口的功能，如果我们需要使用List，但是接口不能创建对象，这个时候我们就有三个实现类，ArrayList、Vector、LinkedList来帮助我们创建。 List<T> a = new ArrayList<>(); //<T>泛型是代表的任意数据类型String、Integer、以及自己创建的类 List<T> b = new Vector<>(); List<T> c =
List常用方法
欧菲丽的博客
05-18 1747
目录 list.addAll list.subList() list.indexOf() list.clear() list.equals(list2) list.isEmpty List定义时添加多条数据 list.remove(i) list.contains() list转数组 检验List是否存在重复的元素 Stream操作List List取出对象中某一属性 List，将id属性逗号拼接 List，将id属性逗号拼接后转换为Strnig类型 List转换为另一
list常用方法
w_La_la_la的博客
08-21 177
添加方法 .add()添加对象 .add(index,element)指定添加元素的位置【只能插入元素，若访问位置大于数组下标，则有异常】 .addAll(Arrays.asList(数组名称))添加数组中的所有元素 .addAll(index,Arrays.asList(数组名称))添加数组中所有元素到指定位置，同理下标不能越界。 修改方法 .set(index, element)将index索...
List的常用方法
小何的博客
05-11 611
List的常用方法
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值